AWS KMS Schlüsselringe

Um einen AWS KMS key in einem Verschlüsselungsschlüsselbund in der zu identifizieren AWS-Verschlüsselungs-SDK for C, geben Sie einen Schlüssel-ARN oder Alias-ARN an. In einem Entschlüsselungsschlüsselbund müssen Sie einen Schlüssel-ARN verwenden. Details hierzu finden Sie unter Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund.

Ein vollständiges Beispiel finden Sie unter string.cpp.

const char * generator_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"

const char * additional_key = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"    

struct aws_cryptosdk_keyring *kms_encrypt_keyring = 
       Aws::Cryptosdk::KmsKeyring::Builder().Build(generator_key,{additional_key});

Verwenden Sie die Methode, um einen Schlüsselbund mit einem oder mehreren KMS-Schlüsseln im AWS Encryption SDK für.NET zu erstellen. CreateAwsKmsMultiKeyring() In diesem Beispiel werden zwei AWS KMS Schlüssel verwendet. Verwenden Sie nur den Generator Parameter, um einen KMS-Schlüssel anzugeben. Der KmsKeyIds Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.

Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des Generator Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (us-west-2), AWS Encryption SDK wird ein AWS KMS Standardclient für die us-west-2 Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die CreateAwsKmsKeyring() Methode.

Wenn Sie im für.NET einen Schlüsselbund AWS KMS key AWS Encryption SDK für die Verschlüsselung angeben, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN. Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund

Im folgenden Beispiel wird Version 4 verwendet. x von AWS Encryption SDK für .NET und die CreateAwsKmsKeyring() Methode zum Anpassen des AWS KMS Clients.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

string generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List<string> additionalKeys = new List<string> { "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321" };

// Instantiate the keyring input object
var createEncryptKeyringInput = new CreateAwsKmsMultiKeyringInput
{
    Generator = generatorKey,
    KmsKeyIds = additionalKeys
};

var kmsEncryptKeyring = materialProviders.CreateAwsKmsMultiKeyring(createEncryptKeyringInput);

Wenn Sie in der einen Schlüsselbund AWS KMS key für die Verschlüsselung angeben AWS-Verschlüsselungs-SDK for JavaScript, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN. Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund

Im folgenden Beispiel wird die buildClient Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Sie können die auch verwendenbuildClient, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter Beschränkung verschlüsselter Datenschlüssel.

Ein vollständiges Beispiel finden Sie unter kms_simple.ts im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
const additionalKey = 'alias/exampleAlias'

const keyring = new KmsKeyringBrowser({
  clientProvider, 
  generatorKeyId, 
  keyIds: [additionalKey] 
})

Wenn Sie in der einen Schlüsselbund AWS KMS key für die Verschlüsselung angeben AWS-Verschlüsselungs-SDK for JavaScript, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN. Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund

Im folgenden Beispiel wird die buildClient Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Sie können die auch verwendenbuildClient, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter Beschränkung verschlüsselter Datenschlüssel.

Ein vollständiges Beispiel finden Sie unter kms_simple.ts im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
                            
const additionalKey = 'alias/exampleAlias'

const keyring = new KmsKeyringNode({
  generatorKeyId,
  keyIds: [additionalKey]
})

Verwenden Sie die Methode, um einen Schlüsselbund mit einem oder mehreren Schlüsseln zu erstellen. AWS KMS CreateAwsKmsMultiKeyring() In diesem Beispiel werden zwei KMS-Schlüssel verwendet. Verwenden Sie nur den generator Parameter, um einen KMS-Schlüssel anzugeben. Der msKeyIds Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.

Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des Generator Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (us-west-2), AWS Encryption SDK wird ein AWS KMS Standardclient für die us-west-2 Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die CreateAwsKmsKeyring() Methode.

Wenn Sie in der einen Schlüsselbund AWS KMS key für die Verschlüsselung angeben AWS-Verschlüsselungs-SDK for Java, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN. Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund

Ein vollständiges Beispiel finden Sie unter BasicEncryptionKeyringExample.java im AWS-Verschlüsselungs-SDK for Java Repository unter. GitHub

// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder().build();
final MaterialProviders materialProviders = MaterialProviders.builder()
            .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
            .build();

String generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List<String> additionalKey = Collections.singletonList("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the keyring
final CreateAwsKmsMultiKeyringInput keyringInput = CreateAwsKmsMultiKeyringInput.builder()
        .generator(generatorKey)
        .kmsKeyIds(additionalKey)
        .build();
final IKeyring kmsKeyring = materialProviders.CreateAwsKmsMultiKeyring(keyringInput);

Verwenden Sie die Methode, um einen Schlüsselbund mit einem oder mehreren AWS KMS Schlüsseln zu erstellen. create_aws_kms_multi_keyring() In diesem Beispiel werden zwei KMS-Schlüssel verwendet. Verwenden Sie nur den generator Parameter, um einen KMS-Schlüssel anzugeben. Der kms_key_ids Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.

Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des generator Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (us-west-2), AWS Encryption SDK wird ein AWS KMS Standardclient für die us-west-2 Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die create_aws_kms_keyring() Methode.

Wenn Sie in der einen Schlüsselbund AWS KMS key für die Verschlüsselung angeben AWS-Verschlüsselungs-SDK for Python, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN. Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund

Im folgenden Beispiel wird der AWS Encryption SDK Client mit der Standard-Commitment-Richtlinie instanziiert. REQUIRE_ENCRYPT_REQUIRE_DECRYPT Ein vollständiges Beispiel finden Sie unter aws_kms_keyring_example.py im AWS-Verschlüsselungs-SDK for Python Repository unter. GitHub

# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
        
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring 
kms_multi_keyring_input: CreateAwsKmsMultiKeyringInput = CreateAwsKmsMultiKeyringInput(
    generator=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
    kms_key_ids=arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321
)

kms_multi_keyring: IKeyring = mat_prov.create_aws_kms_multi_keyring(
    input=kms_multi_keyring_input
)

Verwenden Sie die create_aws_kms_multi_keyring() Methode, um einen Schlüsselbund mit einem oder mehreren AWS KMS Schlüsseln zu erstellen. In diesem Beispiel werden zwei KMS-Schlüssel verwendet. Verwenden Sie nur den generator Parameter, um einen KMS-Schlüssel anzugeben. Der kms_key_ids Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.

Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des generator Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (us-west-2), AWS Encryption SDK wird ein AWS KMS Standardclient für die us-west-2 Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die create_aws_kms_keyring() Methode.

Wenn Sie im AWS KMS key for Rust einen Schlüsselbund für eine Verschlüsselung angeben, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN. AWS Encryption SDK Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund

Im folgenden Beispiel wird der AWS Encryption SDK Client mit der Standard-Commitment-Richtlinie instanziiert. REQUIRE_ENCRYPT_REQUIRE_DECRYPT Ein vollständiges Beispiel finden Sie unter aws_kms_keyring_example.rs im Rust-Verzeichnis des Repositorys auf. aws-encryption-sdk GitHub

// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
        
// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
    
// Optional: Create an encryption context
let encryption_context = HashMap::from([
    ("encryption".to_string(), "context".to_string()),
    ("is not".to_string(), "secret".to_string()),
    ("but adds".to_string(), "useful metadata".to_string()),
    ("that can help you".to_string(), "be confident that".to_string()),
    ("the data you are handling".to_string(), "is what you think it is".to_string()),
]);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create the AWS KMS keyring 
let kms_keyring = mpl
    .create_aws_kms_keyring()
    .kms_key_id(kms_key_id)
    .kms_client(kms_client)
    .send()
    .await?;

kms_multi_keyring: IKeyring = mat_prov.create_aws_kms_multi_keyring(
    input=kms_multi_keyring_input
)

Verwenden Sie die Methode, um einen Schlüsselbund mit einem oder mehreren Schlüsseln zu erstellen. AWS KMS create_aws_kms_multi_keyring() In diesem Beispiel werden zwei KMS-Schlüssel verwendet. Verwenden Sie nur den generator Parameter, um einen KMS-Schlüssel anzugeben. Der kms_key_ids Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.

Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des generator Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (us-west-2), AWS Encryption SDK wird ein AWS KMS Standardclient für die us-west-2 Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die create_aws_kms_keyring() Methode.

Wenn Sie in AWS KMS key for Go einen Schlüsselbund für eine Verschlüsselung angeben, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN. AWS Encryption SDK Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund

Im folgenden Beispiel wird der AWS Encryption SDK Client mit der Standard-Commitment-Richtlinie instanziiert. REQUIRE_ENCRYPT_REQUIRE_DECRYPT

import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)

// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}

// Create the AWS KMS keyring 
awsKmsMultiKeyringInput := mpltypes.CreateAwsKmsMultiKeyringInput{
    Generator: &arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
    KmsKeyIds: []string{arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321},
}
awsKmsMultiKeyring, err := matProv.CreateAwsKmsMultiKeyring(context.Background(), awsKmsMultiKeyringInput)
                    

Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, müssen Sie den öffentlichen Schlüssel und den privaten Schlüssel ARN aus Ihrem asymmetrischen RSA-KMS-Schlüssel angeben. Der öffentliche Schlüssel muss PEM-codiert sein. Im folgenden Beispiel wird ein AWS KMS Schlüsselbund mit einem asymmetrischen RSA-Schlüsselpaar erstellt.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
        
var publicKey = new MemoryStream(Encoding.UTF8.GetBytes(AWS KMS RSA public key));

// Instantiate the keyring input object
var createKeyringInput = new CreateAwsKmsRsaKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = AWS KMS RSA private key ARN,
    PublicKey = publicKey,
    EncryptionAlgorithm = EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256
};

// Create the keyring
var kmsRsaKeyring = mpl.CreateAwsKmsRsaKeyring(createKeyringInput);

Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, müssen Sie den öffentlichen Schlüssel und den privaten Schlüssel ARN aus Ihrem asymmetrischen RSA-KMS-Schlüssel angeben. Der öffentliche Schlüssel muss PEM-codiert sein. Im folgenden Beispiel wird ein AWS KMS Schlüsselbund mit einem asymmetrischen RSA-Schlüsselpaar erstellt.

// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder()
        // Specify algorithmSuite without asymmetric signing here
        //
        // ALG_AES_128_GCM_IV12_TAG16_NO_KDF("0x0014"),
        // ALG_AES_192_GCM_IV12_TAG16_NO_KDF("0x0046"),
        // ALG_AES_256_GCM_IV12_TAG16_NO_KDF("0x0078"),
        // ALG_AES_128_GCM_IV12_TAG16_HKDF_SHA256("0x0114"),
        // ALG_AES_192_GCM_IV12_TAG16_HKDF_SHA256("0x0146"),
        // ALG_AES_256_GCM_IV12_TAG16_HKDF_SHA256("0x0178")
        .withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_IV12_TAG16_HKDF_SHA256)
        .build();
                
final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();

// Create a KMS RSA keyring.
//    This keyring takes in:
//     - kmsClient
//     - kmsKeyId: Must be an ARN representing an asymmetric RSA KMS key
//     - publicKey: A ByteBuffer of a UTF-8 encoded PEM file representing the public
//                  key for the key passed into kmsKeyId
//     - encryptionAlgorithm: Must be either RSAES_OAEP_SHA_256 or RSAES_OAEP_SHA_1
final CreateAwsKmsRsaKeyringInput createAwsKmsRsaKeyringInput =
        CreateAwsKmsRsaKeyringInput.builder()
                .kmsClient(KmsClient.create())
                .kmsKeyId(rsaKeyArn)
                .publicKey(publicKey)
                .encryptionAlgorithm(EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256)
                .build();
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);

Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, müssen Sie den öffentlichen Schlüssel und den privaten Schlüssel ARN aus Ihrem asymmetrischen RSA-KMS-Schlüssel angeben. Der öffentliche Schlüssel muss PEM-codiert sein. Im folgenden Beispiel wird ein AWS KMS Schlüsselbund mit einem asymmetrischen RSA-Schlüsselpaar erstellt.

# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
        
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring 
keyring_input: CreateAwsKmsRsaKeyringInput = CreateAwsKmsRsaKeyringInput(
    public_key=public_key,
    kms_key_id=kms_key_id,
    encryption_algorithm="RSAES_OAEP_SHA_256",
    kms_client=kms_client
)

