AWS KMS porte-clés

Pour identifier une clé AWS KMS key dans un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour C, spécifiez une clé ARN ou un alias ARN. Dans un trousseau de clés de déchiffrement, vous devez utiliser une clé. ARN Pour plus de détails, consultez Identification AWS KMS keys dans un AWS KMS porte-clés.

Pour obtenir un exemple complet, veuillez consulter 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});

Pour créer un AWS KMS porte-clés avec une ou plusieurs AWS KMS clés dans le formulaire AWS Encryption SDK . NET, créez un porte-clés multiple. Le AWS Encryption SDK pour. NETcomprend un porte-clés multiple juste pour les AWS KMS clés.

Lorsque vous spécifiez un AWS KMS key pour un jeu de clés de chiffrement dans le formulaire AWS Encryption SDK . NET, vous pouvez utiliser n'importe quel identifiant de clé valide : un identifiant de clé, une clé ARN, un nom d'alias ou un alias ARN. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voirIdentification AWS KMS keys dans un AWS KMS porte-clés.

L'exemple suivant utilise la version 4. x du AWS Encryption SDK formulaire. NETpour créer un AWS KMS porte-clés avec une clé génératrice et des clés supplémentaires. Pour un exemple complet, consultez AwsKmsMultiKeyringExample.cs.

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

string generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List<string> additionalKey = new List<string> { "alias/exampleAlias" };

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

var kmsEncryptKeyring = materialProviders.CreateAwsKmsMultiKeyring(kmsEncryptKeyringInput);

Lorsque vous spécifiez un AWS KMS key pour un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour JavaScript, vous pouvez utiliser n'importe quel identifiant de clé valide : un identifiant de clé, une clé ARN, un nom d'alias ou un alias ARN. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voirIdentification AWS KMS keys dans un AWS KMS porte-clés.

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

Pour un exemple complet, consultez kms_simple.ts dans le référentiel de. Kit SDK de chiffrement AWS pour 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] 
})

Lorsque vous spécifiez un AWS KMS key pour un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour JavaScript, vous pouvez utiliser n'importe quel identifiant de clé valide : un identifiant de clé, une clé ARN, un nom d'alias ou un alias ARN. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voirIdentification AWS KMS keys dans un AWS KMS porte-clés.

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

Pour un exemple complet, consultez kms_simple.ts dans le référentiel de. Kit SDK de chiffrement AWS pour 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]
})

Pour créer un AWS KMS porte-clés contenant une ou plusieurs AWS KMS clés Kit SDK de chiffrement AWS pour Java, créez un porte-clés multiple. Kit SDK de chiffrement AWS pour Java Il comprend un porte-clés multiple juste pour les AWS KMS clés.

Lorsque vous spécifiez un AWS KMS key pour un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour Java, vous pouvez utiliser n'importe quel identifiant de clé valide : un identifiant de clé, une clé ARN, un nom d'alias ou un alias ARN. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voirIdentification AWS KMS keys dans un AWS KMS porte-clés.

Pour un exemple complet, consultez le BasicEncryptionKeyringExamplefichier .java dans le Kit SDK de chiffrement AWS pour Java référentiel dans 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("alias/exampleAlias");

// Create the AWS KMS keyring
final CreateAwsKmsMultiKeyringInput keyringInput = CreateAwsKmsMultiKeyringInput.builder()
        .generator(generatorKey)
        .kmsKeyIds(additionalKey)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMultiKeyring(keyringInput);

Pour créer un AWS KMS porte-clés contenant une ou plusieurs AWS KMS clés Kit SDK de chiffrement AWS pour Python, créez un porte-clés multiple. Kit SDK de chiffrement AWS pour Python Il comprend un porte-clés multiple juste pour les AWS KMS clés. Par exemple, consultez le fichier aws_kms_multi_keyring_example.py dans le Kit SDK de chiffrement AWS pour Python référentiel dans GitHub.

Lorsque vous spécifiez un AWS KMS key pour un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour Python, vous pouvez utiliser n'importe quel identifiant de clé valide : un identifiant de clé, une clé ARN, un nom d'alias ou un alias ARN. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voirIdentification AWS KMS keys dans un AWS KMS porte-clés.

L'exemple suivant instancie le AWS Encryption SDK client avec la politique d'engagement par défaut,. REQUIRE_ENCRYPT_REQUIRE_DECRYPT Pour un exemple complet, consultez le fichier aws_kms_keyring_example.py dans le Kit SDK de chiffrement AWS pour Python référentiel dans GitHub.

# Instantiate the AWS Encryption SDK client
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="us-west-2")
        
# 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: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
    generator=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
    kms_key_ids=additionalKey
)

kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
    input=keyring_input
)

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

struct aws_cryptosdk_keyring *kms_decrypt_keyring = 
       Aws::Cryptosdk::KmsKeyring::Builder().Build(additional_key);

Comme ce trousseau de clés de déchiffrement ne comprend qu'une seule AWS KMS clé, l'exemple utilise la CreateAwsKmsKeyring() méthode avec une instance de son CreateAwsKmsKeyringInput objet. Pour créer un AWS KMS porte-clés avec une seule AWS KMS clé, vous pouvez utiliser un porte-clés à une ou plusieurs touches. Pour plus de détails, consultez Chiffrer les données dans le formulaire AWS Encryption SDK . NET. L'exemple suivant utilise la version 4. x du AWS Encryption SDK formulaire. NETpour créer un AWS KMS trousseau de clés à déchiffrer.

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

string additionalKey = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321";

// Instantiate a KMS keyring for one AWS KMS key.
var kmsDecryptKeyringInput = new CreateAwsKmsKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = additionalKey
};

