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.
Das AWS Encryption SDK ist so konzipiert, dass es einfach zu bedienen ist. Obwohl es AWS Encryption SDK mehrere Konfigurationsoptionen gibt, wurden die Standardwerte sorgfältig ausgewählt, damit sie für die meisten Anwendungen praktisch und sicher sind. Möglicherweise müssen Sie jedoch Ihre Konfiguration anpassen, um die Leistung zu verbessern, oder eine benutzerdefinierte Funktion in Ihr Design aufnehmen.
Lesen Sie sich bei der Konfiguration Ihrer Implementierung die AWS Encryption SDK bewährten Methoden durch und implementieren Sie so viele wie möglich.
Auswahl einer Programmiersprache
Das AWS Encryption SDK ist in mehreren Programmiersprachen verfügbar. Die Sprachimplementierungen sind so konzipiert, dass sie vollständig interoperabel sind und dieselben Funktionen bieten, obwohl sie möglicherweise auf unterschiedliche Weise implementiert werden. In der Regel verwenden Sie die Bibliothek, die mit Ihrer Anwendung kompatibel ist. Sie können jedoch eine Programmiersprache für eine bestimmte Implementierung auswählen. Wenn Sie beispielsweise lieber mit Schlüsselanhängern arbeiten, können Sie den AWS-Verschlüsselungs-SDK for C oder den AWS-Verschlüsselungs-SDK for JavaScript wählen.
Auswahl von Schlüsseln zum Umbrechen
Der AWS Encryption SDK generiert einen eindeutigen symmetrischen Datenschlüssel, um jede Nachricht zu verschlüsseln. Sofern Sie das Zwischenspeichern von Datenschlüsseln nicht verwenden, müssen Sie die Datenschlüssel nicht konfigurieren, verwalten oder verwenden. Das AWS Encryption SDK erledigt das für Sie.
Sie müssen jedoch einen oder mehrere Wrapping-Schlüssel auswählen, um jeden Datenschlüssel zu verschlüsseln. Der AWS Encryption SDK unterstützt AES symmetrische Schlüssel und RSA asymmetrische Schlüssel in verschiedenen Größen. Es unterstützt auch AWS Key Management Service(AWS KMS) symmetrische Verschlüsselung. AWS KMS keys Sie sind für die Sicherheit und Haltbarkeit Ihrer Wrapping-Schlüssel verantwortlich. Wir empfehlen Ihnen daher, einen Verschlüsselungsschlüssel in einem Hardware-Sicherheitsmodul oder einem wichtigen Infrastrukturdienst zu verwenden, z. B. AWS KMS
Um Ihre Wrapping-Schlüssel für die Verschlüsselung und Entschlüsselung anzugeben, verwenden Sie einen Schlüsselbund (C und JavaScript) oder einen Hauptschlüsselanbieter (Java, Python, AWS VerschlüsselungCLI). Sie können einen Umschließungsschlüssel oder mehrere Umschließungsschlüssel desselben oder verschiedener Typen angeben. Wenn Sie mehrere Umschließungsschlüssel verwenden, um einen Datenschlüssel zu umschließen, verschlüsselt jeder Umschließungsschlüssel eine Kopie desselben Datenschlüssels. Die verschlüsselten Datenschlüssel (einer pro Umschließungsschlüssel) werden zusammen mit den verschlüsselten Daten in der verschlüsselten Nachricht gespeichert, die AWS Encryption SDK zurückgegeben wird. Um die Daten zu entschlüsseln, AWS Encryption SDK
müssen sie zuerst einen Ihrer Verpackungsschlüssel verwenden, um einen verschlüsselten Datenschlüssel zu entschlüsseln.
Um AWS KMS key in einem Schlüsselbund oder einem Hauptschlüsselanbieter anzugeben, verwenden Sie eine unterstützte AWS KMS Schlüssel-ID. Einzelheiten zu den Schlüsselbezeichnern für einen AWS KMS Schlüssel finden Sie unter Schlüsselkennungen im AWS Key Management Service Entwicklerhandbuch.
-
Bei der Verschlüsselung mit der AWS-Verschlüsselungs-SDK for Java, AWS-Verschlüsselungs-SDK for JavaScript AWS-Verschlüsselungs-SDK for Python, oder der AWS Verschlüsselung CLI können Sie jede gültige Schlüssel-ID (Schlüssel-ID, SchlüsselARN, Aliasname oder AliasARN) für einen Schlüssel verwenden. KMS Bei der Verschlüsselung mit dem AWS-Verschlüsselungs-SDK for C können Sie nur eine Schlüssel-ID oder einen Schlüssel verwenden. ARN
Wenn Sie bei der Verschlüsselung einen Aliasnamen oder Alias ARN für einen KMS Schlüssel angeben, AWS Encryption SDK speichert der den Schlüssel, der ARN aktuell mit diesem Alias verknüpft ist. Der Alias wird nicht gespeichert. Änderungen am Alias wirken sich nicht auf den KMS Schlüssel aus, der zum Entschlüsseln Ihrer Datenschlüssel verwendet wird.
-
Bei der Entschlüsselung im strikten Modus (in dem Sie bestimmte Wrapping-Schlüssel angeben) müssen Sie einen Schlüssel ARN zur Identifizierung verwenden. AWS KMS keys Diese Anforderung gilt für alle Sprachenimplementierungen des AWS Encryption SDK.
Wenn Sie mit einem AWS KMS Schlüsselbund verschlüsseln, AWS Encryption SDK speichert der den Schlüssel ARN von AWS KMS key in den Metadaten des verschlüsselten Datenschlüssels. Bei der Entschlüsselung im strikten Modus AWS Encryption SDK überprüft der, ob derselbe Schlüssel im ARN Schlüsselbund (oder Hauptschlüsselanbieter) enthalten ist, bevor versucht wird, den verschlüsselten Datenschlüssel mit dem Wrapping-Schlüssel zu entschlüsseln. Wenn Sie eine andere Schlüssel-ID verwenden, AWS Encryption SDK wird sie nicht erkannt oder verwendet AWS KMS key, auch wenn sich die Kennungen auf denselben Schlüssel beziehen.
Um einen AESRohschlüssel oder ein RSARohschlüsselpaar als Umschließungsschlüssel in einem Schlüsselbund anzugeben, müssen Sie einen Namespace und einen Namen angeben. In einem Hauptschlüsselanbieter Provider
ID entspricht der dem Namespace und der Key ID entspricht dem Namen. Beim Entschlüsseln müssen Sie für jeden Rohverpackungsschlüssel genau denselben Namespace und denselben Namen verwenden wie beim Verschlüsseln. Wenn Sie einen anderen Namespace oder Namen verwenden, AWS Encryption SDK wird der Wrapping-Schlüssel nicht erkannt oder verwendet, selbst wenn das Schlüsselmaterial identisch ist.
Verwenden Sie mehrere Regionen AWS KMS keys
Sie können AWS Key Management Service (AWS KMS) Schlüssel mit mehreren Regionen verwenden, um Schlüssel in der einzuschließen. AWS Encryption SDK Wenn Sie mit einem Schlüssel für mehrere Regionen in einem verschlüsseln AWS-Region, können Sie mit einem zugehörigen Schlüssel für mehrere Regionen in einem anderen verschlüsseln. AWS-Region Die Support für Schlüssel mit mehreren Regionen wurde in Version 2.3 eingeführt. x der Version AWS Encryption SDK und Version 3.0. x der AWS VerschlüsselungCLI.
AWS KMS Schlüssel für mehrere Regionen bestehen aus AWS KMS keys verschiedenen Schlüsseln AWS-Regionen , die dasselbe Schlüsselmaterial und dieselbe Schlüssel-ID haben. Sie können diese verwandten Schlüssel so verwenden, als ob es sich um denselben Schlüssel in verschiedenen Regionen handeln würde. Schlüssel mit mehreren Regionen unterstützen gängige Notfallwiederherstellungs- und Sicherungsszenarien, bei denen die Verschlüsselung in einer Region und die Entschlüsselung in einer anderen Region erforderlich ist, ohne dass ein regionsübergreifender Anruf erforderlich ist. AWS KMSInformationen zu Schlüsseln für mehrere Regionen finden Sie unter Verwenden von Schlüsseln für mehrere Regionen im Entwicklerhandbuch.AWS Key Management Service
Zur Unterstützung von Schlüsseln für mehrere Regionen AWS Encryption SDK umfasst dies Schlüsselringe, die AWS KMS mehrere Regionen berücksichtigen, und Hauptschlüsselanbieter. Das neue Symbol für mehrere Regionen in jeder Programmiersprache unterstützt sowohl Schlüssel für einzelne Regionen als auch Schlüssel für mehrere Regionen.
In den Schlüsselbunden für mehrere Regionen und bei Anbietern von Hauptschlüsseln, die mehr als einen Schlüssel verwenden, können Sie mehrere Schlüssel für einzelne Regionen und Schlüssel für mehrere Regionen angeben. KMS Sie können jedoch nur einen Schlüssel aus jedem Satz verwandter Replikatschlüssel für mehrere Regionen angeben. Wenn Sie mehr als einen Schlüsselbezeichner mit derselben Schlüssel-ID angeben, schlägt der Konstruktoraufruf fehl.
Sie können auch einen Schlüssel für mehrere Regionen zusammen mit den standardmäßigen AWS KMS Schlüsselanhängern und Hauptschlüsselanbietern für einzelne Regionen verwenden. Sie müssen jedoch denselben Schlüssel für mehrere Regionen in derselben Region zum Verschlüsseln und Entschlüsseln verwenden. Die Schlüsselringe für einzelne Regionen und die Anbieter von Masterschlüsseln versuchen, Chiffretext nur mit den Schlüsseln zu entschlüsseln, mit denen die Daten verschlüsselt wurden.
Die folgenden Beispiele zeigen, wie Daten mithilfe von Schlüsseln für mehrere Regionen und den neuen Schlüsselanhängern und Masterschlüsselanbietern, die mehrere Regionen unterstützen, ver- und entschlüsselt werden. In diesen Beispielen werden Daten in der Region verschlüsselt und die Daten in der us-east-1 Region mithilfe verwandter multiregionaler Replikatschlüssel in jeder us-west-2 Region entschlüsselt. Bevor Sie diese Beispiele ausführen, ersetzen Sie den Beispielschlüssel für mehrere Regionen durch einen ARN gültigen Wert aus Ihrem. AWS-Konto
- C
-
Um mit einem Schlüssel für mehrere Regionen zu verschlüsseln, verwenden Sie die Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder() Methode, um den Schlüsselbund zu instanziieren. Geben Sie einen Schlüssel für mehrere Regionen an.
Dieses einfache Beispiel enthält keinen Verschlüsselungskontext. Ein Beispiel, das einen Verschlüsselungskontext in C verwendet, finden Sie unterVerschlüsseln und Entschlüsseln von Zeichenfolgen.
Ein vollständiges Beispiel finden Sie unter kms_multi_region_keys.cpp im AWS-Verschlüsselungs-SDK for C Repository unter GitHub.
/* Encrypt with a multi-Region KMS key in us-east-1 */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Initialize a multi-Region keyring */
const char *mrk_us_east_1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
struct aws_cryptosdk_keyring *mrk_keyring =
Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder().Build(mrk_us_east_1);
/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_ENCRYPT, mrk_keyring);
aws_cryptosdk_keyring_release(mrk_keyring);
/* Encrypt the data
* aws_cryptosdk_session_process_full is designed for non-streaming data
*/
aws_cryptosdk_session_process_full(
session, ciphertext, ciphertext_buf_sz, &ciphertext_len, plaintext, plaintext_len));
/* Clean up the session */
aws_cryptosdk_session_destroy(session);
- C# / .NET
-
Um mit einem Schlüssel für mehrere Regionen in der Region USA Ost (Nord-Virginia) (us-east-1) zu verschlüsseln, instanziieren Sie ein CreateAwsKmsMrkKeyringInput Objekt mit einer Schlüssel-ID für den Schlüssel für mehrere Regionen und einem Client für die angegebene Region. AWS KMS Verwenden Sie dann die Methode, um den Schlüsselbund zu erstellen. CreateAwsKmsMrkKeyring()
Die CreateAwsKmsMrkKeyring() Methode erstellt einen Schlüsselbund mit genau einem Schlüssel für mehrere Regionen. Verwenden Sie die Methode, um mit mehreren Umschließungsschlüsseln, einschließlich eines Schlüssels für mehrere Regionen, zu verschlüsseln. CreateAwsKmsMrkMultiKeyring()
Ein vollständiges Beispiel finden Sie unter AwsKmsMrkKeyringExample.cs im Forum. AWS Encryption SDK NETRepository aktiviert. GitHub
//Encrypt with a multi-Region KMS key in us-east-1 Region
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Multi-Region keys have a distinctive key ID that begins with 'mrk'
// Specify a multi-Region key in us-east-1
string mrkUSEast1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
// Create the keyring
// You can specify the Region or get the Region from the key ARN
var createMrkEncryptKeyringInput = new CreateAwsKmsMrkKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USEast1),
KmsKeyId = mrkUSEast1
};
var mrkEncryptKeyring = materialProviders.CreateAwsKmsMrkKeyring(createMrkEncryptKeyringInput);
// Define the encryption context
var encryptionContext = new Dictionary<string, string>()
{
{"purpose", "test"}
};
// Encrypt your plaintext data.
var encryptInput = new EncryptInput
{
Plaintext = plaintext,
Keyring = mrkEncryptKeyring,
EncryptionContext = encryptionContext
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);
- AWS Encryption CLI
-
In diesem Beispiel wird die hello.txt Datei unter einem Schlüssel für mehrere Regionen in der Region us-east-1 verschlüsselt. Da in dem Beispiel ein Schlüssel ARN mit einem Region-Element angegeben wird, wird in diesem Beispiel das Region-Attribut des Parameters nicht verwendet. --wrapping-keys
Wenn die Schlüssel-ID des Wrapping-Schlüssels keine Region angibt, können Sie das Region-Attribut von verwenden, --wrapping-keys um die Region anzugeben, z. --wrapping-keys key=$keyID region=us-east-1 B.
# Encrypt with a multi-Region KMS key in us-east-1 Region
# To run this example, replace the fictitious key ARN with a valid value.
$ mrkUSEast1=arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab
$ aws-encryption-cli --encrypt \
--input hello.txt \
--wrapping-keys key=$mrkUSEast1 \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--output .
- Java
-
Um mit einem Schlüssel für mehrere Regionen zu verschlüsseln, instanziieren Sie einen AwsKmsMrkAwareMasterKeyProvider und geben Sie einen Schlüssel für mehrere Regionen an.
Ein vollständiges Beispiel finden Sie im Repository unter BasicMultiRegionKeyEncryptionExample.java. AWS-Verschlüsselungs-SDK for Java GitHub
//Encrypt with a multi-Region KMS key in us-east-1 Region
// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
// Multi-Region keys have a distinctive key ID that begins with 'mrk'
// Specify a multi-Region key in us-east-1
final String mrkUSEast1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
// Instantiate an AWS KMS master key provider in strict mode for multi-Region keys
// Configure it to encrypt with the multi-Region key in us-east-1
final AwsKmsMrkAwareMasterKeyProvider kmsMrkProvider = AwsKmsMrkAwareMasterKeyProvider
.builder()
.buildStrict(mrkUSEast1);
// Create an encryption context
final Map<String, String> encryptionContext = Collections.singletonMap("Purpose", "Test");
// Encrypt your plaintext data
final CryptoResult<byte[], AwsKmsMrkAwareMasterKey> encryptResult = crypto.encryptData(
kmsMrkProvider,
encryptionContext,
sourcePlaintext);
byte[] ciphertext = encryptResult.getResult();
- JavaScript Browser
-
Um mit einem Schlüssel für mehrere Regionen zu verschlüsseln, verwenden Sie die buildAwsKmsMrkAwareStrictMultiKeyringBrowser() Methode, um den Schlüsselbund zu erstellen, und geben Sie einen Schlüssel für mehrere Regionen an.
Ein vollständiges Beispiel finden Sie unter kms_multi_region_simple.ts im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub
/* Encrypt with a multi-Region KMS key in us-east-1 Region */
import {
buildAwsKmsMrkAwareStrictMultiKeyringBrowser,
buildClient,
CommitmentPolicy,
KMS,
} from '@aws-crypto/client-browser'
/* Instantiate an AWS Encryption SDK client */
const { encrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
declare const credentials: {
accessKeyId: string
secretAccessKey: string
sessionToken: string
}
/* Instantiate an AWS KMS client
* The AWS-Verschlüsselungs-SDK for JavaScript gets the Region from the key ARN
*/
const clientProvider = (region: string) => new KMS({ region, credentials })
/* Specify a multi-Region key in us-east-1 */
const multiRegionUsEastKey =
'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
/* Instantiate the keyring */
const encryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringBrowser({
generatorKeyId: multiRegionUsEastKey,
clientProvider,
})
/* Set the encryption context */
const context = {
purpose: 'test',
}
/* Test data to encrypt */
const cleartext = new Uint8Array([1, 2, 3, 4, 5])
/* Encrypt the data */
const { result } = await encrypt(encryptKeyring, cleartext, {
encryptionContext: context,
})
- JavaScript Node.js
-
Um mit einem Schlüssel für mehrere Regionen zu verschlüsseln, verwenden Sie die Methode, um den Schlüsselbund zu erstellen, und geben Sie einen Schlüssel für mehrere Regionen an. buildAwsKmsMrkAwareStrictMultiKeyringNode()
Ein vollständiges Beispiel finden Sie unter kms_multi_region_simple.ts im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub
//Encrypt with a multi-Region KMS key in us-east-1 Region
import { buildClient } from '@aws-crypto/client-node'
/* Instantiate the AWS Encryption SDK client
const { encrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
/* Test string to encrypt */
const cleartext = 'asdf'
/* Multi-Region keys have a distinctive key ID that begins with 'mrk'
* Specify a multi-Region key in us-east-1
*/
const multiRegionUsEastKey =
'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
/* Create an AWS KMS keyring */
const mrkEncryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringNode({
generatorKeyId: multiRegionUsEastKey,
})
/* Specify an encryption context */
const context = {
purpose: 'test',
}
/* Create an encryption keyring */
const { result } = await encrypt(mrkEncryptKeyring, cleartext, {
encryptionContext: context,
})
- Python
-
Um mit einem Schlüssel für mehrere Regionen zu verschlüsseln, verwenden Sie die Methode und geben Sie einen Schlüssel für AWS KMS mehrere Regionen an. MRKAwareStrictAwsKmsMasterKeyProvider()
Ein vollständiges Beispiel finden Sie unter mrk_aware_kms_provider.py im AWS-Verschlüsselungs-SDK for Python Repository unter. GitHub
* Encrypt with a multi-Region KMS key in us-east-1 Region
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT)
# Specify a multi-Region key in us-east-1
mrk_us_east_1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab"
# Use the multi-Region method to create the master key provider
# in strict mode
strict_mrk_key_provider = MRKAwareStrictAwsKmsMasterKeyProvider(
key_ids=[mrk_us_east_1]
)
# Set the encryption context
encryption_context = {
"purpose": "test"
}
# Encrypt your plaintext data
ciphertext, encrypt_header = client.encrypt(
source=source_plaintext,
encryption_context=encryption_context,
key_provider=strict_mrk_key_provider
)
Verschieben Sie als Nächstes Ihren Chiffretext in die us-west-2 Region. Sie müssen den Chiffretext nicht erneut verschlüsseln.
Um den Chiffretext im strikten Modus in der us-west-2 Region zu entschlüsseln, instanziieren Sie das Symbol für mehrere Regionen mit dem Schlüssel des zugehörigen Multiregions-Schlüssels in der Region. ARN us-west-2 Wenn Sie den Schlüssel ARN eines zugehörigen Schlüssels mit mehreren Regionen in einer anderen Region angeben (einschließlich des Ortes, an dem er verschlüsselt wurde)us-east-1, führt das Symbol für mehrere Regionen einen regionsübergreifenden Aufruf für diesen Schlüssel aus. AWS KMS key
Bei der Entschlüsselung im strikten Modus ist für das Symbol für mehrere Regionen ein Schlüssel erforderlich. ARN Es akzeptiert nur einen Schlüssel ARN aus jedem Satz verwandter Schlüssel für mehrere Regionen.
Bevor Sie diese Beispiele ausführen, ersetzen Sie den Beispielschlüssel für mehrere Regionen ARN durch einen gültigen Wert aus Ihrem. AWS-Konto
- C
-
Um im strikten Modus mit einem Schlüssel für mehrere Regionen zu entschlüsseln, verwenden Sie die Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder() Methode, um den Schlüsselbund zu instanziieren. Geben Sie den zugehörigen Schlüssel für mehrere Regionen in der lokalen Region (us-west-2) an.
Ein vollständiges Beispiel finden Sie unter kms_multi_region_keys.cpp im AWS-Verschlüsselungs-SDK for C Repository unter. GitHub
/* Decrypt with a related multi-Region KMS key in us-west-2 Region */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Initialize a multi-Region keyring */
const char *mrk_us_west_2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
struct aws_cryptosdk_keyring *mrk_keyring =
Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder().Build(mrk_us_west_2);
/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_ENCRYPT, mrk_keyring);
aws_cryptosdk_session_set_commitment_policy(session,
COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT);
aws_cryptosdk_keyring_release(mrk_keyring);
/* Decrypt the ciphertext
* aws_cryptosdk_session_process_full is designed for non-streaming data
*/
aws_cryptosdk_session_process_full(
session, plaintext, plaintext_buf_sz, &plaintext_len, ciphertext, ciphertext_len));
/* Clean up the session */
aws_cryptosdk_session_destroy(session);
- C# / .NET
-
Um im strikten Modus mit einem einzigen Schlüssel für mehrere Regionen zu entschlüsseln, verwenden Sie dieselben Konstruktoren und Methoden, mit denen Sie die Eingabe zusammengestellt und den Schlüsselbund für die Verschlüsselung erstellt haben. Instanziieren Sie ein CreateAwsKmsMrkKeyringInput Objekt mit dem Schlüssel ARN eines zugehörigen Multiregions-Schlüssels und einem AWS KMS Client für die Region USA West (Oregon) (us-west-2). Verwenden Sie dann die CreateAwsKmsMrkKeyring() Methode, um einen Schlüsselbund für mehrere Regionen mit einem Schlüssel für mehrere Regionen zu erstellen. KMS
Ein vollständiges Beispiel finden Sie unter AwsKmsMrkKeyringExample.cs im Forum. AWS Encryption SDK NETRepository aktiviert. GitHub
// Decrypt with a related multi-Region KMS key in us-west-2 Region
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Specify the key ARN of the multi-Region key in us-west-2
string mrkUSWest2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
// Instantiate the keyring input
// You can specify the Region or get the Region from the key ARN
var createMrkDecryptKeyringInput = new CreateAwsKmsMrkKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
KmsKeyId = mrkUSWest2
};
// Create the multi-Region keyring
var mrkDecryptKeyring = materialProviders.CreateAwsKmsMrkKeyring(createMrkDecryptKeyringInput);
// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
Ciphertext = ciphertext,
Keyring = mrkDecryptKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
- AWS Encryption CLI
-
Um mit dem zugehörigen Schlüssel für mehrere Regionen in der Region us-west-2 zu entschlüsseln, verwenden Sie das Schlüsselattribut des --wrapping-keys Parameters, um seinen Schlüssel anzugeben. ARN
# Decrypt with a related multi-Region KMS key in us-west-2 Region
# To run this example, replace the fictitious key ARN with a valid value.
$ mrkUSWest2=arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys key=$mrkUSWest2 \
--commitment-policy require-encrypt-require-decrypt \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output .
- Java
-
Um im strikten Modus zu entschlüsseln, instanziieren Sie einen AwsKmsMrkAwareMasterKeyProvider und geben Sie den zugehörigen Schlüssel für mehrere Regionen in der lokalen Region (us-west-2) an.
Ein vollständiges Beispiel finden Sie unter .java im Repository unterBasicMultiRegionKeyEncryptionExample. AWS-Verschlüsselungs-SDK for Java GitHub
// Decrypt with a related multi-Region KMS key in us-west-2 Region
// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
// Related multi-Region keys have the same key ID. Their key ARNs differs only in the Region field.
String mrkUSWest2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
// Use the multi-Region method to create the master key provider
// in strict mode
AwsKmsMrkAwareMasterKeyProvider kmsMrkProvider = AwsKmsMrkAwareMasterKeyProvider.builder()
.buildStrict(mrkUSWest2);
// Decrypt your ciphertext
CryptoResult<byte[], AwsKmsMrkAwareMasterKey> decryptResult = crypto.decryptData(
kmsMrkProvider,
ciphertext);
byte[] decrypted = decryptResult.getResult();
- JavaScript Browser
-
Um im strikten Modus zu entschlüsseln, verwenden Sie die buildAwsKmsMrkAwareStrictMultiKeyringBrowser() Methode, um den Schlüsselbund zu erstellen, und geben Sie den zugehörigen Schlüssel für mehrere Regionen in der lokalen Region (us-west-2) an.
Ein vollständiges Beispiel finden Sie unter kms_multi_region_simple.ts im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub
/* Decrypt with a related multi-Region KMS key in us-west-2 Region */
import {
buildAwsKmsMrkAwareStrictMultiKeyringBrowser,
buildClient,
CommitmentPolicy,
KMS,
} from '@aws-crypto/client-browser'
/* Instantiate an AWS Encryption SDK client */
const { decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
declare const credentials: {
accessKeyId: string
secretAccessKey: string
sessionToken: string
}
/* Instantiate an AWS KMS client
* The AWS-Verschlüsselungs-SDK for JavaScript gets the Region from the key ARN
*/
const clientProvider = (region: string) => new KMS({ region, credentials })
/* Specify a multi-Region key in us-west-2 */
const multiRegionUsWestKey =
'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
/* Instantiate the keyring */
const mrkDecryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringBrowser({
generatorKeyId: multiRegionUsWestKey,
clientProvider,
})
/* Decrypt the data */
const { plaintext, messageHeader } = await decrypt(mrkDecryptKeyring, result)
- JavaScript Node.js
-
Um im strikten Modus zu entschlüsseln, verwenden Sie die buildAwsKmsMrkAwareStrictMultiKeyringNode() Methode, um den Schlüsselbund zu erstellen, und geben Sie den zugehörigen Schlüssel für mehrere Regionen in der lokalen Region (us-west-2) an.
Ein vollständiges Beispiel finden Sie unter kms_multi_region_simple.ts im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub
/* Decrypt with a related multi-Region KMS key in us-west-2 Region */
import { buildClient } from '@aws-crypto/client-node'
/* Instantiate the client
const { decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
/* Multi-Region keys have a distinctive key ID that begins with 'mrk'
* Specify a multi-Region key in us-west-2
*/
const multiRegionUsWestKey =
'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
/* Create an AWS KMS keyring */
const mrkDecryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringNode({
generatorKeyId: multiRegionUsWestKey,
})
/* Decrypt your ciphertext */
const { plaintext, messageHeader } = await decrypt(decryptKeyring, result)
- Python
-
Um im strikten Modus zu entschlüsseln, verwenden Sie die Methode, um den Hauptschlüsselanbieter zu erstellen. MRKAwareStrictAwsKmsMasterKeyProvider() Geben Sie den zugehörigen Schlüssel für mehrere Regionen in der lokalen Region (us-west-2) an.
Ein vollständiges Beispiel finden Sie unter mrk_aware_kms_provider.py im AWS-Verschlüsselungs-SDK for Python Repository unter. GitHub
# Decrypt with a related multi-Region KMS key in us-west-2 Region
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT)
# Related multi-Region keys have the same key ID. Their key ARNs differs only in the Region field
mrk_us_west_2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab"
# Use the multi-Region method to create the master key provider
# in strict mode
strict_mrk_key_provider = MRKAwareStrictAwsKmsMasterKeyProvider(
key_ids=[mrk_us_west_2]
)
# Decrypt your ciphertext
plaintext, _ = client.decrypt(
source=ciphertext,
key_provider=strict_mrk_key_provider
)
Sie können auch im Discovery-Modus mit Schlüsseln für AWS KMS
mehrere Regionen entschlüsseln. Beim Entschlüsseln im Discovery-Modus geben Sie keine an. AWS KMS keys(Informationen zu Schlüsselanhängern für die AWS KMS Erkennung einzelner Regionen finden Sie unter.) Verwenden Sie einen Discovery-Schlüsselbund AWS KMS
Wenn Sie mit einem Schlüssel für mehrere Regionen verschlüsselt haben, versucht das Symbol für mehrere Regionen im Erkennungsmodus, die Entschlüsselung mithilfe eines zugehörigen Regionsschlüssels in der lokalen Region durchzuführen. Wenn keine vorhanden ist, schlägt der Anruf fehl. Im Erkennungsmodus versucht der nicht, den Schlüssel für mehrere Regionen, der für die Verschlüsselung verwendet AWS Encryption SDK wird, regionsübergreifend aufzurufen.
Wenn Sie im Erkennungsmodus ein Symbol für mehrere Regionen verwenden, um Daten zu verschlüsseln, schlägt der Verschlüsselungsvorgang fehl.
Das folgende Beispiel zeigt, wie im Erkennungsmodus mit dem Symbol für mehrere Regionen entschlüsselt wird. Da Sie kein angeben AWS KMS key, AWS Encryption SDK muss die Region aus einer anderen Quelle abgerufen werden. Wenn möglich, geben Sie die lokale Region explizit an. Andernfalls AWS Encryption SDK ruft der die lokale Region aus der Region ab, die AWS SDK in Ihrer Programmiersprache konfiguriert ist.
Bevor Sie diese Beispiele ausführen, ersetzen Sie die Beispielkonto-ID und den Schlüssel für mehrere Regionen ARN durch gültige Werte aus Ihrem AWS-Konto.
- C
-
Um im Discovery-Modus mit einem Schlüssel für mehrere Regionen zu entschlüsseln, verwenden Sie die Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder() Methode, um den Schlüsselbund zu erstellen, und die Methode, um den Aws::Cryptosdk::KmsKeyring::DiscoveryFilter::Builder() Discovery-Filter zu erstellen. Um die lokale Region anzugeben, definieren Sie a ClientConfiguration und geben Sie sie im Client an. AWS KMS
Ein vollständiges Beispiel finden Sie unter kms_multi_region_keys.cpp im AWS-Verschlüsselungs-SDK for C Repository unter GitHub.
/* Decrypt in discovery mode with a multi-Region KMS key */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Construct a discovery filter for the account and partition. The
* filter is optional, but it's a best practice that we recommend.
*/
const char *account_id = "111122223333";
const char *partition = "aws";
const std::shared_ptr<Aws::Cryptosdk::KmsKeyring::DiscoveryFilter> discovery_filter =
Aws::Cryptosdk::KmsKeyring::DiscoveryFilter::Builder(partition).AddAccount(account_id).Build();
/* Create an AWS KMS client in the desired region. */
const char *region = "us-west-2";
Aws::Client::ClientConfiguration client_config;
client_config.region = region;
const std::shared_ptr<Aws::KMS::KMSClient> kms_client =
Aws::MakeShared<Aws::KMS::KMSClient>("AWS_SAMPLE_CODE", client_config);
struct aws_cryptosdk_keyring *mrk_keyring =
Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder()
.WithKmsClient(kms_client)
.BuildDiscovery(region, discovery_filter);
/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_DECRYPT, mrk_keyring);
aws_cryptosdk_keyring_release(mrk_keyring);
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
/* Decrypt the ciphertext
* aws_cryptosdk_session_process_full is designed for non-streaming data
*/
aws_cryptosdk_session_process_full(
session, plaintext, plaintext_buf_sz, &plaintext_len, ciphertext, ciphertext_len));
/* Clean up the session */
aws_cryptosdk_session_destroy(session);
- C# / .NET
-
Um einen Discovery-Schlüsselbund für mehrere Regionen im Formular zu erstellen. AWS Encryption SDK NET, instanziieren Sie ein CreateAwsKmsMrkDiscoveryKeyringInput Objekt, das einen AWS KMS Client für ein bestimmtes Objekt verwendet AWS-Region, und einen optionalen Erkennungsfilter, der KMS Schlüssel auf eine bestimmte Partition und ein bestimmtes Konto beschränkt. AWS Rufen Sie dann die CreateAwsKmsMrkDiscoveryKeyring() Methode mit dem Eingabeobjekt auf. Ein vollständiges Beispiel finden Sie unter AwsKmsMrkDiscoveryKeyringExample.cs im Forum AWS Encryption SDK . NETRepository aktiviert. GitHub
Um einen Schlüsselbund für mehrere Regionen zu erstellen, verwenden Sie die Methode, um einen Schlüsselbund für mehrere Regionen zu erstellen AWS-Region, oder verwenden Sie die CreateAwsKmsMrkDiscoveryMultiKeyring() Methode, um mehrere Schlüsselbunde für die Erkennung mehrerer Regionen CreateAwsKmsMrkDiscoveryKeyring() zu erstellen, und kombinieren Sie sie dann mit der Methode zu einem Schlüsselbund mit mehreren Schlüsselbunden. CreateMultiKeyring()
Ein AwsKmsMrkDiscoveryMultiKeyringExampleBeispiel finden Sie unter .cs.
// Decrypt in discovery mode with a multi-Region KMS key
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
List<string> account = new List<string> { "111122223333" };
// Instantiate the discovery filter
DiscoveryFilter mrkDiscoveryFilter = new DiscoveryFilter()
{
AccountIds = account,
Partition = "aws"
}
// Create the keyring
var createMrkDiscoveryKeyringInput = new CreateAwsKmsMrkDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
DiscoveryFilter = mrkDiscoveryFilter
};
var mrkDiscoveryKeyring = materialProviders.CreateAwsKmsMrkDiscoveryKeyring(createMrkDiscoveryKeyringInput);
// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
Ciphertext = ciphertext,
Keyring = mrkDiscoveryKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
- AWS Encryption CLI
-
Verwenden Sie das Discovery-Attribut des Parameters, um im Discovery-Modus zu entschlüsseln. --wrapping-keys Die Attribute discovery-account und discovery-partition erstellen einen Discovery-Filter, der optional, aber empfohlen wird.
Um die Region anzugeben, enthält dieser Befehl das Regionsattribut des Parameters. --wrapping-keys
# Decrypt in discovery mode with a multi-Region KMS key
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys discovery=true \
discovery-account=111122223333 \
discovery-partition=aws \
region=us-west-2 \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output .
- Java
-
Verwenden Sie den builder().withDiscoveryMrkRegion Parameter, um die lokale Region anzugeben. Andernfalls AWS Encryption SDK ruft der die lokale Region aus der Region ab, die in der konfiguriert ist AWS SDK for Java.
Ein vollständiges Beispiel finden Sie unter DiscoveryMultiRegionDecryptionExample.java im AWS-Verschlüsselungs-SDK for Java Repository unter GitHub.
// Decrypt in discovery mode with a multi-Region KMS key
// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
DiscoveryFilter discoveryFilter = new DiscoveryFilter("aws", 111122223333);
AwsKmsMrkAwareMasterKeyProvider mrkDiscoveryProvider = AwsKmsMrkAwareMasterKeyProvider
.builder()
.withDiscoveryMrkRegion(Region.US_WEST_2)
.buildDiscovery(discoveryFilter);
// Decrypt your ciphertext
final CryptoResult<byte[], AwsKmsMrkAwareMasterKey> decryptResult = crypto
.decryptData(mrkDiscoveryProvider, ciphertext);
- JavaScript Browser
-
Verwenden Sie die Methode, um im Discovery-Modus mit einem symmetrischen Schlüssel für mehrere Regionen zu entschlüsseln. AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser()
Ein vollständiges Beispiel finden Sie unter kms_multi_region_discovery.ts im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub
/* Decrypt in discovery mode with a multi-Region KMS key */
import {
AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser,
buildClient,
CommitmentPolicy,
KMS,
} from '@aws-crypto/client-browser'
/* Instantiate an AWS Encryption SDK client */
const { decrypt } = buildClient()
declare const credentials: {
accessKeyId: string
secretAccessKey: string
sessionToken: string
}
/* Instantiate the KMS client with an explicit Region */
const client = new KMS({ region: 'us-west-2', credentials })
/* Create a discovery filter */
const discoveryFilter = { partition: 'aws', accountIDs: ['111122223333'] }
/* Create an AWS KMS discovery keyring */
const mrkDiscoveryKeyring = new AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser({
client,
discoveryFilter,
})
/* Decrypt the data */
const { plaintext, messageHeader } = await decrypt(mrkDiscoveryKeyring, ciphertext)
- JavaScript Node.js
-
Verwenden Sie die Methode, um im Discovery-Modus mit einem symmetrischen Schlüssel für mehrere Regionen zu entschlüsseln. AwsKmsMrkAwareSymmetricDiscoveryKeyringNode()
Ein vollständiges Beispiel finden Sie unter kms_multi_region_discovery.ts im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub
/* Decrypt in discovery mode with a multi-Region KMS key */
import {
AwsKmsMrkAwareSymmetricDiscoveryKeyringNode,
buildClient,
CommitmentPolicy,
KMS,
} from '@aws-crypto/client-node'
/* Instantiate the Encryption SDK client
const { decrypt } = buildClient()
/* Instantiate the KMS client with an explicit Region */
const client = new KMS({ region: 'us-west-2' })
/* Create a discovery filter */
const discoveryFilter = { partition: 'aws', accountIDs: ['111122223333'] }
/* Create an AWS KMS discovery keyring */
const mrkDiscoveryKeyring = new AwsKmsMrkAwareSymmetricDiscoveryKeyringNode({
client,
discoveryFilter,
})
/* Decrypt your ciphertext */
const { plaintext, messageHeader } = await decrypt(mrkDiscoveryKeyring, result)
- Python
-
Verwenden Sie die Methode, um im Discovery-Modus mit einem Schlüssel für mehrere Regionen zu entschlüsseln. MRKAwareDiscoveryAwsKmsMasterKeyProvider()
Ein vollständiges Beispiel finden Sie unter mrk_aware_kms_provider.py im AWS-Verschlüsselungs-SDK for Python Repository unter. GitHub
# Decrypt in discovery mode with a multi-Region KMS key
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient()
# Create the discovery filter and specify the region
decrypt_kwargs = dict(
discovery_filter=DiscoveryFilter(account_ids="111122223333", partition="aws"),
discovery_region="us-west-2",
)
# Use the multi-Region method to create the master key provider
# in discovery mode
mrk_discovery_key_provider = MRKAwareDiscoveryAwsKmsMasterKeyProvider(**decrypt_kwargs)
# Decrypt your ciphertext
plaintext, _ = client.decrypt(
source=ciphertext,
key_provider=mrk_discovery_key_provider
)
Auswahl einer Algorithmus-Suite
Die AWS Encryption SDK unterstützt mehrere symmetrische und asymmetrische Verschlüsselungsalgorithmen zur Verschlüsselung Ihrer Datenschlüssel unter den von Ihnen angegebenen Wrapping-Schlüsseln. Wenn diese Datenschlüssel jedoch zur Verschlüsselung Ihrer Daten verwendet werden, wird AWS Encryption SDK standardmäßig eine empfohlene Algorithmussuite verwendet, die den GCM Algorithmus AES - mit Schlüsselableitung, digitalen Signaturen und Schlüsselbindung verwendet. Obwohl die Standard-Algorithmus-Suite wahrscheinlich für die meisten Anwendungen geeignet ist, können Sie auch eine alternative Algorithmussuite wählen. Einige Vertrauensmodelle würden beispielsweise durch eine Algorithmus-Suite ohne digitale Signaturen erfüllt. Hinweise zu den von der AWS Encryption SDK
unterstützten Algorithmus-Suites finden Sie unterUnterstützte Algorithmen-Pakete im AWS Encryption SDK.
Die folgenden Beispiele zeigen Ihnen, wie Sie beim Verschlüsseln eine alternative Algorithmus-Suite auswählen. In diesen Beispielen wird eine empfohlene AES GCM Algorithmus-Suite mit Schlüsselableitung und Schlüsselzusage ausgewählt, jedoch ohne digitale Signaturen. Wenn Sie mit einer Algorithmus-Suite verschlüsseln, die keine digitalen Signaturen enthält, verwenden Sie beim Entschlüsseln den Entschlüsselungsmodus nur ohne Vorzeichen. Dieser Modus schlägt fehl, wenn er auf einen signierten Chiffretext trifft, und ist vor allem bei der Streaming-Entschlüsselung nützlich.
- C
-
Um eine alternative Algorithmus-Suite in der anzugeben AWS-Verschlüsselungs-SDK for C, müssen Sie explizit eine erstellen. CMM Verwenden Sie dann die aws_cryptosdk_default_cmm_set_alg_id mit der CMM und der ausgewählten Algorithmus-Suite.
/* Specify an algorithm suite without signing */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
/* To set an alternate algorithm suite, create an cryptographic
materials manager (CMM) explicitly
*/
struct aws_cryptosdk_cmm *cmm = aws_cryptosdk_default_cmm_new(aws_default_allocator(), kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
/* Specify the algorithm suite for the CMM */
aws_cryptosdk_default_cmm_set_alg_id(cmm, ALG_AES256_GCM_HKDF_SHA512_COMMIT_KEY);
/* Construct the session with the CMM,
then release the CMM reference
*/
struct aws_cryptosdk_session *session = aws_cryptosdk_session_new_from_cmm_2(alloc, AWS_CRYPTOSDK_ENCRYPT, cmm);
aws_cryptosdk_cmm_release(cmm);
/* Encrypt the data
Use aws_cryptosdk_session_process_full with non-streaming data
*/
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(
session,
ciphertext,
ciphertext_buf_sz,
&ciphertext_len,
plaintext,
plaintext_len)) {
aws_cryptosdk_session_destroy(session);
return AWS_OP_ERR;
}
Verwenden AWS_CRYPTOSDK_DECRYPT_UNSIGNED Sie beim Entschlüsseln von Daten, die ohne digitale Signaturen verschlüsselt wurden. Dies führt dazu, dass die Entschlüsselung fehlschlägt, wenn signierter Chiffretext gefunden wird.
/* Decrypt unsigned streaming data */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
/* Create a session for decrypting with the AWS KMS keyring
Then release the keyring reference
*/
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT_UNSIGNED, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
if (!session) {
return AWS_OP_ERR;
}
/* Limit encrypted data keys */
aws_cryptosdk_session_set_max_encrypted_data_keys(session, 1);
/* Decrypt
Use aws_cryptosdk_session_process_full with non-streaming data
*/
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(
session,
plaintext,
plaintext_buf_sz,
&plaintext_len,
ciphertext,
ciphertext_len)) {
aws_cryptosdk_session_destroy(session);
return AWS_OP_ERR;
}
- C# / .NET
-
Um eine alternative Algorithmus-Suite im Formular anzugeben. AWS Encryption SDK NET, geben Sie die AlgorithmSuiteId Eigenschaft eines EncryptInputObjekts an. Das AWS Encryption SDK für. NETenthält Konstanten, anhand derer Sie Ihre bevorzugte Algorithmussuite identifizieren können.
Das AWS Encryption SDK für. NETverfügt nicht über eine Methode zur Erkennung von signiertem Chiffretext bei der Streaming-Entschlüsselung, da diese Bibliothek keine Streaming-Daten unterstützt.
// Specify an algorithm suite without signing
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Create the keyring
var keyringInput = new CreateAwsKmsKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = keyArn
};
var keyring = materialProviders.CreateAwsKmsKeyring(keyringInput);
// Encrypt your plaintext data
var encryptInput = new EncryptInput
{
Plaintext = plaintext,
Keyring = keyring,
AlgorithmSuiteId = AlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);
- AWS Encryption CLI
-
Bei der Verschlüsselung der hello.txt Datei verwendet dieses Beispiel den --algorithm Parameter, um eine Algorithmussuite ohne digitale Signaturen anzugeben.
# Specify an algorithm suite without signing
# 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
$ aws-encryption-cli --encrypt \
--input hello.txt \
--wrapping-keys key=$keyArn \
--algorithm AES_256_GCM_HKDF_SHA512_COMMIT_KEY \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt \
--output hello.txt.encrypted \
--decode
Bei der Entschlüsselung verwendet dieses Beispiel den --decrypt-unsigned Parameter. Dieser Parameter wird empfohlen, um sicherzustellen, dass Sie unsignierten Chiffretext entschlüsseln, insbesondere bei der, bei der immer ein- und CLI ausgegebene Daten gestreamt werden.
# Decrypt unsigned streaming data
# 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
$ aws-encryption-cli --decrypt-unsigned \
--input hello.txt.encrypted \
--wrapping-keys key=$keyArn \
--max-encrypted-data-keys 1 \
--commitment-policy require-encrypt-require-decrypt \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--output .
- Java
-
Verwenden Sie die Methode, um eine alternative Algorithmus-Suite anzugeben. AwsCrypto.builder().withEncryptionAlgorithm() Dieses Beispiel spezifiziert eine alternative Algorithmussuite ohne digitale Signaturen.
// Specify an algorithm suite without signing
// Instantiate the client
AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY)
.build();
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
// Create a master key provider in strict mode
KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
.buildStrict(awsKmsKey);
// Create an encryption context to identify this ciphertext
Map<String, String> encryptionContext = Collections.singletonMap("Example", "FileStreaming");
// Encrypt your plaintext data
CryptoResult<byte[], KmsMasterKey> encryptResult = crypto.encryptData(
masterKeyProvider,
sourcePlaintext,
encryptionContext);
byte[] ciphertext = encryptResult.getResult();
Verwenden Sie beim Streamen von Daten zur Entschlüsselung diese createUnsignedMessageDecryptingStream() Methode, um sicherzustellen, dass der gesamte Chiffretext, den Sie entschlüsseln, nicht signiert ist.
// Decrypt unsigned streaming data
// Instantiate the client
AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.withMaxEncryptedDataKeys(1)
.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);
// Decrypt the encrypted message
FileInputStream in = new FileInputStream(srcFile + ".encrypted");
CryptoInputStream<KmsMasterKey> decryptingStream = crypto.createUnsignedMessageDecryptingStream(masterKeyProvider, in);
// Return the plaintext data
// Write the plaintext data to disk
FileOutputStream out = new FileOutputStream(srcFile + ".decrypted");
IOUtils.copy(decryptingStream, out);
decryptingStream.close();
- JavaScript Browser
-
Um eine alternative Algorithmussuite anzugeben, verwenden Sie den suiteId Parameter mit einem Enum-Wert. AlgorithmSuiteIdentifier
// Specify an algorithm suite without signing
// Instantiate the client
const { encrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )
// Specify a KMS key
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
// Create a keyring with the KMS key
const keyring = new KmsKeyringBrowser({ generatorKeyId })
// Encrypt your plaintext data
const { result } = await encrypt(keyring, cleartext, { suiteId: AlgorithmSuiteIdentifier.ALG_AES256_GCM_IV12_TAG16_HKDF_SHA512_COMMIT_KEY, encryptionContext: context, })
Verwenden Sie beim Entschlüsseln die decrypt Standardmethode. AWS-Verschlüsselungs-SDK for JavaScript hat im Browser keinen decrypt-unsigned Modus, weil der Browser kein Streaming unterstützt.
// Decrypt unsigned streaming data
// Instantiate the client
const { decrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )
// Create a keyring with the same KMS key used to encrypt
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
const keyring = new KmsKeyringBrowser({ generatorKeyId })
// Decrypt the encrypted message
const { plaintext, messageHeader } = await decrypt(keyring, ciphertextMessage)
- JavaScript Node.js
-
Um eine alternative Algorithmus-Suite anzugeben, verwenden Sie den suiteId Parameter mit einem AlgorithmSuiteIdentifier Enum-Wert.
// Specify an algorithm suite without signing
// Instantiate the client
const { encrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )
// Specify a KMS key
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
// Create a keyring with the KMS key
const keyring = new KmsKeyringNode({ generatorKeyId })
// Encrypt your plaintext data
const { result } = await encrypt(keyring, cleartext, { suiteId: AlgorithmSuiteIdentifier.ALG_AES256_GCM_IV12_TAG16_HKDF_SHA512_COMMIT_KEY, encryptionContext: context, })
Verwenden decryptUnsignedMessage Sie Stream, wenn Sie Daten entschlüsseln, die ohne digitale Signaturen verschlüsselt wurden. Diese Methode schlägt fehl, wenn sie auf signierten Chiffretext trifft.
// Decrypt unsigned streaming data
// Instantiate the client
const { decryptUnsignedMessageStream } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )
// Create a keyring with the same KMS key used to encrypt
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
const keyring = new KmsKeyringNode({ generatorKeyId })
// Decrypt the encrypted message
const outputStream = createReadStream(filename) .pipe(decryptUnsignedMessageStream(keyring))
- Python
-
Um einen alternativen Verschlüsselungsalgorithmus anzugeben, verwenden Sie den algorithm Parameter mit einem Algorithm Enum-Wert.
# Specify an algorithm suite without signing
# Instantiate a client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT,
max_encrypted_data_keys=1)
# 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 the plaintext using an alternate algorithm suite
ciphertext, encrypted_message_header = client.encrypt(
algorithm=Algorithm.AES_256_GCM_HKDF_SHA512_COMMIT_KEY, source=source_plaintext, key_provider=kms_key_provider
)
Verwenden Sie beim Entschlüsseln von Nachrichten, die ohne digitale Signaturen verschlüsselt wurden, den decrypt-unsigned Streaming-Modus, insbesondere beim Entschlüsseln während des Streamings.
# Decrypt unsigned streaming data
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT,
max_encrypted_data_keys=1)
# 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]
)
# Decrypt with decrypt-unsigned
with open(ciphertext_filename, "rb") as ciphertext, open(cycled_plaintext_filename, "wb") as plaintext:
with client.stream(mode="decrypt-unsigned",
source=ciphertext,
key_provider=master_key_provider) as decryptor:
for chunk in decryptor:
plaintext.write(chunk)
# Verify that the encryption context
assert all(
pair in decryptor.header.encryption_context.items() for pair in encryptor.header.encryption_context.items()
)
return ciphertext_filename, cycled_plaintext_filename
Beschränkung verschlüsselter Datenschlüssel
Sie können die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht einschränken. Diese bewährte Methode kann Ihnen helfen, einen falsch konfigurierten Schlüsselbund beim Verschlüsseln oder einen bösartigen Chiffretext beim Entschlüsseln zu erkennen. Es verhindert auch unnötige, teure und potenziell erschöpfende Zugriffe auf Ihre Schlüsselinfrastruktur. Die Einschränkung verschlüsselter Datenschlüssel ist am wertvollsten, wenn Sie Nachrichten aus einer nicht vertrauenswürdigen Quelle entschlüsseln.
Obwohl die meisten verschlüsselten Nachrichten einen verschlüsselten Datenschlüssel für jeden bei der Verschlüsselung verwendeten Umschließungsschlüssel haben, kann eine verschlüsselte Nachricht bis zu 65.535 verschlüsselte Datenschlüssel enthalten. Ein böswilliger Akteur könnte eine verschlüsselte Nachricht mit Tausenden von verschlüsselten Datenschlüsseln erstellen, von denen keiner entschlüsselt werden kann. In der Folge AWS Encryption SDK würde versucht werden, jeden verschlüsselten Datenschlüssel zu entschlüsseln, bis alle verschlüsselten Datenschlüssel in der Nachricht aufgebraucht sind.
Verwenden Sie den MaxEncryptedDataKeys Parameter, um die Anzahl der verschlüsselten Datenschlüssel einzuschränken. Dieser Parameter ist ab Version 1.9 für alle unterstützten Programmiersprachen verfügbar. x und 2.2. x der AWS Encryption SDK. Es ist optional und gültig beim Verschlüsseln und Entschlüsseln. In den folgenden Beispielen werden Daten entschlüsselt, die mit drei verschiedenen Wrapping-Schlüsseln verschlüsselt wurden. Der MaxEncryptedDataKeys Wert ist auf 3 festgelegt.
- C
-
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn1, { key_arn2, key_arn3 });
/* Create a session */
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
/* Limit encrypted data keys */
aws_cryptosdk_session_set_max_encrypted_data_keys(session, 3);
/* Decrypt */
size_t ciphertext_consumed_output;
aws_cryptosdk_session_process(session,
plaintext_output,
plaintext_buf_sz_output,
&plaintext_len_output,
ciphertext_input,
ciphertext_len_input,
&ciphertext_consumed_output);
assert(aws_cryptosdk_session_is_done(session));
assert(ciphertext_consumed == ciphertext_len);
- C# / .NET
-
Um verschlüsselte Datenschlüssel im Formular AWS Encryption SDK einzuschränken. NET, instanziieren Sie einen Client für das AWS Encryption SDK for. NETund setzen Sie seinen optionalen MaxEncryptedDataKeys Parameter auf den gewünschten Wert. Rufen Sie dann die Decrypt() Methode auf der konfigurierten AWS Encryption SDK
Instanz auf.
// Decrypt with limited data keys
// Instantiate the material providers
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Configure the commitment policy on the AWS Encryption SDK instance
var config = new AwsEncryptionSdkConfig
{
MaxEncryptedDataKeys = 3
};
var encryptionSdk = AwsEncryptionSdkFactory.CreateAwsEncryptionSdk(config);
// Create the keyring
string keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
var createKeyringInput = new CreateAwsKmsKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = keyArn
};
var decryptKeyring = materialProviders.CreateAwsKmsKeyring(createKeyringInput);
// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
Ciphertext = ciphertext,
Keyring = decryptKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
- AWS Encryption CLI
-
# Decrypt with limited encrypted data keys
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys key=$key_arn1 key=$key_arn2 key=$key_arn3 \
--buffer \
--max-encrypted-data-keys 3 \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--output .
- Java
-
// Construct a client with limited encrypted data keys
final AwsCrypto crypto = AwsCrypto.builder()
.withMaxEncryptedDataKeys(3)
.build();
// Create an AWS KMS master key provider
final KmsMasterKeyProvider keyProvider = KmsMasterKeyProvider.builder()
.buildStrict(keyArn1, keyArn2, keyArn3);
// Decrypt
final CryptoResult<byte[], KmsMasterKey> decryptResult = crypto.decryptData(keyProvider, ciphertext)
- JavaScript Browser
-
// Construct a client with limited encrypted data keys
const { encrypt, decrypt } = buildClient({ maxEncryptedDataKeys: 3 })
declare const credentials: {
accessKeyId: string
secretAccessKey: string
sessionToken: string
}
const clientProvider = getClient(KMS, {
credentials: { accessKeyId, secretAccessKey, sessionToken }
})
// Create an AWS KMS keyring
const keyring = new KmsKeyringBrowser({
clientProvider,
keyIds: [keyArn1, keyArn2, keyArn3],
})
// Decrypt
const { plaintext, messageHeader } = await decrypt(keyring, ciphertext)
- JavaScript Node.js
-
// Construct a client with limited encrypted data keys
const { encrypt, decrypt } = buildClient({ maxEncryptedDataKeys: 3 })
// Create an AWS KMS keyring
const keyring = new KmsKeyringBrowser({
keyIds: [keyArn1, keyArn2, keyArn3],
})
// Decrypt
const { plaintext, messageHeader } = await decrypt(keyring, ciphertext)
- Python
-
# Instantiate a client with limited encrypted data keys
client = aws_encryption_sdk.EncryptionSDKClient(max_encrypted_data_keys=3)
# Create an AWS KMS master key provider
master_key_provider = aws_encryption_sdk.StrictAwsKmsMasterKeyProvider(
key_ids=[key_arn1, key_arn2, key_arn3])
# Decrypt
plaintext, header = client.decrypt(source=ciphertext, key_provider=master_key_provider)
Einen Discovery-Filter erstellen
Beim Entschlüsseln von Daten, die mit KMS Schlüsseln verschlüsselt wurden, empfiehlt es sich, im strikten Modus zu entschlüsseln, d. h., die verwendeten Wrapping-Schlüssel auf die von Ihnen angegebenen zu beschränken. Bei Bedarf können Sie jedoch auch im Discovery-Modus entschlüsseln, in dem Sie keine Umschließungsschlüssel angeben. In diesem Modus AWS KMS können Sie den verschlüsselten Datenschlüssel mit dem Schlüssel entschlüsseln, mit dem er verschlüsselt wurde, unabhängig davon, wem dieser KMS Schlüssel gehört oder wer Zugriff darauf KMS hat.
Wenn Sie im Discovery-Modus entschlüsseln müssen, empfehlen wir, immer einen Discovery-Filter zu verwenden, der die Schlüssel, die verwendet werden können, auf die KMS Schlüssel beschränkt, die sich in einer bestimmten Partition befinden AWS-Konto . Der Discovery-Filter ist optional, hat sich aber bewährt.
Verwenden Sie die folgende Tabelle, um den Partitionswert für Ihren Discovery-Filter zu ermitteln.
| Region |
Partition |
| AWS-Regionen |
aws |
| Regionen in China |
aws-cn |
| AWS GovCloud (US) Regions |
aws-us-gov |
Die Beispiele in diesem Abschnitt zeigen, wie Sie einen Discovery-Filter erstellen. Bevor Sie den Code verwenden, ersetzen Sie die Beispielwerte durch gültige Werte für die Partition AWS-Konto und.
- C
-
Vollständige Beispiele finden Sie in der Datei kms_discovery.cpp in der AWS-Verschlüsselungs-SDK for C.
/* Create a discovery filter for an AWS account and partition */
const char *account_id = "111122223333";
const char *partition = "aws";
const std::shared_ptr<Aws::Cryptosdk::KmsKeyring::DiscoveryFilter> discovery_filter =
Aws::Cryptosdk::KmsKeyring::DiscoveryFilter::Builder(partition).AddAccount(account_id).Build();
- C# / .NET
-
Ein vollständiges Beispiel finden Sie unter DiscoveryFilterExample.cs im Forum AWS Encryption SDK . NET.
// Create a discovery filter for an AWS account and partition
List<string> account = new List<string> { "111122223333" };
DiscoveryFilter exampleDiscoveryFilter = new DiscoveryFilter()
{
AccountIds = account,
Partition = "aws"
}
- AWS Encryption CLI
-
# Decrypt in discovery mode with a discovery filter
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys discovery=true \
discovery-account=111122223333 \
discovery-partition=aws \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output .
- Java
-
Ein vollständiges Beispiel finden Sie unter DiscoveryDecryptionExample.java in der AWS-Verschlüsselungs-SDK for Java.
// Create a discovery filter for an AWS account and partition
DiscoveryFilter discoveryFilter = new DiscoveryFilter("aws", 111122223333);
- JavaScript (Node and Browser)
-
Vollständige Beispiele finden Sie unter kms_filtered_discovery.ts (Node.js) und kms_multi_region_discovery.ts (Browser) im. AWS-Verschlüsselungs-SDK for JavaScript
/* Create a discovery filter for an AWS account and partition */
const discoveryFilter = {
accountIDs: ['111122223333'],
partition: 'aws',
}
- Python
-
Ein vollständiges Beispiel finden Sie unter AWS-Verschlüsselungs-SDK for Python discovery_kms_provider.py in der.
# Create the discovery filter and specify the region
decrypt_kwargs = dict(
discovery_filter=DiscoveryFilter(account_ids="111122223333", partition="aws"),
discovery_region="us-west-2",
)
Festlegung einer Verpflichtungspolitik
Eine Commitment-Richtlinie ist eine Konfigurationseinstellung, die bestimmt, ob Ihre Anwendung mit Key Commitment ver- oder entschlüsselt wird. Das Verschlüsseln und Entschlüsseln mit Key Commitment ist eine bewährte Methode.AWS Encryption SDK
Die Festlegung und Anpassung Ihrer Verpflichtungsrichtlinie ist ein wichtiger Schritt bei der Migration von Versionen 1.7. x und frühere Versionen von AWS Encryption SDK auf Version 2.0. x und später. Dieser Fortschritt wird im Thema Migration ausführlich erklärt.
Der Standardwert der Commitment-Richtlinie in den neuesten Versionen von AWS Encryption SDK
(ab Version 2.0). x),RequireEncryptRequireDecrypt, ist für die meisten Situationen ideal. Wenn Sie jedoch Chiffretext entschlüsseln müssen, der ohne Schlüsselbindung verschlüsselt wurde, müssen Sie Ihre Verpflichtungsrichtlinie möglicherweise auf ändern. RequireEncryptAllowDecrypt Beispiele dafür, wie Sie in jeder Programmiersprache eine Commitment-Richtlinie einrichten, finden Sie unter. Festlegung Ihrer Verpflichtungspolitik
Arbeiten mit Streaming-Daten
Beachten Sie beim Streamen von Daten zur Entschlüsselung, dass der entschlüsselte Klartext AWS Encryption SDK zurückgibt, nachdem die Integritätsprüfungen abgeschlossen sind, aber bevor die digitale Signatur verifiziert wurde. Um sicherzustellen, dass Sie erst dann Klartext zurückgeben oder verwenden, wenn die Signatur verifiziert ist, empfehlen wir, den gestreamten Klartext zu puffern, bis der gesamte Entschlüsselungsprozess abgeschlossen ist.
Dieses Problem tritt nur auf, wenn Sie Chiffretext zur Entschlüsselung streamen und nur, wenn Sie eine Algorithmussuite verwenden, z. B. die Standard-Algorithmussuite, die digitale Signaturen enthält.
Um die Pufferung zu vereinfachen, enthalten einige AWS Encryption SDK Sprachimplementierungen, z. B. AWS-Verschlüsselungs-SDK for JavaScript in Node.js, eine Pufferfunktion als Teil der Entschlüsselungsmethode. Mit der AWS VerschlüsselungCLI, die immer Eingabe und Ausgabe streamt, wurde in Version 1.9 ein --buffer Parameter eingeführt. x und 2.2. x. In anderen Sprachimplementierungen können Sie vorhandene Pufferfunktionen verwenden. (Das für AWS Encryption SDK . NETunterstützt kein Streaming.)
Wenn Sie eine Algorithmus-Suite ohne digitale Signaturen verwenden, stellen Sie sicher, dass Sie die decrypt-unsigned Funktion in jeder Sprachimplementierung verwenden. Diese Funktion entschlüsselt Chiffretext, schlägt jedoch fehl, wenn signierter Chiffretext gefunden wird. Details hierzu finden Sie unter Auswahl einer Algorithmus-Suite.
Zwischenspeichern von Datenschlüsseln
Im Allgemeinen wird von der Wiederverwendung von Datenschlüsseln abgeraten, AWS Encryption SDK bietet jedoch eine Option zum Zwischenspeichern von Datenschlüsseln, die eine begrenzte Wiederverwendung von Datenschlüsseln ermöglicht. Das Zwischenspeichern von Datenschlüsseln kann die Leistung einiger Anwendungen verbessern und die Anzahl der Zugriffe auf Ihre wichtige Infrastruktur reduzieren. Bevor Sie das Zwischenspeichern von Datenschlüsseln in der Produktion verwenden, passen Sie die Sicherheitsschwellen an und testen Sie, ob die Vorteile die Nachteile der Wiederverwendung von Datenschlüsseln überwiegen.