kms_rsa_keyring: IKeyring = mat_prov.create_aws_kms_rsa_keyring(
    input=keyring_input
)

Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, müssen Sie den öffentlichen Schlüssel und den privaten Schlüssel ARN aus Ihrem asymmetrischen RSA-KMS-Schlüssel angeben. Der öffentliche Schlüssel muss PEM-codiert sein. Im folgenden Beispiel wird ein AWS KMS Schlüsselbund mit einem asymmetrischen RSA-Schlüsselpaar erstellt.

// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;)

// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);

// Optional: Create an encryption context
let encryption_context = HashMap::from([
    ("encryption".to_string(), "context".to_string()),
    ("is not".to_string(), "secret".to_string()),
    ("but adds".to_string(), "useful metadata".to_string()),
    ("that can help you".to_string(), "be confident that".to_string()),
    ("the data you are handling".to_string(), "is what you think it is".to_string()),
]);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create the AWS KMS keyring
let kms_rsa_keyring = mpl
    .create_aws_kms_rsa_keyring()
    .kms_key_id(kms_key_id
    .public_key(aws_smithy_types::Blob::new(public_key))
    .encryption_algorithm(aws_sdk_kms::types::EncryptionAlgorithmSpec::RsaesOaepSha256)
    .kms_client(kms_client)
    .send()
    .await?;

import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/kms"
)

// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}

// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
    o.Region = KmsKeyRegion
})

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}

// Create the AWS KMS keyring
awsKmsRSAKeyringInput := mpltypes.CreateAwsKmsRsaKeyringInput{
    KmsClient:           kmsClient,
    KmsKeyId:            kmsKeyID,
    PublicKey:           kmsPublicKey,
    EncryptionAlgorithm: kmstypes.EncryptionAlgorithmSpecRsaesOaepSha256,
}
awsKmsRSAKeyring, err := matProv.CreateAwsKmsRsaKeyring(context.Background(), awsKmsRSAKeyringInput)
if err != nil {
    panic(err)
}

Ein vollständiges Beispiel finden Sie unter kms_discovery.cpp.

std::shared_ptr<KmsKeyring::> discovery_filter(
    KmsKeyring::DiscoveryFilter::Builder("aws")
        .AddAccount("111122223333")
        .Build());

struct aws_cryptosdk_keyring *kms_discovery_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
       .BuildDiscovery(discovery_filter));

Im folgenden Beispiel wird Version 4 verwendet. x von AWS Encryption SDK für .NET.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

List<string> account = new List<string> { "111122223333" };
        
// In a discovery keyring, you specify an AWS KMS client and a discovery filter,
// but not a AWS KMS key
var kmsDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    DiscoveryFilter = new DiscoveryFilter()
    {
        AccountIds = account,
        Partition = "aws"
    }
};
        
var kmsDiscoveryKeyring = materialProviders.CreateAwsKmsDiscoveryKeyring(kmsDiscoveryKeyringInput);

JavaScriptIn müssen Sie die Discovery-Eigenschaft explizit angeben.

Im folgenden Beispiel wird die buildClient Funktion verwendet, um die Standard-Commitment-Richtlinie anzugebenREQUIRE_ENCRYPT_REQUIRE_DECRYPT. Sie können die auch verwendenbuildClient, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter Beschränkung verschlüsselter Datenschlüssel.

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })

const discovery = true
const keyring = new KmsKeyringBrowser(clientProvider, {
    discovery,
    discoveryFilter: { accountIDs: [111122223333], partition: 'aws' }
})

JavaScriptIn müssen Sie die Discovery-Eigenschaft explizit angeben.

Im folgenden Beispiel wird die buildClient Funktion verwendet, um die Standard-Commitment-Richtlinie anzugebenREQUIRE_ENCRYPT_REQUIRE_DECRYPT. Sie können die auch verwendenbuildClient, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter Beschränkung verschlüsselter Datenschlüssel.

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const discovery = true

const keyring = new KmsKeyringNode({
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})

// Create discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
        .partition("aws")
        .accountIds(111122223333)
        .build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
        .discoveryFilter(discoveryFilter)
        .build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);

# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)

# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS discovery keyring
discovery_keyring_input: CreateAwsKmsDiscoveryKeyringInput = CreateAwsKmsDiscoveryKeyringInput(
    kms_client=kms_client,
    discovery_filter=DiscoveryFilter(
        account_ids=[aws_account_id],
        partition="aws"
    )
)