var kmsDecryptKeyring = materialProviders.CreateAwsKmsKeyring(kmsDecryptKeyringInput);

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

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

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

const clientProvider = getClient(KMS, { credentials })
const additionalKey = 'arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321'

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

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

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

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

const additionalKey = 'arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321'

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

Comme ce trousseau de clés de déchiffrement ne comprend qu'une seule AWS KMS clé, l'exemple utilise la CreateAwsKmsKeyring() méthode avec une instance de son CreateAwsKmsKeyringInput objet. Pour créer un AWS KMS porte-clés avec une seule AWS KMS clé, vous pouvez utiliser un porte-clés à une ou plusieurs touches.

// 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 additionalKey = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321";

// Create a AwsKmsKeyring
CreateAwsKmsKeyringInput kmsDecryptKeyringInput = CreateAwsKmsKeyringInput.builder()
        .generator(additionalKey)
        .kmsClient(KmsClient.create())
        .build();
IKeyring kmsKeyring = materialProviders.CreateAwsKmsKeyring(kmsDecryptKeyringInput);

L'exemple suivant instancie le AWS Encryption SDK client avec la politique d'engagement par défaut,. REQUIRE_ENCRYPT_REQUIRE_DECRYPT Pour un exemple complet, consultez le fichier aws_kms_keyring_example.py dans le Kit SDK de chiffrement AWS pour Python référentiel dans GitHub.

# Instantiate the AWS Encryption SDK client
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="us-west-2")
        
# Instantiate the material providers   
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring
keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
    generator=additionalKey,
    kms_client=kms_client
)

kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
    input=keyring_input
)

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

L'exemple suivant utilise la version 4. x du AWS Encryption SDK formulaire. NET.

// 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";

// Instantiate a KMS keyring for one AWS KMS key.
var kmsDecryptKeyringInput = new CreateAwsKmsKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = generatorKey
};

var kmsDecryptKeyring = materialProviders.CreateAwsKmsKeyring(kmsDecryptKeyringInput);

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

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

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

const clientProvider = getClient(KMS, { credentials })

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

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

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

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

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

// 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";

// Create a AwsKmsKeyring
CreateAwsKmsKeyringInput kmsDecryptKeyringInput = CreateAwsKmsKeyringInput.builder()
        .generator(generatorKey)
        .kmsClient(KmsClient.create())
        .build();
IKeyring kmsKeyring = materialProviders.CreateAwsKmsKeyring(kmsDecryptKeyringInput);

L'exemple suivant instancie le AWS Encryption SDK client avec la politique d'engagement par défaut,. REQUIRE_ENCRYPT_REQUIRE_DECRYPT Pour un exemple complet, consultez le fichier aws_kms_keyring_example.py dans le Kit SDK de chiffrement AWS pour Python référentiel dans GitHub.

# Instantiate the AWS Encryption SDK client
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="us-west-2")
        
# Instantiate the material providers library  
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create the AWS KMS keyring
keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
    generator=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
    kms_client=kms_client
)

kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
    input=keyring_input
)

Pour obtenir un exemple complet, veuillez consulter : 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));

L'exemple suivant utilise la version 4. x du AWS Encryption SDK formulaire. 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);

Dans JavaScript, vous devez spécifier explicitement la propriété de découverte.

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

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' }
})

Dans JavaScript, vous devez spécifier explicitement la propriété de découverte.

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

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
)
                            

Pour afficher ce porte-clés ainsi que la méthode create_kms_client dans un exemple pratique, consultez 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));

Le AWS Encryption SDK pour. NETne possède pas de porte-clés dédié aux découvertes régionales. Cependant, vous pouvez utiliser plusieurs techniques pour limiter le nombre de KMS clés utilisées lors du déchiffrement dans une région donnée.

Le moyen le plus efficace de limiter le nombre de régions dans un jeu de clés de découverte consiste à utiliser un jeu de clés de multi-Region-aware découverte, même si vous avez chiffré les données uniquement à l'aide de clés à région unique. Lorsqu'il rencontre des clés à région unique, le multi-Region-aware trousseau de clés n'utilise aucune fonctionnalité multirégionale.

Le trousseau de clés renvoyé par la CreateAwsKmsMrkDiscoveryKeyring() méthode filtre les KMS clés par région avant l'appel AWS KMS. Il envoie une demande de déchiffrement AWS KMS uniquement lorsque la clé de données chiffrée a été chiffrée par une KMS clé dans la région spécifiée par le Region paramètre de l'CreateAwsKmsMrkDiscoveryKeyringInputobjet.

Les exemples suivants utilisent la version 4. x du AWS Encryption SDK formulaire. 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);

Vous pouvez également limiter KMS les clés à une valeur particulière Région AWS en spécifiant une région dans votre instance du AWS KMS client (AmazonKeyManagementServiceClient). Toutefois, cette configuration est moins efficace et potentiellement plus coûteuse que l'utilisation d'un trousseau de clés de multi-Region-aware découverte. Au lieu de filtrer KMS les clés par région avant d'appeler AWS KMS, le AWS Encryption SDK for. NETappelle chaque clé AWS KMS de données chiffrée (jusqu'à ce qu'elle en déchiffre une) et s'appuie sur cette clé AWS KMS pour limiter les KMS clés utilisées à la région spécifiée.

L'exemple suivant utilise la version 4. x du AWS Encryption SDK formulaire. 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);

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

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' }
})

L'exemple suivant utilise la buildClient fonction pour spécifier la politique d'engagement par défaut,REQUIRE_ENCRYPT_REQUIRE_DECRYPT. Vous pouvez également utiliser le buildClient pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter Limiter les clés de données chiffrées.

Pour voir ce trousseau de clés et la limitRegions fonction, dans un exemple pratique, consultez 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
    )