discovery_keyring: IKeyring = mat_prov.create_aws_kms_discovery_keyring(
    input=discovery_keyring_input
)
                            

// Instantiate the AWS Encryption SDK
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;

// Create a AWS KMS client.
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);


// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
    .account_ids(vec![aws_account_id.to_string()])
    .partition("aws".to_string())
    .build()?;

// Create the AWS KMS discovery keyring
let discovery_keyring = mpl
    .create_aws_kms_discovery_keyring()
    .kms_client(kms_client.clone())
    .discovery_filter(discovery_filter)
    .send()
    .await?;

import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/kms"
)

// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}

// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
    o.Region = KmsKeyRegion
})

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}

// Create discovery filter
discoveryFilter := mpltypes.DiscoveryFilter{
    AccountIds: []string{kmsKeyAccountID},
    Partition:  "aws",
}
awsKmsDiscoveryKeyringInput := mpltypes.CreateAwsKmsDiscoveryKeyringInput{
    KmsClient:       kmsClient,
    DiscoveryFilter: &discoveryFilter,
}
awsKmsDiscoveryKeyring, err := matProv.CreateAwsKmsDiscoveryKeyring(context.Background(), awsKmsDiscoveryKeyringInput)
if err != nil {
    panic(err)
}

Weitere Informationen zum Anzeigen dieses Schlüsselbunds und der create_kms_client-Methode in einem funktionierenden Beispiel finden Sie unter kms_discovery.cpp.

std::shared_ptr<KmsKeyring::DiscoveryFilter> discovery_filter(
    KmsKeyring::DiscoveryFilter::Builder("aws")
        .AddAccount("111122223333")
        .Build());

struct aws_cryptosdk_keyring *kms_regional_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
       .WithKmsClient(create_kms_client(Aws::Region::US_WEST_2)).BuildDiscovery(discovery_filter));

AWS Encryption SDK Für .NET gibt es keinen eigenen Schlüsselbund für die regionale Erkennung. Sie können jedoch verschiedene Techniken verwenden, um die bei der Entschlüsselung verwendeten KMS-Schlüssel auf eine bestimmte Region zu beschränken.

Die effizienteste Methode, die Regionen in einem Discovery-Schlüsselbund einzuschränken, ist die Verwendung eines multi-Region-aware Discovery-Schlüsselbunds, auch wenn Sie die Daten nur mit Schlüsseln aus einer Region verschlüsselt haben. Wenn Schlüssel mit nur einer Region gefunden werden, verwendet der multi-Region-aware Schlüsselbund keine Funktionen für mehrere Regionen.

Der von der CreateAwsKmsMrkDiscoveryKeyring() Methode zurückgegebene Schlüsselbund filtert KMS-Schlüssel vor dem Aufruf nach Region. AWS KMS Sie sendet AWS KMS nur dann eine Entschlüsselungsanforderung an, wenn der verschlüsselte Datenschlüssel mit einem KMS-Schlüssel in der Region verschlüsselt wurde, die durch den Region Parameter im Objekt angegeben wurde. CreateAwsKmsMrkDiscoveryKeyringInput

In den folgenden Beispielen wird Version 4 verwendet. x von AWS Encryption SDK für .NET.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

List<string> account = new List<string> { "111122223333" };

// Create the discovery filter
var filter = DiscoveryFilter = new DiscoveryFilter
{
    AccountIds = account,
    Partition = "aws"
};
                                
var regionalDiscoveryKeyringInput = new CreateAwsKmsMrkDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
    Region = RegionEndpoint.USWest2,
    DiscoveryFilter = filter
};                                

var kmsRegionalDiscoveryKeyring = materialProviders.CreateAwsKmsMrkDiscoveryKeyring(regionalDiscoveryKeyringInput);

Sie können KMS-Schlüssel auch auf einen bestimmten Wert beschränken, AWS-Region indem Sie eine Region in Ihrer Instanz des AWS KMS Clients angeben (AmazonKeyManagementServiceClient). Diese Konfiguration ist jedoch weniger effizient und potenziell kostspieliger als die Verwendung eines multi-Region-aware Discovery-Schlüsselbunds. Anstatt KMS-Schlüssel vor dem Aufrufen nach Region zu filtern AWS KMS, ruft AWS KMS for.NET jeden verschlüsselten Datenschlüssel auf (bis er einen entschlüsselt) und beschränkt sich darauf, die verwendeten KMS-Schlüssel auf AWS KMS die angegebene Region zu beschränken. AWS Encryption SDK

Im folgenden Beispiel wird Version 4 verwendet. x von AWS Encryption SDK für .NET.

// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

List<string> account = new List<string> { "111122223333" };
        
// Create the discovery filter,
// but not a AWS KMS key
var createRegionalDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
    DiscoveryFilter = new DiscoveryFilter()
    {
        AccountIds = account,
        Partition = "aws"
    }
};
        
var kmsRegionalDiscoveryKeyring = materialProviders.CreateAwsKmsDiscoveryKeyring(createRegionalDiscoveryKeyringInput);

Im folgenden Beispiel wird die buildClient Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Sie können die auch verwendenbuildClient, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter Beschränkung verschlüsselter Datenschlüssel.

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const clientProvider = getClient(KMS, { credentials })

const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringBrowser(clientProvider, {
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})

Im folgenden Beispiel wird die buildClient Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Sie können die auch verwendenbuildClient, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter Beschränkung verschlüsselter Datenschlüssel.

Einen Überblick über diesen Schlüsselbund und die limitRegions Funktion finden Sie in einem funktionierenden Beispiel unter kms_regional_discovery.ts.

import {
  KmsKeyringNode,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringNode({
    clientProvider,
    discovery,
    discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})

// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
        .partition("aws")
        .accountIds(111122223333)
        .build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
        .discoveryFilter(discoveryFilter)
        .regions("us-west-2")
        .build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);

# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)

# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "encryption": "context",
    "is not": "secret",
    "but adds": "useful metadata",
    "that can help you": "be confident that",
    "the data you are handling": "is what you think it is",
}

# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS regional discovery keyring
regional_discovery_keyring_input: CreateAwsKmsMrkDiscoveryKeyringInput = \
    CreateAwsKmsMrkDiscoveryKeyringInput(
        kms_client=kms_client,
        region=mrk_replica_decrypt_region,
        discovery_filter=DiscoveryFilter(
            account_ids=[111122223333],
            partition="aws"
        )
)

    regional_discovery_keyring: IKeyring = mat_prov.create_aws_kms_mrk_discovery_keyring(
        input=regional_discovery_keyring_input
    )

                            

// Instantiate the AWS Encryption SDK
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;

// Optional: Create an encryption context
let encryption_context = HashMap::from([
    ("encryption".to_string(), "context".to_string()),
    ("is not".to_string(), "secret".to_string()),
    ("but adds".to_string(), "useful metadata".to_string()),
    ("that can help you".to_string(), "be confident that".to_string()),
    ("the data you are handling".to_string(), "is what you think it is".to_string()),
]);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create an AWS KMS client
let decrypt_kms_config = aws_sdk_kms::config::Builder::from(&sdk_config)
    .region(Region::new(mrk_replica_decrypt_region.clone()))
    .build();
let decrypt_kms_client = aws_sdk_kms::Client::from_conf(decrypt_kms_config);


// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
    .account_ids(vec![aws_account_id.to_string()])
    .partition("aws".to_string())
    .build()?;

// Create the regional discovery keyring
let discovery_keyring = mpl
    .create_aws_kms_mrk_discovery_keyring()
    .kms_client(decrypt_kms_client)
    .region(mrk_replica_decrypt_region)
    .discovery_filter(discovery_filter)
    .send()
    .await?;

import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/kms"
)

// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}

// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
    o.Region = KmsKeyRegion
})

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Create discovery filter
discoveryFilter := mpltypes.DiscoveryFilter{
    AccountIds: []string{awsAccountID},
    Partition:  "aws",
}

// Create the regional discovery keyring
awsKmsMrkDiscoveryInput := mpltypes.CreateAwsKmsMrkDiscoveryKeyringInput{
    KmsClient:       kmsClient,
    Region:          alternateRegionMrkKeyRegion,
    DiscoveryFilter: &discoveryFilter,
}
awsKmsMrkDiscoveryKeyring, err := matProv.CreateAwsKmsMrkDiscoveryKeyring(context.Background(), awsKmsMrkDiscoveryInput)
if err != nil {
    panic(err)
}