Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Porte-clés
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Le SDK AWS Database Encryption utilise des *trousseaux de clés pour* chiffrer les [enveloppes.](concepts.md#envelope-encryption) Les porte-clés génèrent, chiffrent et déchiffrent des clés de données. Les porte-clés déterminent la source des clés de données uniques qui protègent chaque enregistrement chiffré, ainsi que les [clés d'encapsulation qui chiffrent cette clé](concepts.md#wrapping-key) de données. Vous spécifiez un porte-clés lors du chiffrement et le même porte-clés ou un autre porte-clés lors du déchiffrement.
Vous pouvez utiliser chaque porte-clés individuellement ou combiner les porte-clés dans un [porte-clés multiple](use-multi-keyring.md). Bien que la plupart des porte-clés peuvent générer, chiffrer et déchiffrer des clés de données, vous pouvez créer un porte-clés qui effectue une seule opération particulière, par exemple un porte-clés qui génère uniquement des clés de données, et utiliser ce porte-clés en combinaison avec d'autres.
Nous vous recommandons d'utiliser un trousseau de clés qui protège vos clés d'encapsulation et effectue des opérations cryptographiques dans une limite sécurisée, tel que le AWS KMS trousseau de clés, qui utilise AWS KMS keys that never leave [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)()AWS KMS non chiffré. Vous pouvez également créer un trousseau de clés utilisant des clés d'encapsulation stockées dans vos modules de sécurité matériels (HSMs) ou protégées par d'autres services de clés principales.
Votre trousseau de clés détermine les clés d'encapsulation qui protègent vos clés de données et, en fin de compte, vos données. Utilisez les clés d'emballage les plus sûres et les plus pratiques pour votre tâche. Dans la mesure du possible, utilisez des clés d'encapsulation protégées par un module de sécurité matériel (HSM) ou une infrastructure de gestion des clés, comme les clés KMS in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) ou les clés de chiffrement in [AWS CloudHSM](https://docs.aws.amazon.com/cloudhsm/latest/userguide/).
Le SDK AWS Database Encryption fournit plusieurs ensembles de clés et configurations de trousseaux de clés, et vous pouvez créer vos propres trousseaux de clés personnalisés. Vous pouvez également créer un [porte-clés multiple](use-multi-keyring.md) comprenant un ou plusieurs porte-clés du même type ou d'un type différent.
**Topics**
+ [Fonctionnement des porte-clés](#using-keyrings)
+ [AWS KMS porte-clés](use-kms-keyring.md)
+ [AWS KMS Porte-clés hiérarchiques](use-hierarchical-keyring.md)
+ [AWS KMS Porte-clés ECDH](use-kms-ecdh-keyring.md)
+ [Porte-clés AES brut](use-raw-aes-keyring.md)
+ [Porte-clés RSA bruts](use-raw-rsa-keyring.md)
+ [Porte-clés ECDH bruts](use-raw-ecdh-keyring.md)
+ [Porte-clés multiples](use-multi-keyring.md)
## Fonctionnement des porte-clés
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Lorsque vous chiffrez et signez un champ dans votre base de données, le SDK de chiffrement de AWS base de données demande au trousseau de clés le matériel de chiffrement. Le porte-clés renvoie une clé de données en texte brut, une copie de la clé de données chiffrée par chacune des clés d'encapsulage du trousseau de clés et une clé MAC associée à la clé de données. Le SDK AWS de chiffrement de base de données utilise la clé en texte brut pour chiffrer les données, puis la supprime de la mémoire dès que possible. Le SDK AWS de chiffrement de base de données ajoute ensuite une [description matérielle](concepts.md#material-description) qui inclut les clés de données chiffrées et d'autres informations, telles que les instructions de chiffrement et de signature. Le SDK AWS Database Encryption utilise la clé MAC pour calculer les codes d'authentification des messages basés sur le hachage (HMACs) lors de la canonisation de la description du matériel et de tous les champs marqués ou. `ENCRYPT_AND_SIGN` `SIGN_ONLY`
Lorsque vous déchiffrez des données, vous pouvez utiliser le même trousseau de clés que celui que vous avez utilisé pour chiffrer les données, ou un autre. Pour déchiffrer les données, un jeu de clés de déchiffrement doit avoir accès à au moins une clé d'encapsulation du jeu de clés de chiffrement.
Le SDK AWS de chiffrement de base de données transmet les clés de données chiffrées de la description matérielle au trousseau de clés et demande au trousseau de déchiffrer l'une d'entre elles. Le porte-clés utilise ses clés d'encapsulage pour déchiffrer l'une des clés de données chiffrées et renvoie une clé de données en texte brut. Le SDK AWS de chiffrement de base de données utilise la clé de données en texte brut pour déchiffrer les données. Si aucune des clés d'encapsulage du porte-clés ne peut déchiffrer les clés de données chiffrées, l'opération de déchiffrement échoue.
Vous pouvez utiliser un seul porte-clés ou également combiner des porte-clés du même type ou de types différents dans un [porte-clés multiple](use-multi-keyring.md). Lorsque vous chiffrez des données, le jeu de clés multiples renvoie une copie de la clé de données chiffrée par toutes les clés d'encapsulage de tous les trousseaux de clés qui le composent et une clé MAC associée à la clé de données. Vous pouvez déchiffrer les données à l'aide d'un trousseau de clés avec n'importe laquelle des clés d'encapsulage du trousseau de clés multiples.
# AWS KMS porte-clés
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Un AWS KMS trousseau de clés utilise le chiffrement symétrique ou le RSA asymétrique [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)pour générer, chiffrer et déchiffrer les clés de données. AWS Key Management Service (AWS KMS) protège vos clés KMS et effectue des opérations cryptographiques dans les limites de la norme FIPS. Nous vous recommandons d'utiliser un AWS KMS trousseau de clés, ou un trousseau de clés présentant des propriétés de sécurité similaires, dans la mesure du possible.
Vous pouvez également utiliser une clé KMS multirégionale symétrique dans un AWS KMS trousseau de clés. Pour plus de détails et des exemples d'utilisation de plusieurs régions AWS KMS keys, consultez[Utilisation de plusieurs régions AWS KMS keys](#config-mrks). Pour plus d'informations sur les clés multirégionales, consultez la section [Utilisation des clés multirégionales](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) dans le manuel du *AWS Key Management Service développeur*.
AWS KMS les porte-clés peuvent inclure deux types de clés d'emballage :
+ **Clé du générateur** : génère une clé de données en texte brut et la chiffre. Un trousseau de clés qui chiffre des données doit comporter une clé génératrice.
+ **Clés supplémentaires** : chiffre la clé de données en texte brut générée par la clé du générateur. AWS KMS les porte-clés peuvent comporter zéro ou plusieurs clés supplémentaires.
Vous devez disposer d'une clé génératrice pour chiffrer les enregistrements. Lorsqu'un AWS KMS trousseau de clés ne comporte qu'une seule AWS KMS clé, celle-ci est utilisée pour générer et chiffrer la clé de données.
Comme tous les porte-clés, les AWS KMS porte-clés peuvent être utilisés indépendamment ou dans un [porte-clés multiple avec d'autres porte-clés](use-multi-keyring.md) du même type ou d'un type différent.
**Topics**
+ [Autorisations requises pour les AWS KMS porte-clés](#kms-keyring-permissions)
+ [Identification AWS KMS keys dans un AWS KMS porte-clés](#kms-keyring-id)
+ [Création d'un AWS KMS porte-clés](#kms-keyring-create)
+ [Utilisation de plusieurs régions AWS KMS keys](#config-mrks)
+ [Utilisation d'un porte-clés AWS KMS Discovery](#kms-keyring-discovery)
+ [Utiliser un porte-clés de découverte AWS KMS régional](#kms-keyring-regional)
## Autorisations requises pour les AWS KMS porte-clés
Le SDK AWS de chiffrement de base de données n'en nécessite pas Compte AWS et n'en dépend pas Service AWS. Toutefois, pour utiliser un AWS KMS trousseau de clés, vous devez disposer des autorisations minimales suivantes AWS KMS keys sur celui-ci. Compte AWS
+ Pour chiffrer avec un AWS KMS trousseau de clés, vous avez besoin de l'GenerateDataKeyautorisation [kms :](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) sur la clé du générateur. Vous devez disposer de l'autorisation [KMS:Encrypt pour](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) toutes les clés supplémentaires du trousseau de clés. AWS KMS
+ Pour déchiffrer avec un AWS KMS trousseau de clés, vous devez disposer de l'autorisation [KMS:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) sur au moins une des clés du trousseau de clés. AWS KMS
+ Pour chiffrer avec un trousseau de clés multiples composé de trousseaux de AWS KMS clés, vous avez besoin de l'GenerateDataKeyautorisation [kms :](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) sur la clé du générateur située dans le trousseau de clés du générateur. Vous avez besoin de l'autorisation [KMS:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) sur toutes les autres clés de tous les autres trousseaux de clés. AWS KMS
+ Pour chiffrer avec un jeu de AWS KMS clés RSA asymétrique, vous n'avez pas besoin de [kms : GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) ou de [KMS:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) car vous devez spécifier le matériel de clé publique que vous souhaitez utiliser pour le chiffrement lorsque vous créez le trousseau de clés. Aucun AWS KMS appel n'est effectué lors du chiffrement avec ce trousseau de clés. [Pour déchiffrer avec un trousseau de AWS KMS clés RSA asymétrique, vous devez disposer de l'autorisation KMS:Decrypt.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
Pour obtenir des informations détaillées sur les autorisations pour AWS KMS keys, voir [Authentification et contrôle d'accès](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html) dans le *Guide du AWS Key Management Service développeur*.
## Identification AWS KMS keys dans un AWS KMS porte-clés
Un AWS KMS porte-clés peut en inclure un ou plusieurs AWS KMS keys. Pour spécifier un AWS KMS key dans un AWS KMS trousseau de clés, utilisez un identifiant de AWS KMS clé compatible. Les identificateurs de clé que vous pouvez utiliser pour identifier un élément AWS KMS key dans un trousseau de clés varient en fonction de l'opération et de l'implémentation du langage. Pour plus de détails sur les identificateurs de clé d'un AWS KMS key, consultez la section [Identifiants de clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) dans le guide du *AWS Key Management Service développeur*.
Il est recommandé d'utiliser l'identifiant de clé le plus précis qui soit adapté à votre tâche.
+ Pour chiffrer à l'aide d'un AWS KMS trousseau de clés, vous pouvez utiliser un [identifiant de clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), un [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) de clé, un [nom d'alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) ou un [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-ARN) d'alias pour chiffrer les données.
**Note**
Si vous spécifiez un nom d'alias ou un alias ARN pour une clé KMS dans un jeu de clés de chiffrement, l'opération de chiffrement enregistre l'ARN de clé actuellement associé à l'alias dans les métadonnées de la clé de données chiffrée. Cela n'enregistre pas l'alias. Les modifications apportées à l'alias n'affectent pas la clé KMS utilisée pour déchiffrer vos clés de données chiffrées.
+ Pour déchiffrer à l'aide d'un AWS KMS trousseau de clés, vous devez utiliser un ARN de clé pour vous identifier. AWS KMS keys Pour en savoir plus, consultez [Sélection des clés d'emballage](configure.md#config-keys).
+ Dans un porte-clés utilisé pour le chiffrement et le déchiffrement, vous devez utiliser un ARN de clé pour identifier les AWS KMS keys.
Lors du déchiffrement, le SDK de chiffrement de AWS base de données recherche dans le jeu de AWS KMS clés une clé capable de déchiffrer l'une AWS KMS key des clés de données chiffrées. Plus précisément, le SDK AWS de chiffrement de base de données utilise le modèle suivant pour chaque clé de données cryptée dans la description du matériel.
+ Le SDK AWS de chiffrement de base de données obtient l'ARN de la clé AWS KMS key qui a chiffré la clé de données à partir des métadonnées de la description du matériel.
+ Le SDK AWS Database Encryption recherche dans le trousseau de clés de déchiffrement un AWS KMS key code ARN correspondant.
+ S'il trouve un AWS KMS key ARN correspondant dans le jeu de clés, le SDK de chiffrement de AWS base de données demande d'utiliser la clé KMS AWS KMS pour déchiffrer la clé de données chiffrée.
+ Dans le cas contraire, il passe à la clé de données chiffrée suivante, le cas échéant.
## Création d'un AWS KMS porte-clés
Vous pouvez configurer chaque AWS KMS porte-clés avec un AWS KMS key ou plusieurs AWS KMS keys éléments identiques ou différents Comptes AWS . Régions AWS AWS KMS key Il doit s'agir d'une clé de chiffrement symétrique (`SYMMETRIC_DEFAULT`) ou d'une clé RSA KMS asymétrique. Vous pouvez également utiliser une clé [KMS multirégionale](#config-mrks) à chiffrement symétrique. Vous pouvez utiliser un ou plusieurs AWS KMS porte-clés dans un porte-clés [multiple](use-multi-keyring.md).
Vous pouvez créer un AWS KMS trousseau de clés qui chiffre et déchiffre les données, ou vous pouvez créer un trousseau de AWS KMS clés spécialement conçu pour le chiffrement ou le déchiffrement. Lorsque vous créez un AWS KMS trousseau de clés pour chiffrer des données, vous devez spécifier une *clé* de génération, AWS KMS key qui est utilisée pour générer une clé de données en texte brut et la chiffrer. La clé de données n'est mathématiquement pas liée à la clé KMS. Ensuite, si vous le souhaitez, vous pouvez en spécifier d'autres AWS KMS keys qui chiffrent la même clé de données en texte brut. Pour déchiffrer un champ crypté protégé par ce trousseau de clés, le trousseau de déchiffrement que vous utilisez doit inclure au moins l'un des éléments AWS KMS keys définis dans le trousseau de clés, ou non. AWS KMS keys(Un AWS KMS porte-clés sans numéro AWS KMS keys est connu sous le nom de [porte-clés AWS KMS Discovery](#kms-keyring-discovery).)
Toutes les clés d'encapsulation d'un jeu de clés de chiffrement ou d'un jeu de clés multiples doivent être en mesure de chiffrer la clé de données. Si le chiffrement d'une clé d'encapsulation échoue, la méthode de chiffrement échoue. Par conséquent, l'appelant doit disposer des [autorisations requises](#kms-keyring-permissions) pour toutes les clés du trousseau de clés. Si vous utilisez un trousseau de découverte pour chiffrer des données, seul ou dans un jeu de clés multiples, l'opération de chiffrement échoue.
Les exemples suivants utilisent la `CreateAwsKmsMrkMultiKeyring` méthode pour créer un jeu de AWS KMS clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode crée automatiquement le AWS KMS client et garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples. Ces exemples utilisent une [clé ARNs](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) pour identifier les clés KMS. Pour plus d’informations, consultez [Identification AWS KMS keys dans un AWS KMS porte-clés](#kms-keyring-id).
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyArn)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = kmsKeyArn
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
let provider_config = MaterialProvidersConfig::builder().build()?;
let mat_prov = client::Client::from_conf(provider_config)?;
let kms_keyring = mat_prov
.create_aws_kms_mrk_multi_keyring()
.generator(kms_key_id)
.send()
.await?;
```
------
Les exemples suivants utilisent la `CreateAwsKmsRsaKeyring` méthode pour créer un AWS KMS trousseau de clés avec une clé RSA KMS asymétrique. Pour créer un trousseau de AWS KMS clés RSA asymétrique, entrez les valeurs suivantes.
+ `kmsClient`: créer un nouveau AWS KMS client
+ `kmsKeyID`: l'ARN de clé qui identifie votre clé RSA KMS asymétrique
+ `publicKey`: un ByteBuffer fichier PEM codé en UTF-8 qui représente la clé publique de la clé que vous avez transmise `kmsKeyID`
+ `encryptionAlgorithm`: l'algorithme de chiffrement doit être `RSAES_OAEP_SHA_256` ou `RSAES_OAEP_SHA_1`
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsRsaKeyringInput createAwsKmsRsaKeyringInput =
CreateAwsKmsRsaKeyringInput.builder()
.kmsClient(KmsClient.create())
.kmsKeyId(rsaKMSKeyArn)
.publicKey(publicKey)
.encryptionAlgorithm(EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256)
.build();
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsRsaKeyringInput = new CreateAwsKmsRsaKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = rsaKMSKeyArn,
PublicKey = publicKey,
EncryptionAlgorithm = EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256
};
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_rsa_keyring = mpl
.create_aws_kms_rsa_keyring()
.kms_key_id(rsa_kms_key_arn)
.public_key(public_key)
.encryption_algorithm(aws_sdk_kms::types::EncryptionAlgorithmSpec::RsaesOaepSha256)
.kms_client(aws_sdk_kms::Client::new(&sdk_config))
.send()
.await?;
```
------
## Utilisation de plusieurs régions AWS KMS keys
Vous pouvez utiliser plusieurs régions AWS KMS keys comme clés d'encapsulation dans le SDK de chiffrement AWS de base de données. Si vous chiffrez avec une clé multirégionale dans une clé Région AWS, vous pouvez déchiffrer en utilisant une clé multirégionale associée dans une autre. Région AWS
Les clés KMS multirégionales sont un ensemble de AWS KMS keys clés différentes Régions AWS qui ont le même matériau clé et le même identifiant de clé. Vous pouvez utiliser ces clés *associées* comme s'il s'agissait de la même clé dans différentes régions. Les clés multirégionales prennent en charge les scénarios courants de reprise après sinistre et de sauvegarde qui nécessitent le chiffrement dans une région et le déchiffrement dans une autre région sans passer un appel interrégional à. AWS KMS Pour plus d'informations sur les clés multirégionales, consultez la section [Utilisation des clés multirégionales](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) dans le manuel du *AWS Key Management Service développeur*.
Pour prendre en charge les clés multirégionales, le SDK de chiffrement de AWS base de données inclut AWS KMS multi-Region-aware des trousseaux de clés. La `CreateAwsKmsMrkMultiKeyring` méthode prend en charge les clés à région unique et à régions multiples.
+ Pour les clés à région unique, le multi-Region-aware symbole se comporte comme le porte-clés à région unique AWS KMS . Il tente de déchiffrer le texte chiffré uniquement à l'aide de la clé à région unique qui a chiffré les données. Pour simplifier votre expérience en matière de trousseau de AWS KMS clés, nous vous recommandons d'utiliser `CreateAwsKmsMrkMultiKeyring` cette méthode chaque fois que vous utilisez une clé KMS de chiffrement symétrique.
+ Pour les clés multirégionales, le multi-Region-aware symbole tente de déchiffrer le texte chiffré avec la même clé multirégionale qui a chiffré les données ou avec la clé multirégionale associée dans la région que vous spécifiez.
Dans les multi-Region-aware trousseaux de clés qui utilisent plusieurs clés KMS, vous pouvez spécifier plusieurs clés à région unique ou multirégionale. Toutefois, vous ne pouvez spécifier qu'une seule clé pour chaque ensemble de clés multirégionales associées. Si vous spécifiez plusieurs identificateurs de clé avec le même identifiant de clé, l'appel du constructeur échoue.
Les exemples suivants créent un AWS KMS trousseau de clés avec une clé KMS multirégionale. Les exemples spécifient une clé multirégionale comme clé génératrice et une clé mono-région comme clé enfant.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput createAwsKmsMrkMultiKeyringInput =
CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(multiRegionKeyArn)
.kmsKeyIds(Collections.singletonList(kmsKeyArn))
.build();
IKeyring awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = multiRegionKeyArn,
KmsKeyIds = new List { kmsKeyArn }
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let aws_kms_mrk_multi_keyring = mpl
.create_aws_kms_mrk_multi_keyring()
.generator(multiRegion_key_arn)
.kms_key_ids(vec![key_arn.to_string()])
.send()
.await?;
```
------
Lorsque vous utilisez des trousseaux de AWS KMS clés multirégionaux, vous pouvez déchiffrer le texte chiffré en mode strict ou en mode découverte. Pour déchiffrer le texte chiffré en mode strict, instanciez le symbole multi-Region-aware avec la clé ARN de la clé multirégionale associée dans la région dans laquelle vous êtes en train de déchiffrer le texte chiffré. Si vous spécifiez l'ARN d'une clé multirégionale associée dans une région différente (par exemple, la région où l'enregistrement a été chiffré), le multi-Region-aware symbole émettra un appel interrégional pour cela. AWS KMS key
Lors du déchiffrement en mode strict, le multi-Region-aware symbole nécessite un ARN clé. Il n'accepte qu'un seul ARN de clé pour chaque ensemble de clés multirégionales associées.
Vous pouvez également déchiffrer en *mode découverte* à l'aide de clés AWS KMS multirégionales. Lorsque vous déchiffrez en mode découverte, vous n'en spécifiez aucune. AWS KMS keys(Pour plus d'informations sur les porte-clés de AWS KMS découverte d'une seule région, consultez[Utilisation d'un porte-clés AWS KMS Discovery](#kms-keyring-discovery).)
Si vous avez chiffré avec une clé multirégionale, le multi-Region-aware symbole en mode découverte essaiera de le déchiffrer en utilisant une clé multirégionale associée dans la région locale. S'il n'en existe aucun, l'appel échoue. En mode découverte, le SDK AWS de chiffrement de base de données ne tente pas d'appeler plusieurs régions pour obtenir la clé multirégionale utilisée pour le chiffrement.
## Utilisation d'un porte-clés AWS KMS Discovery
Lors du déchiffrement, il est recommandé de spécifier les clés d'encapsulation que le SDK de chiffrement de AWS base de données peut utiliser. Pour suivre cette bonne pratique, utilisez un jeu de clés de AWS KMS déchiffrement qui limite les clés AWS KMS d'encapsulage à celles que vous spécifiez. Toutefois, vous pouvez également créer un trousseau de *clés de AWS KMS découverte*, c'est-à-dire un AWS KMS trousseau de clés ne spécifiant aucune clé d'encapsulation.
Le SDK AWS Database Encryption fournit un jeu de clés de AWS KMS découverte standard et un jeu de clés de découverte pour les AWS KMS clés multirégionales. Pour plus d'informations sur l'utilisation de clés multirégionales avec le SDK AWS de chiffrement de base de données, consultez. [Utilisation de plusieurs régions AWS KMS keys](#config-mrks)
Comme il ne spécifie aucune clé d'encapsulation, un jeu de clés de découverte ne peut pas chiffrer les données. Si vous utilisez un trousseau de découverte pour chiffrer des données, seul ou dans un jeu de clés multiples, l'opération de chiffrement échoue.
Lors du déchiffrement, un jeu de clés de découverte permet au SDK de chiffrement de AWS base de données de demander AWS KMS à déchiffrer toute clé de données chiffrée à l'aide de AWS KMS key celle qui l'a chiffrée, indépendamment de son propriétaire ou de son accès. AWS KMS key L'appel ne réussit que lorsque l'appelant est `kms:Decrypt` autorisé à utiliser le. AWS KMS key
**Important**
Si vous incluez un jeu de clés de AWS KMS découverte dans un jeu de clés [multiples de déchiffrement, le jeu de clés](use-multi-keyring.md) de découverte remplace toutes les restrictions relatives aux clés KMS spécifiées par les autres trousseaux de clés du jeu de clés multiples. Le porte-clés multiple se comporte comme le porte-clés le moins restrictif. Si vous utilisez un trousseau de découverte pour chiffrer des données, seul ou dans un jeu de clés multiples, l'opération de chiffrement échoue
Le SDK AWS Database Encryption fournit un jeu de clés de AWS KMS découverte pour plus de commodité. Cependant, nous vous recommandons d'utiliser un porte-clés plus limité chaque fois que possible pour les raisons suivantes.
+ **Authenticité** — Un trousseau de clés de AWS KMS découverte peut utiliser tout AWS KMS key élément utilisé pour chiffrer une clé de données dans la description du matériel, à condition que l'appelant soit autorisé à l'utiliser pour le déchiffrer. AWS KMS key Ce n'est peut-être pas AWS KMS key celui que l'appelant a l'intention d'utiliser. Par exemple, l'une des clés de données cryptées peut avoir été cryptée sous une forme moins sécurisée AWS KMS key que tout le monde peut utiliser.
+ **Latence et performances** : un jeu de clés de AWS KMS découverte peut être sensiblement plus lent que les autres car le SDK de chiffrement de AWS base de données essaie de déchiffrer toutes les clés de données chiffrées, y compris celles chiffrées AWS KMS keys dans d'autres régions, Comptes AWS et AWS KMS keys que l'appelant n'est pas autorisé à utiliser pour le déchiffrement.
Si vous utilisez un trousseau de clés de découverte, nous vous recommandons d'utiliser un [*filtre de découverte*](configure.md#config-discovery) pour limiter les clés KMS pouvant être utilisées à celles Comptes AWS des [partitions](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) spécifiées. Pour obtenir de l'aide pour trouver votre identifiant de compte et votre partition, consultez la section [Vos Compte AWS identifiants](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html) et votre [format ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arns-syntax) dans le *Références générales AWS*.
Les exemples de code suivants instancient un jeu de clés de AWS KMS découverte avec un filtre de découverte qui limite les clés KMS que le SDK de chiffrement de AWS base de données peut utiliser à celles de la `aws` partition et du compte d'exemple. `111122223333`
Avant d'utiliser ce code, remplacez les valeurs d'exemple Compte AWS et de partition par des valeurs valides pour votre partition Compte AWS and. Si vos clés KMS se trouvent dans les régions de Chine, utilisez la valeur de `aws-cn` partition. Si vos clés KMS sont incluses AWS GovCloud (US) Regions, utilisez la valeur de `aws-us-gov` partition. Pour tous les autres Régions AWS, utilisez la valeur de `aws` partition.
------
#### [ Java ]
```
// Create discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
.partition("aws")
.accountIds(111122223333)
.build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
.discoveryFilter(discoveryFilter)
.build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create discovery filter
var discoveryFilter = new DiscoveryFilter
{
Partition = "aws",
AccountIds = 111122223333
};
// Create the discovery keyring
var createAwsKmsMrkDiscoveryMultiKeyringInput = new CreateAwsKmsMrkDiscoveryMultiKeyringInput
{
DiscoveryFilter = discoveryFilter
};
var decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ Rust ]
```
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.partition("aws")
.account_ids(111122223333)
.build()?;
// Create the discovery keyring
let decrypt_keyring = mpl
.create_aws_kms_mrk_discovery_multi_keyring()
.discovery_filter(discovery_filter)
.send()
.await?;
```
------
## Utiliser un porte-clés de découverte AWS KMS régional
Un *trousseau de découverte AWS KMS régional* est un trousseau de clés qui ne précise pas les ARNs clés KMS. Au lieu de cela, il permet au SDK AWS de chiffrement de base de données de déchiffrer en utilisant uniquement les clés KMS en particulier. Régions AWS
Lors du déchiffrement à l'aide d'un jeu de clés de découverte AWS KMS régional, le SDK AWS de chiffrement de base de données déchiffre toute clé de données chiffrée selon un dans le spécifié. AWS KMS key Région AWS Pour réussir, l'appelant doit avoir l'`kms:Decrypt`autorisation d'utiliser au moins l'un des éléments spécifiés Région AWS qui ont chiffré une clé de données. AWS KMS keys
Comme les autres trousseaux de découverte, le trousseau de clés de découverte régional n'a aucun effet sur le chiffrement. Cela ne fonctionne que lors du déchiffrement de champs chiffrés. Si vous utilisez un jeu de clés de découverte régional dans un jeu de clés multiples utilisé pour le chiffrement et le déchiffrement, il n'est efficace que lors du déchiffrement. Si vous utilisez un jeu de clés de découverte multirégional pour chiffrer des données, seul ou dans un jeu de clés multirégional, l'opération de chiffrement échoue.
**Important**
Si vous incluez un trousseau de clés de découverte AWS KMS régional dans un jeu de clés [multiples de déchiffrement, le jeu de clés](use-multi-keyring.md) de découverte régional remplace toutes les restrictions relatives aux clés KMS spécifiées par les autres trousseaux de clés du jeu de clés multiples. Le porte-clés multiple se comporte comme le porte-clés le moins restrictif. Un trousseau de AWS KMS découverte n'a aucun effet sur le chiffrement lorsqu'il est utilisé seul ou dans un jeu de clés multiples.
Le jeu de clés de découverte régional du SDK AWS de chiffrement de base de données tente de déchiffrer uniquement avec des clés KMS dans la région spécifiée. Lorsque vous utilisez un trousseau de clés de découverte, vous configurez la région sur le AWS KMS client. Ces implémentations du SDK de chiffrement de AWS base de données ne filtrent pas les clés KMS par région, mais AWS KMS échoueront à une demande de déchiffrement de clés KMS en dehors de la région spécifiée.
Si vous utilisez un trousseau de clés de découverte, nous vous recommandons d'utiliser un *filtre de découverte* afin de limiter les clés KMS utilisées pour le déchiffrement à celles figurant dans les partitions Comptes AWS et les partitions spécifiées.
Par exemple, le code suivant crée un trousseau de clés de découverte AWS KMS régional avec un filtre de découverte. Ce jeu de clés limite le SDK AWS de chiffrement de base de données aux clés KMS du compte 111122223333 dans la région USA Ouest (Oregon) (us-west-2).
------
#### [ Java ]
```
// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
.partition("aws")
.accountIds(111122223333)
.build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
.discoveryFilter(discoveryFilter)
.regions("us-west-2")
.build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create discovery filter
var discoveryFilter = new DiscoveryFilter
{
Partition = "aws",
AccountIds = 111122223333
};
// Create the discovery keyring
var createAwsKmsMrkDiscoveryMultiKeyringInput = new CreateAwsKmsMrkDiscoveryMultiKeyringInput
{
DiscoveryFilter = discoveryFilter,
Regions = us-west-2
};
var decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ Rust ]
```
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.partition("aws")
.account_ids(111122223333)
.build()?;
// Create the discovery keyring
let decrypt_keyring = mpl
.create_aws_kms_mrk_discovery_multi_keyring()
.discovery_filter(discovery_filter)
.regions(us-west-2)
.send()
.await?;
```
------
# AWS KMS Porte-clés hiérarchiques
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
**Note**
Depuis le 24 juillet 2023, les clés de branche créées lors de la version préliminaire pour les développeurs ne sont plus prises en charge. Créez de nouvelles clés de branche pour continuer à utiliser le magasin de clés que vous avez créé lors de la version préliminaire pour les développeurs.
Avec le trousseau de clés AWS KMS hiérarchique, vous pouvez protéger vos documents cryptographiques sous une clé KMS de chiffrement symétrique sans avoir à appeler AWS KMS chaque fois que vous chiffrez ou déchiffrez un enregistrement. Il s'agit d'un bon choix pour les applications qui doivent minimiser les appels AWS KMS, ainsi que pour les applications qui peuvent réutiliser certains matériels cryptographiques sans enfreindre leurs exigences de sécurité.
Le trousseau de clés hiérarchique est une solution de mise en cache des matériaux cryptographiques qui réduit le nombre d' AWS KMS appels en utilisant des *clés de branche AWS KMS * protégées conservées dans une table Amazon DynamoDB, puis en mettant en cache localement les éléments clés de branche utilisés dans les opérations de chiffrement et de déchiffrement. La table DynamoDB sert de magasin de clés qui gère et protège les clés de branche. Il stocke la clé de branche active et toutes les versions précédentes de la clé de branche. La clé de branche *active* est la version de clé de branche la plus récente. Le trousseau de clés hiérarchique utilise une clé de chiffrement de données unique pour chaque demande de chiffrement et chiffre chaque clé de chiffrement de données avec une clé d'encapsulation unique dérivée de la clé de branche active. Le trousseau de clés hiérarchique dépend de la hiérarchie établie entre les clés de branche actives et leurs clés d'encapsulation dérivées.
Le trousseau de clés hiérarchique utilise généralement chaque version de clé de branche pour satisfaire plusieurs demandes. Mais vous contrôlez la mesure dans laquelle les clés de branche actives sont réutilisées et vous déterminez la fréquence à laquelle la clé de branche active est pivotée. La version active de la clé de branche reste active jusqu'à ce que vous la [fassiez pivoter](rotate-branch-key.md). Les versions précédentes de la clé de branche active ne seront pas utilisées pour effectuer des opérations de chiffrement, mais elles peuvent toujours être interrogées et utilisées dans des opérations de déchiffrement.
Lorsque vous instanciez le trousseau de clés hiérarchique, il crée un cache local. Vous spécifiez une [limite de cache](#cache-limit) qui définit la durée maximale pendant laquelle les éléments clés de branche sont stockés dans le cache local avant leur expiration et leur expulsion du cache. Le trousseau de clés hiérarchique effectue un AWS KMS appel pour déchiffrer la clé de branche et assembler les matériaux de la clé de branche la première fois que a `branch-key-id` est spécifié dans une opération. Les éléments clés de branche sont ensuite stockés dans le cache local et réutilisés pour toutes les opérations de chiffrement et de déchiffrement qui le spécifient `branch-key-id` jusqu'à l'expiration de la limite de cache. Le stockage des éléments clés de branche dans le cache local réduit le nombre d' AWS KMS appels. Par exemple, considérez une limite de cache de 15 minutes. Si vous effectuez 10 000 opérations de chiffrement dans cette limite de cache, le trousseau de [AWS KMS clés traditionnel](use-kms-keyring.md) devra effectuer 10 000 AWS KMS appels pour satisfaire 10 000 opérations de chiffrement. Si vous en avez un actif`branch-key-id`, le trousseau de clés hiérarchique n'a besoin que d'un seul AWS KMS appel pour satisfaire 10 000 opérations de chiffrement.
Le cache local sépare le matériel de chiffrement du matériel de déchiffrement. Les matériaux de chiffrement sont assemblés à partir de la clé de branche active et réutilisés pour toutes les opérations de chiffrement jusqu'à l'expiration de la limite de cache. Les matériaux de déchiffrement sont assemblés à partir de l'ID et de la version de la clé de branche identifiés dans les métadonnées du champ crypté, et ils sont réutilisés pour toutes les opérations de déchiffrement liées à l'ID et à la version de la clé de branche jusqu'à l'expiration de la limite de cache. Le cache local peut stocker plusieurs versions de la même clé de branche à la fois. Lorsque le cache local est configuré pour utiliser un[branch key ID supplier](#branch-key-id-supplier), il peut également stocker des éléments clés de branche provenant de plusieurs clés de branche actives à la fois.
**Note**
Toutes les mentions du jeu de *clés hiérarchique* dans le SDK de chiffrement AWS de base de données font référence au jeu de clés AWS KMS hiérarchique.
**Topics**
+ [Comment ça marche](#how-hierarchical-keyring-works)
+ [Conditions préalables](#hierarchical-keyring-prereqs)
+ [Autorisations requises](#hierarchical-keyring-permissions)
+ [Choisissez un cache](#hierarchical-keyring-caches)
+ [Création d'un trousseau de clés hiérarchique](#initialize-hierarchical-keyring)
+ [Utilisation du trousseau de clés hiérarchique pour un chiffrement consultable](#searchable-encryption-hierarchical-keyrings)
## Comment ça marche
Les procédures pas à pas suivantes décrivent comment le trousseau de clés hiérarchique assemble le matériel de chiffrement et de déchiffrement, ainsi que les différents appels effectués par le trousseau de clés pour les opérations de chiffrement et de déchiffrement. Pour plus de détails techniques sur les processus de dérivation des clés d'encapsulation et de chiffrement des clés de données en texte clair, consultez la section Détails techniques du trousseau de [clés AWS KMS hiérarchique](reference.md#hierarchical-keyring-details).
**Chiffrer et signer**
La procédure pas à pas suivante décrit comment le trousseau de clés hiérarchique assemble les matériaux de chiffrement et en déduit une clé d'encapsulation unique.
1. La méthode de cryptage demande au trousseau de clés hiérarchique le matériel de cryptage. Le trousseau de clés génère une clé de données en texte brut, puis vérifie s'il existe des éléments de clé de branche valides dans le cache local pour générer la clé d'encapsulation. S'il existe des documents relatifs aux clés de succursale valides, le porte-clés passe à l'**étape 4**.
1. S'il n'existe aucun matériel de clé de branche valide, le trousseau de clés hiérarchique interroge le magasin de clés pour trouver la clé de branche active.
1. Le magasin de clés appelle AWS KMS pour déchiffrer la clé de branche active et renvoie la clé de branche active en texte clair. Les données identifiant la clé de branche active sont sérialisées pour fournir des données authentifiées supplémentaires (AAD) lors de l'appel de déchiffrement à. AWS KMS
1. Le magasin de clés renvoie la clé de branche en texte brut et les données qui l'identifient, telles que la version de la clé de branche.
1. Le trousseau de clés hiérarchique assemble les éléments clés de branche (version de clé de branche en texte clair et de clé de branche) et en stocke une copie dans le cache local.
1. Le trousseau de clés hiérarchique déduit une clé d'encapsulation unique à partir de la clé de branche en texte brut et d'un sel aléatoire de 16 octets. Il utilise la clé d'encapsulation dérivée pour chiffrer une copie de la clé de données en texte brut.
La méthode de cryptage utilise le matériel de cryptage pour chiffrer et signer l'enregistrement. Pour plus d'informations sur la façon dont les enregistrements sont chiffrés et signés dans le SDK AWS de chiffrement de base de données, voir [Chiffrer et](how-it-works.md#encrypt-and-sign) signer.
**Déchiffrer et vérifier**
La procédure pas à pas suivante décrit comment le trousseau de clés hiérarchique assemble le matériel de déchiffrement et déchiffre la clé de données chiffrée.
1. Le procédé de déchiffrement identifie la clé de données chiffrée dans le champ de description matérielle de l'enregistrement chiffré et la transmet au trousseau de clés hiérarchique.
1. Le trousseau hiérarchique désérialise les données identifiant la clé de données chiffrée, y compris la version de la clé de branche, le sel de 16 octets et d'autres informations décrivant la manière dont la clé de données a été cryptée.
Pour de plus amples informations, veuillez consulter [AWS KMS Détails techniques du porte-clés hiérarchique](reference.md#hierarchical-keyring-details).
1. Le trousseau de clés hiérarchique vérifie si le cache local contient des éléments de clé de branche valides qui correspondent à la version de clé de branche identifiée à l'**étape 2**. S'il existe des documents relatifs aux clés de succursale valides, le porte-clés passe à l'**étape 6**.
1. S'il n'existe aucun matériel de clé de branche valide, le trousseau de clés hiérarchique interroge le magasin de clés pour trouver la clé de branche correspondant à la version de clé de branche identifiée à l'**étape 2**.
1. Le magasin de clés appelle AWS KMS pour déchiffrer la clé de branche et renvoie la clé de branche active en texte clair. Les données identifiant la clé de branche active sont sérialisées pour fournir des données authentifiées supplémentaires (AAD) lors de l'appel de déchiffrement à. AWS KMS
1. Le magasin de clés renvoie la clé de branche en texte brut et les données qui l'identifient, telles que la version de la clé de branche.
1. Le trousseau de clés hiérarchique assemble les éléments clés de branche (version de clé de branche en texte clair et de clé de branche) et en stocke une copie dans le cache local.
1. Le trousseau de clés hiérarchique utilise les éléments de clé de branche assemblés et le sel de 16 octets identifié à l'**étape 2** pour reproduire la clé d'encapsulation unique qui a chiffré la clé de données.
1. Le trousseau de clés hiérarchique utilise la clé d'encapsulation reproduite pour déchiffrer la clé de données et renvoie la clé de données en texte brut.
La méthode de déchiffrement utilise le matériel de déchiffrement et la clé de données en texte brut pour déchiffrer et vérifier l'enregistrement. [Pour plus d'informations sur la façon dont les enregistrements sont déchiffrés et vérifiés dans le SDK de chiffrement de AWS base de données, voir Déchiffrer et vérifier.](how-it-works.md#decrypt-and-verify)
## Conditions préalables
Avant de créer et d'utiliser un trousseau de clés hiérarchique, assurez-vous que les conditions préalables suivantes sont remplies.
+ Vous, ou l'administrateur de votre magasin de clés, avez [créé un magasin de clés](create-keystore.md) et [créé au moins une clé de branche active](create-branch-keys.md).
+ Vous avez [configuré les actions de votre magasin de clés](keystore-actions.md#config-keystore-actions).
**Note**
La façon dont vous configurez les actions de votre magasin de clés détermine les opérations que vous pouvez effectuer et les clés KMS que le trousseau de clés hiérarchique peut utiliser. Pour plus d'informations, consultez la section [Actions du magasin de clés](keystore-actions.md).
+ Vous disposez des AWS KMS autorisations requises pour accéder aux clés du magasin de clés et des succursales et les utiliser. Pour de plus amples informations, veuillez consulter [Autorisations requises](#hierarchical-keyring-permissions).
+ Vous avez examiné les types de cache pris en charge et configuré le type de cache le mieux adapté à vos besoins. Pour de plus amples informations, consultez [Choisissez un cache](#hierarchical-keyring-caches).
## Autorisations requises
Le SDK AWS de chiffrement de base de données n'en nécessite pas Compte AWS et n'en dépend pas Service AWS. Toutefois, pour utiliser un trousseau de clés hiérarchique, vous devez disposer Compte AWS des autorisations minimales suivantes sur le ou les AWS KMS key chiffrements symétriques de votre magasin de clés.
+ [Pour chiffrer et déchiffrer des données à l'aide du trousseau de clés hiérarchique, vous avez besoin de KMS:Decrypt.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
+ Pour [créer](create-branch-keys.md) et [faire pivoter](rotate-branch-key.md) des clés de branche, vous avez besoin de [kms : GenerateDataKeyWithoutPlaintext](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) et [kms : ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html).
Pour plus d'informations sur le contrôle de l'accès à vos clés de succursale et à votre magasin de clés, consultez[Implémentation des autorisations avec le moindre privilégié](keystore-least-privilege.md).
## Choisissez un cache
Le trousseau de clés hiérarchique réduit le nombre d'appels en mettant AWS KMS en cache localement les éléments clés de branche utilisés dans les opérations de chiffrement et de déchiffrement. Avant de [créer votre trousseau de clés hiérarchique](#initialize-hierarchical-keyring), vous devez choisir le type de cache que vous souhaitez utiliser. Vous pouvez utiliser le cache par défaut ou le personnaliser en fonction de vos besoins.
Le trousseau de clés hiérarchique prend en charge les types de cache suivants :
+ [Cache par défaut](#cache-default)
+ [MultiThreaded cache](#cache-multithreaded)
+ [StormTracking cache](#cache-stormtracking)
+ [Cache partagé](#cache-shared)
### Cache par défaut
Pour la plupart des utilisateurs, le cache par défaut répond à leurs exigences en matière de threading. Le cache par défaut est conçu pour prendre en charge les environnements fortement multithread. Lorsqu'une entrée de matériel de clé de branche expire, le cache par défaut empêche plusieurs threads d'appeler AWS KMS en notifiant à un thread que l'entrée de matériaux de clé de branche va expirer 10 secondes à l'avance. Cela garantit qu'un seul thread envoie une demande AWS KMS pour actualiser le cache.
La valeur par défaut et StormTracking les caches prennent en charge le même modèle de thread, mais il suffit de spécifier la capacité d'entrée pour utiliser le cache par défaut. Pour des personnalisations de cache plus détaillées, utilisez le. [StormTracking cache](#cache-stormtracking)
À moins que vous ne souhaitiez personnaliser le nombre d'entrées de matériaux clés de branche pouvant être stockées dans le cache local, il n'est pas nécessaire de spécifier un type de cache lorsque vous créez le trousseau de clés hiérarchique. Si vous ne spécifiez aucun type de cache, le trousseau de clés hiérarchique utilise le type de cache par défaut et définit la capacité d'entrée à 1 000.
Pour personnaliser le cache par défaut, spécifiez les valeurs suivantes :
+ **Capacité d'entrée** : limite le nombre d'entrées de matériaux clés de branche qui peuvent être stockées dans le cache local.
------
#### [ Java ]
```
.cache(CacheType.builder()
.Default(DefaultCache.builder()
.entryCapacity(100)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType defaultCache = new CacheType
{
Default = new DefaultCache{EntryCapacity = 100}
};
```
------
#### [ Rust ]
```
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
```
------
### MultiThreaded cache
Le MultiThreaded cache peut être utilisé en toute sécurité dans les environnements multithread, mais il ne fournit aucune fonctionnalité permettant de minimiser les appels Amazon AWS KMS DynamoDB. Par conséquent, lorsqu'une entrée de contenu clé de branche expire, tous les fils de discussion seront avertis en même temps. Cela peut entraîner plusieurs AWS KMS appels pour actualiser le cache.
Pour utiliser le MultiThreaded cache, spécifiez les valeurs suivantes :
+ **Capacité d'entrée** : limite le nombre d'entrées de matériaux clés de branche qui peuvent être stockées dans le cache local.
+ **Taille de la queue d'élagage d'entrée** : définit le nombre d'entrées à élaguer si la capacité d'entrée est atteinte.
------
#### [ Java ]
```
.cache(CacheType.builder()
.MultiThreaded(MultiThreadedCache.builder()
.entryCapacity(100)
.entryPruningTailSize(1)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType multithreadedCache = new CacheType
{
MultiThreaded = new MultiThreadedCache
{
EntryCapacity = 100,
EntryPruningTailSize = 1
}
};
```
------
#### [ Rust ]
```
CacheType::MultiThreaded(
MultiThreadedCache::builder()
.entry_capacity(100)
.entry_pruning_tail_size(1)
.build()?)
```
------
### StormTracking cache
Le StormTracking cache est conçu pour prendre en charge les environnements fortement multithread. Lorsqu'une entrée de matériel de clé de branche expire, le StormTracking cache empêche plusieurs threads d'appeler AWS KMS en notifiant à l'un d'entre eux que l'entrée de matériaux de clé de branche va expirer à l'avance. Cela garantit qu'un seul thread envoie une demande AWS KMS pour actualiser le cache.
Pour utiliser le StormTracking cache, spécifiez les valeurs suivantes :
+ **Capacité d'entrée** : limite le nombre d'entrées de matériaux clés de branche qui peuvent être stockées dans le cache local.
Valeur par défaut : 1000 entrées
+ **Taille de la queue d'élagage d'entrée** : définit le nombre d'entrées de matériaux clés de branche à tailler à la fois.
Valeur par défaut : 1 entrée
+ **Période de grâce** : définit le nombre de secondes avant l'expiration pendant lesquelles une tentative d'actualisation des documents clés de la branche est effectuée.
Valeur par défaut : 10 secondes
+ **Intervalle de grâce** : définit le nombre de secondes entre les tentatives d'actualisation des éléments clés de la branche.
Valeur par défaut : 1 seconde
+ **Ventilateur : définit** le nombre de tentatives simultanées qui peuvent être effectuées pour actualiser les documents clés de la branche.
Valeur par défaut : 20 tentatives
+ **In flight time to live (TTL)** : définit le nombre de secondes avant l'expiration d'une tentative d'actualisation des informations clés de branche. Chaque fois que le cache revient `NoSuchEntry` en réponse à un`GetCacheEntry`, cette clé de branche est considérée comme étant *en vol* jusqu'à ce que la même clé soit écrite avec une `PutCache` entrée.
Valeur par défaut : 10 secondes
+ **Sommeil** : définit le nombre de secondes pendant lesquelles un thread doit être mis en veille si le `fanOut` délai est dépassé.
Valeur par défaut : 20 millisecondes
------
#### [ Java ]
```
.cache(CacheType.builder()
.StormTracking(StormTrackingCache.builder()
.entryCapacity(100)
.entryPruningTailSize(1)
.gracePeriod(10)
.graceInterval(1)
.fanOut(20)
.inFlightTTL(10)
.sleepMilli(20)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType stormTrackingCache = new CacheType
{
StormTracking = new StormTrackingCache
{
EntryCapacity = 100,
EntryPruningTailSize = 1,
FanOut = 20,
GraceInterval = 1,
GracePeriod = 10,
InFlightTTL = 10,
SleepMilli = 20
}
};
```
------
#### [ Rust ]
```
CacheType::StormTracking(
StormTrackingCache::builder()
.entry_capacity(100)
.entry_pruning_tail_size(1)
.grace_period(10)
.grace_interval(1)
.fan_out(20)
.in_flight_ttl(10)
.sleep_milli(20)
.build()?)
```
------
### Cache partagé
Par défaut, le trousseau de clés hiérarchique crée un nouveau cache local chaque fois que vous instanciez le trousseau de clés. Cependant, le cache partagé peut contribuer à économiser de la mémoire en vous permettant de partager un cache entre plusieurs trousses de clés hiérarchiques. Plutôt que de créer un nouveau cache de matériaux cryptographiques pour chaque jeu de clés hiérarchique que vous instanciez, le cache partagé ne stocke qu'un seul cache en mémoire, qui peut être utilisé par tous les jeux de clés hiérarchiques qui le référencent. Le cache partagé permet d'optimiser l'utilisation de la mémoire en évitant la duplication du matériel cryptographique entre les trousseaux de clés. Au lieu de cela, les trousseaux de clés hiérarchiques peuvent accéder au même cache sous-jacent, réduisant ainsi l'encombrement mémoire global.
Lorsque vous créez votre cache partagé, vous définissez toujours le type de cache. Vous pouvez spécifier un [Cache par défaut](#cache-default)[MultiThreaded cache](#cache-multithreaded), ou [StormTracking cache](#cache-stormtracking) comme type de cache, ou le remplacer par un cache personnalisé compatible.
**Partitions**
Plusieurs trousseaux de clés hiérarchiques peuvent utiliser un seul cache partagé. Lorsque vous créez un trousseau de clés hiérarchique avec un cache partagé, vous pouvez définir un **ID de partition** facultatif. L'ID de partition permet de distinguer le jeu de clés hiérarchique qui écrit dans le cache. Si deux trousseaux de clés hiérarchiques font référence au même ID de partition et au même ID de clé de branche[logical key store name](create-keystore.md#logical-key-store-name), les deux trousseaux de clés partageront les mêmes entrées de cache dans le cache. Si vous créez deux trousseaux de clés hiérarchiques avec le même cache partagé, mais avec une partition différente IDs, chaque trousseau de clés n'accèdera aux entrées du cache qu'à partir de sa propre partition désignée dans le cache partagé. Les partitions agissent comme des divisions logiques au sein du cache partagé, permettant à chaque jeu de clés hiérarchique de fonctionner indépendamment sur sa propre partition désignée, sans interférer avec les données stockées dans l'autre partition.
Si vous avez l'intention de réutiliser ou de partager les entrées du cache d'une partition, vous devez définir votre propre ID de partition. Lorsque vous transmettez l'ID de partition à votre trousseau de clés hiérarchique, celui-ci peut réutiliser les entrées du cache déjà présentes dans le cache partagé, sans avoir à récupérer et à réautoriser les éléments clés de branche. Si vous ne spécifiez pas d'ID de partition, un ID de partition unique est automatiquement attribué au trousseau de clés chaque fois que vous instanciez le trousseau de clés hiérarchique.
Les procédures suivantes montrent comment créer un cache partagé avec le [type de cache par défaut](#cache-default) et le transmettre à un trousseau de clés hiérarchique.
1. Créez un `CryptographicMaterialsCache` (CMC) à l'aide de la [bibliothèque des fournisseurs de matériaux](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL).
------
#### [ Java ]
```
// Instantiate the MPL
final MaterialProviders matProv =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
// Create a CacheType object for the Default cache
final CacheType cache =
CacheType.builder()
.Default(DefaultCache.builder().entryCapacity(100).build())
.build();
// Create a CMC using the default cache
final CreateCryptographicMaterialsCacheInput cryptographicMaterialsCacheInput =
CreateCryptographicMaterialsCacheInput.builder()
.cache(cache)
.build();
final ICryptographicMaterialsCache sharedCryptographicMaterialsCache =
matProv.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ C\$1 / .NET ]
```
// Instantiate the MPL
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create a CacheType object for the Default cache
var cache = new CacheType { Default = new DefaultCache{EntryCapacity = 100} };
// Create a CMC using the default cache
var cryptographicMaterialsCacheInput = new CreateCryptographicMaterialsCacheInput {Cache = cache};
var sharedCryptographicMaterialsCache = materialProviders.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ Rust ]
```
// Instantiate the MPL
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create a CacheType object for the default cache
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
// Create a CMC using the default cache
let shared_cryptographic_materials_cache: CryptographicMaterialsCacheRef = mpl.
create_cryptographic_materials_cache()
.cache(cache)
.send()
.await?;
```
------
1. Créez un `CacheType` objet pour le cache partagé.
Transmettez le `sharedCryptographicMaterialsCache` que vous avez créé à l'**étape 1** au nouvel `CacheType` objet.
------
#### [ Java ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
final CacheType sharedCache =
CacheType.builder()
.Shared(sharedCryptographicMaterialsCache)
.build();
```
------
#### [ C\$1 / .NET ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
var sharedCache = new CacheType { Shared = sharedCryptographicMaterialsCache };
```
------
#### [ Rust ]
```
// Create a CacheType object for the shared_cryptographic_materials_cache
let shared_cache: CacheType = CacheType::Shared(shared_cryptographic_materials_cache);
```
------
1. Passez l'`sharedCache`objet de l'**étape 2** à votre trousseau de clés hiérarchique.
Lorsque vous créez un trousseau de clés hiérarchique avec un cache partagé, vous pouvez éventuellement définir un `partitionID` pour partager les entrées du cache entre plusieurs trousseaux hiérarchiques. Si vous ne spécifiez pas d'ID de partition, le trousseau de clés hiérarchique attribue automatiquement un identifiant de partition unique au trousseau de clés.
**Note**
Vos trousseaux de clés hiérarchiques partageront les mêmes entrées de cache dans un cache partagé si vous créez au moins deux trousseaux de clés faisant référence au même ID de partition et au même ID de clé de branche. [logical key store name](create-keystore.md#logical-key-store-name) Si vous ne souhaitez pas que plusieurs trousseaux de clés partagent les mêmes entrées de cache, vous devez utiliser un identifiant de partition unique pour chaque jeu de clés hiérarchique.
L'exemple suivant crée un jeu de clés hiérarchique avec une [branch key ID supplier](#branch-key-id-supplier) [limite de cache](#cache-limit) de 600 secondes. Pour plus d'informations sur les valeurs définies dans la configuration hiérarchique du trousseau de clés suivante, consultez[Création d'un trousseau de clés hiérarchique](#initialize-hierarchical-keyring).
------
#### [ Java ]
```
// Create the Hierarchical keyring
final CreateAwsKmsHierarchicalKeyringInput keyringInput =
CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(sharedCache)
.partitionID(partitionID)
.build();
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create the Hierarchical keyring
var createKeyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
Cache = sharedCache,
TtlSeconds = 600,
PartitionId = partitionID
};
var keyring = materialProviders.CreateAwsKmsHierarchicalKeyring(createKeyringInput);
```
------
#### [ Rust ]
```
// Create the Hierarchical keyring
let keyring1 = mpl
.create_aws_kms_hierarchical_keyring()
.key_store(key_store1)
.branch_key_id(branch_key_id.clone())
// CryptographicMaterialsCacheRef is an Rc (Reference Counted), so if you clone it to
// pass it to different Hierarchical Keyrings, it will still point to the same
// underlying cache, and increment the reference count accordingly.
.cache(shared_cache.clone())
.ttl_seconds(600)
.partition_id(partition_id.clone())
.send()
.await?;
```
------
## Création d'un trousseau de clés hiérarchique
Pour créer un trousseau de clés hiérarchique, vous devez fournir les valeurs suivantes :
+ **Le nom d'un magasin clé**
Le nom de la table DynamoDB que vous, ou votre administrateur de magasin de clés, avez créée pour servir de magasin de clés.
+
**Une limite de durée de vie du cache (TTL)**
Durée en secondes pendant laquelle une entrée de clé de branche dans le cache local peut être utilisée avant son expiration. La limite de cache TTL détermine la fréquence à laquelle le client appelle AWS KMS pour autoriser l'utilisation des clés de branche. Cette valeur doit être supérieure à zéro. Une fois la limite de cache TTL expirée, l'entrée n'est jamais servie et sera expulsée du cache local.
+ **Un identifiant de clé de branche**
Vous pouvez soit configurer statiquement le `branch-key-id` identifiant d'une seule clé de branche active dans votre magasin de clés, soit fournir un fournisseur d'ID de clé de branche.
Le *fournisseur d'ID de clé de branche* utilise les champs stockés dans le contexte de chiffrement pour déterminer quelle clé de branche est requise pour déchiffrer un enregistrement. Par défaut, seules les clés de partition et de tri sont incluses dans le contexte de chiffrement. Toutefois, vous pouvez utiliser l'[action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique](concepts.md#crypt-actions) pour inclure des champs supplémentaires dans le contexte de chiffrement.
Nous vous recommandons vivement de faire appel à un fournisseur d'ID de clé de branche pour les bases de données mutualisées où chaque locataire possède sa propre clé de branche. Vous pouvez utiliser le fournisseur d'ID de clé de succursale pour créer un nom convivial pour votre clé de succursale IDs afin de reconnaître facilement l'ID de clé de branche correct pour un locataire spécifique. Par exemple, le nom convivial vous permet de faire référence à une clé de branche au `tenant1` lieu de`b3f61619-4d35-48ad-a275-050f87e15122`.
Pour les opérations de déchiffrement, vous pouvez soit configurer de manière statique un jeu de clés hiérarchique unique pour limiter le déchiffrement à un seul locataire, soit utiliser le fournisseur d'ID de clé de branche pour identifier le locataire responsable du déchiffrement d'un enregistrement.
+ **(Facultatif) Un cache**
Si vous souhaitez personnaliser le type de cache ou le nombre d'entrées clés de branche pouvant être stockées dans le cache local, spécifiez le type de cache et la capacité d'entrée lorsque vous initialisez le trousseau de clés.
Le trousseau de clés hiérarchique prend en charge les types de cache suivants : par défaut MultiThreaded, StormTracking, et partagé. Pour plus d'informations et des exemples illustrant comment définir chaque type de cache, consultez[Choisissez un cache](#hierarchical-keyring-caches).
Si vous ne spécifiez pas de cache, le trousseau de clés hiérarchique utilise automatiquement le type de cache par défaut et définit la capacité d'entrée à 1 000.
+ **(Facultatif) Un identifiant de partition**
Si vous spécifiez le[Cache partagé](#cache-shared), vous pouvez éventuellement définir un ID de partition. L'ID de partition permet de distinguer le jeu de clés hiérarchique qui écrit dans le cache. Si vous avez l'intention de réutiliser ou de partager les entrées du cache d'une partition, vous devez définir votre propre ID de partition. Vous pouvez spécifier n'importe quelle chaîne pour l'ID de partition. Si vous ne spécifiez pas d'ID de partition, un ID de partition unique est automatiquement attribué au trousseau de clés lors de sa création.
Pour de plus amples informations, veuillez consulter [Partitions](#shared-cache-partitions).
**Note**
Vos trousseaux de clés hiérarchiques partageront les mêmes entrées de cache dans un cache partagé si vous créez au moins deux trousseaux de clés faisant référence au même ID de partition et au même ID de clé de branche. [logical key store name](create-keystore.md#logical-key-store-name) Si vous ne souhaitez pas que plusieurs trousseaux de clés partagent les mêmes entrées de cache, vous devez utiliser un identifiant de partition unique pour chaque jeu de clés hiérarchique.
+ **(Facultatif) Une liste de jetons de subvention**
Si vous contrôlez l'accès à la clé KMS dans votre trousseau de clés hiérarchique avec [des autorisations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html), vous devez fournir tous les jetons de subvention nécessaires lorsque vous initialisez le trousseau de clés.
### Création d'un trousseau de clés hiérarchique avec un identifiant de clé de branche statique
Les exemples suivants montrent comment créer un jeu de clés hiérarchique avec un identifiant de clé de branche statique, le[Cache par défaut](#cache-default), et une limite de cache TTL de 600 secondes.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(branchKeyStoreName)
.branchKeyId(branch-key-id)
.ttlSeconds(600)
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.branch_key_id(branch_key_id)
.key_store(branch_key_store_name)
.ttl_seconds(600)
.send()
.await?;
```
------
### Créez un trousseau de clés hiérarchique avec un fournisseur d'identifiant de clé de succursale
Les procédures suivantes montrent comment créer un trousseau de clés hiérarchique avec un fournisseur d'ID de clé de branche.
1. Création d'un fournisseur d'ID de clé de succursale
L'exemple suivant crée des noms conviviaux pour les deux clés de branche créées à l'**étape 1** et appelle `CreateDynamoDbEncryptionBranchKeyIdSupplier` à créer un fournisseur d'ID de clé de branche avec le SDK AWS Database Encryption pour le client DynamoDB.
------
#### [ Java ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier implements IDynamoDbKeyBranchKeyIdSupplier {
private static String branchKeyIdForTenant1;
private static String branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this.branchKeyIdForTenant1 = tenant1Id;
this.branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
final DynamoDbEncryption ddbEnc = DynamoDbEncryption.builder()
.DynamoDbEncryptionConfig(DynamoDbEncryptionConfig.builder().build())
.build();
final BranchKeyIdSupplier branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
CreateDynamoDbEncryptionBranchKeyIdSupplierInput.builder()
.ddbKeyBranchKeyIdSupplier(new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2))
.build()).branchKeyIdSupplier();
```
------
#### [ C\$1 / .NET ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier : DynamoDbKeyBranchKeyIdSupplierBase {
private String _branchKeyIdForTenant1;
private String _branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this._branchKeyIdForTenant1 = tenant1Id;
this._branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
var ddbEnc = new DynamoDbEncryption(new DynamoDbEncryptionConfig());
var branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
new CreateDynamoDbEncryptionBranchKeyIdSupplierInput
{
DdbKeyBranchKeyIdSupplier = new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2)
}).BranchKeyIdSupplier;
```
------
#### [ Rust ]
```
// Create friendly names for each branch_key_id
pub struct ExampleBranchKeyIdSupplier {
branch_key_id_for_tenant1: String,
branch_key_id_for_tenant2: String,
}
impl ExampleBranchKeyIdSupplier {
pub fn new(tenant1_id: &str, tenant2_id: &str) -> Self {
Self {
branch_key_id_for_tenant1: tenant1_id.to_string(),
branch_key_id_for_tenant2: tenant2_id.to_string(),
}
}
}
// Create the branch key ID supplier
let dbesdk_config = DynamoDbEncryptionConfig::builder().build()?;
let dbesdk = dbesdk_client::Client::from_conf(dbesdk_config)?;
let supplier = ExampleBranchKeyIdSupplier::new(tenant1_branch_key_id, tenant2_branch_key_id);
let branch_key_id_supplier = dbesdk
.create_dynamo_db_encryption_branch_key_id_supplier()
.ddb_key_branch_key_id_supplier(supplier)
.send()
.await?
.branch_key_id_supplier
.unwrap();
```
------
1. Création d'un trousseau de clés hiérarchique
Les exemples suivants initialisent un jeu de clés hiérarchique avec le fournisseur d'ID de clé de branche créé à l'**étape 1**, une limite de cache TLL de 600 secondes et une taille de cache maximale de 1 000.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity(100)
.build())
.build())
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600,
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = 100 }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.branch_key_id_supplier(branch_key_id_supplier)
.key_store(key_store)
.ttl_seconds(600)
.send()
.await?;
```
------
## Utilisation du trousseau de clés hiérarchique pour un chiffrement consultable
[Le chiffrement consultable](searchable-encryption.md) vous permet de rechercher des enregistrements cryptés sans déchiffrer l'intégralité de la base de données. [Pour ce faire, il faut indexer la valeur en texte brut d'un champ chiffré à l'aide d'une balise.](beacons.md) Pour implémenter le chiffrement consultable, vous devez utiliser un trousseau de clés hiérarchique.
L'`CreateKey`opération de stockage des clés génère à la fois une clé de branche et une *clé de balise*. La clé de branche est utilisée dans les opérations de chiffrement et de déchiffrement des enregistrements. La clé de balise est utilisée pour générer des balises.
La clé de branche et la clé de balise sont protégées par la même protection AWS KMS key que celle que vous spécifiez lors de la création de votre service de banque de clés. Une fois que l'`CreateKey`opération appelle AWS KMS pour générer la clé de branche, elle appelle [kms : GenerateDataKeyWithoutPlaintext](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) une seconde fois pour générer la clé de balise en utilisant la requête suivante.
```
{
"EncryptionContext": {
"branch-key-id" : "branch-key-id",
"type" : type,
"create-time" : "timestamp",
"tablename" : "the logical table name for your key store",
"kms-arn" : the KMS key ARN,
"hierarchy-version" : 1
},
"KeyId": "the KMS key ARN",
"NumberOfBytes": "32"
}
```
Après avoir généré les deux clés, l'`CreateKey`opération appelle [ddb : TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) pour écrire deux nouveaux éléments qui conserveront la clé de branche et la clé de balise dans votre magasin de clés de succursale.
Lorsque vous [configurez une balise standard](configure-beacons.md#config-standard-beacons), le SDK AWS de chiffrement de base de données interroge le magasin de clés pour obtenir la clé de balise. Il utilise ensuite une fonction de dérivation de extract-and-expand clé basée sur HMAC ([HKDF](https://en.wikipedia.org/wiki/HKDF)) pour combiner la clé de balise avec le nom de la [balise standard](beacons.md#standard-beacon-overview) afin de créer la clé HMAC pour une balise donnée.
Contrairement aux clés de branche, il n'existe qu'une seule version de clé de balise par clé `branch-key-id` dans un magasin de clés. La clé de la balise n'est jamais tournée.
### Définition de la source clé de votre balise
Lorsque vous définissez la [version de balise](using-beacons.md#beacon-version) pour vos balises standard et composées, vous devez identifier la clé de balise et définir une durée de vie limite de cache (TTL) pour les éléments clés de la balise. Les éléments clés des balises sont stockés dans un cache local distinct de celui des clés de branche. L'extrait suivant montre comment définir le pour une base de données à `keySource` locataire unique. Identifiez la clé de votre balise par celle à laquelle `branch-key-id` elle est associée.
------
#### [ Java ]
```
keySource(BeaconKeySource.builder()
.single(SingleKeyStore.builder()
.keyId(branch-key-id)
.cacheTTL(6000)
.build())
.build())
```
------
#### [ C\$1 / .NET ]
```
KeySource = new BeaconKeySource
{
Single = new SingleKeyStore
{
KeyId = branch-key-id,
CacheTTL = 6000
}
}
```
------
#### [ Rust ]
```
.key_source(BeaconKeySource::Single(
SingleKeyStore::builder()
// `keyId` references a beacon key.
// For every branch key we create in the keystore,
// we also create a beacon key.
// This beacon key is not the same as the branch key,
// but is created with the same ID as the branch key.
.key_id(branch_key_id)
.cache_ttl(6000)
.build()?,
))
```
------
**Définition de la source de balise dans une base de données mutualisée**
Si vous disposez d'une base de données mutualisée, vous devez spécifier les valeurs suivantes lors de la `keySource` configuration de.
+
**keyFieldName**
Définit le nom du champ qui stocke la clé `branch-key-id` associée à la balise utilisée pour générer des balises pour un locataire donné. Il `keyFieldName` peut s'agir de n'importe quelle chaîne, mais elle doit être unique à tous les autres champs de votre base de données. Lorsque vous écrivez de nouveaux enregistrements dans votre base de données, la clé `branch-key-id` identifiant la clé de balise utilisée pour générer des balises pour cet enregistrement est stockée dans ce champ. Vous devez inclure ce champ dans vos requêtes sur les balises et identifier les éléments clés de balise appropriés nécessaires pour recalculer la balise. Pour de plus amples informations, veuillez consulter [Interrogation de balises dans une base de données mutualisée](searchable-encryption-multitenant.md#query-multitenant-beacons).
+ **CacheTTL**
Durée en secondes pendant laquelle une entrée de contenu clé de balise dans le cache de balises local peut être utilisée avant son expiration. Cette valeur doit être supérieure à zéro. Lorsque la limite de cache TTL expire, l'entrée est expulsée du cache local.
+ **(Facultatif) Un cache**
Si vous souhaitez personnaliser le type de cache ou le nombre d'entrées clés de branche pouvant être stockées dans le cache local, spécifiez le type de cache et la capacité d'entrée lorsque vous initialisez le trousseau de clés.
Le trousseau de clés hiérarchique prend en charge les types de cache suivants : par défaut MultiThreaded, StormTracking, et partagé. Pour plus d'informations et des exemples illustrant comment définir chaque type de cache, consultez[Choisissez un cache](#hierarchical-keyring-caches).
Si vous ne spécifiez pas de cache, le trousseau de clés hiérarchique utilise automatiquement le type de cache par défaut et définit la capacité d'entrée à 1 000.
L'exemple suivant crée un jeu de clés hiérarchique avec un fournisseur d'ID de clé de branche, une limite de cache (TLL) de 600 secondes et une capacité d'entrée de 1 000.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(branchKeyStoreName)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity(1000)
.build())
.build());
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600,
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = 1000 }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
```
let provider_config = MaterialProvidersConfig::builder().build()?;
let mat_prov = client::Client::from_conf(provider_config)?;
let kms_keyring = mat_prov
.create_aws_kms_hierarchical_keyring()
.branch_key_id(branch_key_id)
.key_store(key_store)
.ttl_seconds(600)
.send()
.await?;
```
# AWS KMS Porte-clés ECDH
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
**Important**
Le porte-clés AWS KMS ECDH n'est disponible qu'avec la version 1.5.0 ou ultérieure de la bibliothèque des fournisseurs de matériaux.
Un porte-clés AWS KMS ECDH utilise un accord de clé asymétrique [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/key-types.html)pour dériver une clé d'encapsulation symétrique partagée entre deux parties. Tout d'abord, le trousseau de clés utilise l'algorithme d'accord de clé Elliptic Curve Diffie-Hellman (ECDH) pour dériver un secret partagé à partir de la clé privée contenue dans la paire de clés KMS de l'expéditeur et de la clé publique du destinataire. Le trousseau de clés utilise ensuite le secret partagé pour dériver la clé d'encapsulation partagée qui protège vos clés de chiffrement des données. La fonction de dérivation de clé utilisée par le SDK AWS de chiffrement de base de données (`KDF_CTR_HMAC_SHA384`) pour dériver la clé d'encapsulation partagée est conforme aux [recommandations du NIST](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf) pour la dérivation de clés.
La fonction de dérivation de clés renvoie 64 octets de matériel de saisie. Pour garantir que les deux parties utilisent le bon matériel de saisie, le SDK de chiffrement de AWS base de données utilise les 32 premiers octets comme clé d'engagement et les 32 derniers octets comme clé d'encapsulation partagée. Lors du déchiffrement, si le trousseau de clés ne peut pas reproduire la même clé d'engagement et la même clé d'encapsulation partagée que celles stockées dans le champ de description du matériel de l'enregistrement crypté, l'opération échoue. Par exemple, si vous chiffrez un enregistrement avec un trousseau de clés configuré avec la clé privée d'**Alice** et la clé publique **de Bob**, un trousseau de clés configuré avec la clé privée **de Bob** et la clé publique d'**Alice** reproduira la même clé d'engagement et la même clé d'encapsulation partagée et pourra déchiffrer l'enregistrement. Si la clé publique de Bob ne provient pas d'une paire de clés KMS, Bob peut créer un jeu de [clés ECDH brut](use-raw-ecdh-keyring.md) pour déchiffrer l'enregistrement.
Le trousseau de clés AWS KMS ECDH chiffre les enregistrements avec une clé symétrique à l'aide de l'AES-GCM. La clé de données est ensuite cryptée par enveloppe avec la clé d'encapsulation partagée dérivée à l'aide d'AES-GCM. [Chaque porte-clés AWS KMS ECDH ne peut avoir qu'une seule clé d'encapsulation partagée, mais vous pouvez inclure plusieurs porte-clés AWS KMS ECDH, seuls ou avec d'autres porte-clés, dans un porte-clés multiple.](use-multi-keyring.md)
**Topics**
+ [Autorisations requises pour les AWS KMS porte-clés ECDH](#kms-ecdh-permissions)
+ [Création d'un AWS KMS porte-clés ECDH](#kms-ecdh-create)
+ [Création d'un AWS KMS porte-clés de découverte ECDH](#kms-ecdh-discovery)
## Autorisations requises pour les AWS KMS porte-clés ECDH
Le SDK AWS Database Encryption ne nécessite pas de AWS compte et ne dépend d'aucun AWS service. Toutefois, pour utiliser un porte-clés AWS KMS ECDH, vous devez disposer d'un AWS compte et des autorisations minimales suivantes sur le porte-clés de votre trousseau AWS KMS keys de clés. Les autorisations varient en fonction du schéma d'accord clé que vous utilisez.
+ Pour chiffrer et déchiffrer des enregistrements à l'aide du schéma d'accord de `KmsPrivateKeyToStaticPublicKey` clés, vous avez besoin de [kms : GetPublicKey et [kms : DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html)](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) sur la paire de clés KMS asymétrique *de l'expéditeur*. Si vous fournissez directement la clé publique codée DER de l'expéditeur lorsque vous instanciez votre jeu de clés, vous n'avez besoin que de l'DeriveSharedSecretautorisation [kms :](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) sur la paire de clés KMS asymétrique de l'expéditeur.
+ Pour déchiffrer des enregistrements à l'aide du schéma d'accord de `KmsPublicKeyDiscovery` clés, vous avez besoin des GetPublicKey autorisations [kms : DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) et [kms :](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) sur la paire de clés KMS asymétrique spécifiée.
## Création d'un AWS KMS porte-clés ECDH
Pour créer un jeu de clés AWS KMS ECDH qui chiffre et déchiffre les données, vous devez utiliser le schéma d'accord de clés. `KmsPrivateKeyToStaticPublicKey` Pour initialiser un trousseau de clés AWS KMS ECDH avec le schéma d'accord de `KmsPrivateKeyToStaticPublicKey` clés, fournissez les valeurs suivantes :
+ ** AWS KMS key Identifiant de l'expéditeur**
Doit identifier une paire de clés KMS à courbe elliptique (ECC) asymétrique recommandée par le NIST avec une valeur de. `KeyUsage` `KEY_AGREEMENT` La clé privée de l'expéditeur est utilisée pour dériver le secret partagé.
+ **(Facultatif) Clé publique de l'expéditeur**
[Il doit s'agir d'une clé publique X.509 codée DER, également connue sous le nom de `SubjectPublicKeyInfo` (SPKI), telle que définie dans la RFC 5280.](https://tools.ietf.org/html/rfc5280)
L' AWS KMS [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)opération renvoie la clé publique d'une paire de clés KMS asymétriques dans le format CODÉ DER requis.
Pour réduire le nombre d' AWS KMS appels effectués par votre trousseau de clés, vous pouvez fournir directement la clé publique de l'expéditeur. Si aucune valeur n'est fournie pour la clé publique de l'expéditeur, le keyring appelle AWS KMS pour récupérer la clé publique de l'expéditeur.
+ **Clé publique du destinataire**
[Vous devez fournir la clé publique X.509 codée DER du destinataire, également connue sous le nom de `SubjectPublicKeyInfo` (SPKI), telle que définie dans la RFC 5280.](https://tools.ietf.org/html/rfc5280)
L' AWS KMS [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)opération renvoie la clé publique d'une paire de clés KMS asymétriques dans le format CODÉ DER requis.
+ **Spécification de la courbe**
Identifie la spécification de la courbe elliptique dans les paires de clés spécifiées. Les paires de clés de l'expéditeur et du destinataire doivent avoir la même spécification de courbe.
Valeurs valides : `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
+ **(Facultatif) Une liste de jetons de subvention**
Si vous contrôlez l'accès à la clé KMS dans votre trousseau de clés AWS KMS ECDH avec [des autorisations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html), vous devez fournir tous les jetons d'autorisation nécessaires lors de l'initialisation du trousseau de clés.
------
#### [ C\$1 / .NET ]
L'exemple suivant crée un jeu de clés AWS KMS ECDH avec la clé KMS de l'expéditeur, la clé publique de l'expéditeur et la clé publique du destinataire. Cet exemple utilise le `senderPublicKey` paramètre facultatif pour fournir la clé publique de l'expéditeur. Si vous ne fournissez pas la clé publique de l'expéditeur, le keyring appelle AWS KMS pour récupérer la clé publique de l'expéditeur. Les paires de clés de l'expéditeur et du destinataire sont toutes deux en `ECC_NIST_P256` évolution.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Must be DER-encoded X.509 public keys
var BobPublicKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the AWS KMS ECDH static keyring
var staticConfiguration = new KmsEcdhStaticConfigurations
{
KmsPrivateKeyToStaticPublicKey = new KmsPrivateKeyToStaticPublicKeyInput
{
SenderKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
SenderPublicKey = BobPublicKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'exemple suivant crée un jeu de clés AWS KMS ECDH avec la clé KMS de l'expéditeur, la clé publique de l'expéditeur et la clé publique du destinataire. Cet exemple utilise le `senderPublicKey` paramètre facultatif pour fournir la clé publique de l'expéditeur. Si vous ne fournissez pas la clé publique de l'expéditeur, le keyring appelle AWS KMS pour récupérer la clé publique de l'expéditeur. Les paires de clés de l'expéditeur et du destinataire sont toutes deux en `ECC_NIST_P256` évolution.
```
// Retrieve public keys
// Must be DER-encoded X.509 public keys
ByteBuffer BobPublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab");
ByteBuffer AlicePublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the AWS KMS ECDH static keyring
final CreateAwsKmsEcdhKeyringInput senderKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPrivateKeyToStaticPublicKey(
KmsPrivateKeyToStaticPublicKeyInput.builder()
.senderKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab")
.senderPublicKey(BobPublicKey)
.recipientPublicKey(AlicePublicKey)
.build()).build()).build();
```
------
#### [ Rust ]
L'exemple suivant crée un jeu de clés AWS KMS ECDH avec la clé KMS de l'expéditeur, la clé publique de l'expéditeur et la clé publique du destinataire. Cet exemple utilise le `sender_public_key` paramètre facultatif pour fournir la clé publique de l'expéditeur. Si vous ne fournissez pas la clé publique de l'expéditeur, le keyring appelle AWS KMS pour récupérer la clé publique de l'expéditeur.
```
// Retrieve public keys
// Must be DER-encoded X.509 keys
let public_key_file_content_sender = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_SENDER))?;
let parsed_public_key_file_content_sender = parse(public_key_file_content_sender)?;
let public_key_sender_utf8_bytes = parsed_public_key_file_content_sender.contents();
let public_key_file_content_recipient = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_RECIPIENT))?;
let parsed_public_key_file_content_recipient = parse(public_key_file_content_recipient)?;
let public_key_recipient_utf8_bytes = parsed_public_key_file_content_recipient.contents();
// Create KmsPrivateKeyToStaticPublicKeyInput
let kms_ecdh_static_configuration_input =
KmsPrivateKeyToStaticPublicKeyInput::builder()
.sender_kms_identifier(arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab)
// Must be a UTF8 DER-encoded X.509 public key
.sender_public_key(public_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let kms_ecdh_static_configuration = KmsEcdhStaticConfigurations::KmsPrivateKeyToStaticPublicKey(kms_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH keyring
let kms_ecdh_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client)
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_static_configuration)
.send()
.await?;
```
------
## Création d'un AWS KMS porte-clés de découverte ECDH
Lors du déchiffrement, il est recommandé de spécifier les clés que le SDK de chiffrement de AWS base de données peut utiliser. Pour suivre cette bonne pratique, utilisez un porte-clés AWS KMS ECDH avec le schéma d'accord de `KmsPrivateKeyToStaticPublicKey` clés. Toutefois, vous pouvez également créer un jeu de clés de découverte AWS KMS ECDH, c'est-à-dire un trousseau de clés AWS KMS ECDH capable de déchiffrer tout enregistrement dont la clé publique de la paire de clés KMS spécifiée correspond à la clé publique *du destinataire stockée dans le champ de description du* matériel de l'enregistrement chiffré.
**Important**
Lorsque vous déchiffrez des enregistrements à l'aide du schéma d'accord de `KmsPublicKeyDiscovery` clés, vous acceptez toutes les clés publiques, quel que soit leur propriétaire.
Pour initialiser un trousseau de clés AWS KMS ECDH avec le schéma d'accord de `KmsPublicKeyDiscovery` clés, fournissez les valeurs suivantes :
+ ** AWS KMS key Identifiant du destinataire**
Doit identifier une paire de clés KMS à courbe elliptique (ECC) asymétrique recommandée par le NIST avec une valeur de. `KeyUsage` `KEY_AGREEMENT`
+ **Spécification de la courbe**
Identifie la spécification de courbe elliptique dans la paire de clés KMS du destinataire.
Valeurs valides : `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
+ **(Facultatif) Une liste de jetons de subvention**
Si vous contrôlez l'accès à la clé KMS dans votre trousseau de clés AWS KMS ECDH avec [des autorisations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html), vous devez fournir tous les jetons d'autorisation nécessaires lors de l'initialisation du trousseau de clés.
------
#### [ C\$1 / .NET ]
L'exemple suivant crée un trousseau de clés de découverte AWS KMS ECDH avec une paire de clés KMS sur la `ECC_NIST_P256` courbe. Vous devez disposer des DeriveSharedSecret autorisations [kms : GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) et [kms :](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) sur la paire de clés KMS spécifiée. Ce porte-clés peut déchiffrer n'importe quel enregistrement où la clé publique de la paire de clés KMS spécifiée correspond à la clé publique du destinataire stockée dans le champ de description matérielle de l'enregistrement crypté.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create the AWS KMS ECDH discovery keyring
var discoveryConfiguration = new KmsEcdhStaticConfigurations
{
KmsPublicKeyDiscovery = new KmsPublicKeyDiscoveryInput
{
RecipientKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'exemple suivant crée un trousseau de clés de découverte AWS KMS ECDH avec une paire de clés KMS sur la `ECC_NIST_P256` courbe. Vous devez disposer des DeriveSharedSecret autorisations [kms : GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) et [kms :](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) sur la paire de clés KMS spécifiée. Ce porte-clés peut déchiffrer n'importe quel enregistrement où la clé publique de la paire de clés KMS spécifiée correspond à la clé publique du destinataire stockée dans le champ de description matérielle de l'enregistrement crypté.
```
// Create the AWS KMS ECDH discovery keyring
final CreateAwsKmsEcdhKeyringInput recipientKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPublicKeyDiscovery(
KmsPublicKeyDiscoveryInput.builder()
.recipientKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321").build()
).build())
.build();
```
------
#### [ Rust ]
```
// Create KmsPublicKeyDiscoveryInput
let kms_ecdh_discovery_static_configuration_input =
KmsPublicKeyDiscoveryInput::builder()
.recipient_kms_identifier(ecc_recipient_key_arn)
.build()?;
let kms_ecdh_discovery_static_configuration = KmsEcdhStaticConfigurations::KmsPublicKeyDiscovery(kms_ecdh_discovery_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH discovery keyring
let kms_ecdh_discovery_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client.clone())
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_discovery_static_configuration)
.send()
.await?;
```
------
# Porte-clés AES brut
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Le SDK AWS Database Encryption vous permet d'utiliser une clé symétrique AES que vous fournissez comme clé d'encapsulation qui protège votre clé de données. Vous devez générer, stocker et protéger le matériel clé, de préférence dans un module de sécurité matériel (HSM) ou un système de gestion des clés. Utilisez un trousseau de clés AES brut lorsque vous devez fournir la clé d'encapsulation et chiffrer les clés de données localement ou hors ligne.
Le jeu de clés AES brut chiffre les données à l'aide de l'algorithme AES-GCM et d'une clé d'encapsulation que vous spécifiez sous forme de tableau d'octets. [Vous ne pouvez spécifier qu'une seule clé d'encapsulation par jeu de clés AES brut, mais vous pouvez inclure plusieurs porte-clés AES bruts, seuls ou avec d'autres trousseaux de clés, dans un jeu de clés multiple.](use-multi-keyring.md)
**Espaces de noms et noms clés**
Pour identifier la clé AES dans un trousseau de clés, le trousseau de clés AES brut utilise un espace de *noms de clé* et un *nom de clé* que vous fournissez. Ces valeurs ne sont pas secrètes. Ils apparaissent en texte brut dans la [description matérielle](concepts.md#material-description) que le SDK AWS de chiffrement de base de données ajoute à l'enregistrement. Nous vous recommandons d'utiliser un espace de noms de clé dans votre HSM ou votre système de gestion de clés et un nom de clé identifiant la clé AES dans ce système.
**Note**
L'espace de noms clé et le nom de clé sont équivalents aux champs *ID* du *fournisseur (ou fournisseur*) et *ID clé* du`JceMasterKey`.
Si vous créez différents trousseaux de clés pour chiffrer et déchiffrer un champ donné, l'espace de noms et les valeurs des noms sont essentiels. Si l'espace de noms de clé et le nom de clé du jeu de clés de déchiffrement ne correspondent pas exactement, en distinguant majuscules et minuscules, à l'espace de noms de clé et au nom de clé du jeu de clés de chiffrement, le jeu de clés de déchiffrement n'est pas utilisé, même si les octets essentiels sont identiques.
Par exemple, vous pouvez définir un trousseau de clés AES brut avec un espace de noms de clé `HSM_01` et un nom de clé. `AES_256_012` Ensuite, vous utilisez ce trousseau de clés pour chiffrer certaines données. Pour déchiffrer ces données, créez un jeu de clés AES brut avec le même espace de noms, le même nom de clé et le même matériau clé.
Les exemples suivants montrent comment créer un trousseau de clés AES brut. La `AESWrappingKey` variable représente le matériel clé que vous fournissez.
------
#### [ Java ]
```
final CreateRawAesKeyringInput keyringInput = CreateRawAesKeyringInput.builder()
.keyName("AES_256_012")
.keyNamespace("HSM_01")
.wrappingKey(AESWrappingKey)
.wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var keyNamespace = "HSM_01";
var keyName = "AES_256_012";
// This example uses the key generator in Bouncy Castle to generate the key material.
// In production, use key material from a secure source.
var aesWrappingKey = new MemoryStream(GeneratorUtilities.GetKeyGenerator("AES256").GenerateKey());
// Create the keyring
var keyringInput = new CreateRawAesKeyringInput
{
KeyNamespace = keyNamespace,
KeyName = keyName,
WrappingKey = AESWrappingKey,
WrappingAlg = AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
};
var matProv = new MaterialProviders(new MaterialProvidersConfig());
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name("AES_256_012")
.key_namespace("HSM_01")
.wrapping_key(aes_key_bytes)
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
```
------
# Porte-clés RSA bruts
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Le trousseau RSA brut effectue le chiffrement et le déchiffrement asymétriques des clés de données dans la mémoire locale à l'aide des clés publiques et privées RSA que vous fournissez. Vous devez générer, stocker et protéger la clé privée, de préférence dans un module de sécurité matériel (HSM) ou un système de gestion des clés. La fonction de chiffrement chiffre la clé de données sous la clé publique RSA. La fonction de déchiffrement déchiffre la clé de données à l'aide de la clé privée. Vous pouvez choisir parmi plusieurs modes de remplissage RSA.
Un porte-clés RSA brut qui chiffre et déchiffre doit inclure une clé publique asymétrique et une clé privée en paire. Toutefois, vous pouvez chiffrer des données à l'aide d'un jeu de clés RSA brut contenant uniquement une clé publique, et vous pouvez déchiffrer des données à l'aide d'un jeu de clés RSA brut contenant uniquement une clé privée. [Vous pouvez inclure n'importe quel trousseau RSA brut dans un trousseau à clés multiples.](use-multi-keyring.md) Si vous configurez un jeu de clés RSA brut avec une clé publique et une clé privée, assurez-vous qu'elles font partie de la même paire de clés.
Le trousseau de clés RSA brut est équivalent au fichier [JceMasterKey](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html)in et interagit avec celui-ci Kit SDK de chiffrement AWS pour Java lorsqu'il est utilisé avec des clés de chiffrement asymétriques RSA.
**Note**
Le porte-clés RSA brut ne prend pas en charge les clés KMS asymétriques. [Pour utiliser des clés RSA KMS asymétriques, créez un AWS KMS trousseau de clés.](use-kms-keyring.md)
**Espaces de noms et noms**
*Pour identifier le contenu clé RSA d'un trousseau de clés, le trousseau RSA brut utilise un *espace de noms de clé et un nom de clé* que vous fournissez.* Ces valeurs ne sont pas secrètes. Ils apparaissent en texte brut dans la [description matérielle](concepts.md#material-description) que le SDK AWS de chiffrement de base de données ajoute à l'enregistrement. Nous vous recommandons d'utiliser l'espace de noms de clé et le nom de clé qui identifient la paire de clés RSA (ou sa clé privée) dans votre HSM ou votre système de gestion des clés.
**Note**
L'espace de noms clé et le nom de clé sont équivalents aux champs *ID* du *fournisseur (ou fournisseur*) et *ID clé* du`JceMasterKey`.
Si vous créez différents trousseaux de clés pour chiffrer et déchiffrer un enregistrement donné, l'espace de noms et les valeurs des noms sont essentiels. Si l'espace de noms de clé et le nom de clé du jeu de clés de déchiffrement ne correspondent pas exactement, en distinguant majuscules et minuscules, à l'espace de noms de clé et au nom de clé du jeu de clés de chiffrement, le jeu de clés de déchiffrement n'est pas utilisé, même si les clés proviennent de la même paire de clés.
L'espace de noms de clé et le nom de clé du contenu clé des trousseaux de clés de chiffrement et de déchiffrement doivent être identiques, que le jeu de clés contienne la clé publique RSA, la clé privée RSA ou les deux clés de la paire de clés. Supposons, par exemple, que vous cryptiez des données à l'aide d'un jeu de clés RSA brut pour une clé publique RSA avec un espace de noms `HSM_01` de clé et un nom de clé. `RSA_2048_06` Pour déchiffrer ces données, créez un jeu de clés RSA brut avec la clé privée (ou paire de clés), ainsi que le même espace de noms et le même nom de clé.
**Mode de rembourrage**
Vous devez spécifier un mode de remplissage pour les porte-clés RSA bruts utilisés pour le chiffrement et le déchiffrement, ou utiliser les fonctionnalités de l'implémentation de votre langage qui le spécifient pour vous.
Il AWS Encryption SDK prend en charge les modes de remplissage suivants, sous réserve des contraintes de chaque langue. Nous recommandons un mode de rembourrage [OAEP](https://tools.ietf.org/html/rfc8017#section-7.1), en particulier OAEP avec SHA-256 et avec rembourrage SHA-256. MGF1 Le mode de [PKCS1](https://tools.ietf.org/html/rfc8017#section-7.2)rembourrage n'est pris en charge que pour des raisons de rétrocompatibilité.
+ OAEP avec SHA-1 et rembourrage SHA-1 MGF1
+ OAEP avec SHA-256 et avec rembourrage SHA-256 MGF1
+ OAEP avec SHA-384 et avec rembourrage SHA-384 MGF1
+ OAEP avec SHA-512 et avec rembourrage SHA-512 MGF1
+ PKCS1 Rembourrage v1.5
L'exemple Java suivant montre comment créer un jeu de clés RSA brut avec les clés publique et privée d'une paire de clés RSA et l'OAEP avec SHA-256 et avec le mode de remplissage SHA-256. MGF1 Les `RSAPrivateKey` variables `RSAPublicKey` et représentent le matériel clé que vous fournissez.
------
#### [ Java ]
```
final CreateRawRsaKeyringInput keyringInput = CreateRawRsaKeyringInput.builder()
.keyName("RSA_2048_06")
.keyNamespace("HSM_01")
.paddingScheme(PaddingScheme.OAEP_SHA256_MGF1)
.publicKey(RSAPublicKey)
.privateKey(RSAPrivateKey)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
IKeyring rawRsaKeyring = matProv.CreateRawRsaKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var keyNamespace = "HSM_01";
var keyName = "RSA_2048_06";
// Get public and private keys from PEM files
var publicKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePublicKey.pem"));
var privateKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePrivateKey.pem"));
// Create the keyring input
var keyringInput = new CreateRawRsaKeyringInput
{
KeyNamespace = keyNamespace,
KeyName = keyName,
PaddingScheme = PaddingScheme.OAEP_SHA512_MGF1,
PublicKey = publicKey,
PrivateKey = privateKey
};
// Create the keyring
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var rawRsaKeyring = matProv.CreateRawRsaKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_rsa_keyring = mpl
.create_raw_rsa_keyring()
.key_name("RSA_2048_06")
.key_namespace("HSM_01")
.padding_scheme(PaddingScheme::OaepSha256Mgf1)
.public_key(RSA_public_key)
.private_key(RSA_private_key)
.send()
.await?;
```
------
# Porte-clés ECDH bruts
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
**Important**
Le porte-clés Raw ECDH n'est disponible qu'avec la version 1.5.0 de la bibliothèque Material Providers.
Le porte-clés ECDH brut utilise les paires de clés publique-privée à courbe elliptique que vous fournissez pour dériver une clé d'encapsulation partagée entre deux parties. Tout d'abord, le trousseau de clés déduit un secret partagé à l'aide de la clé privée de l'expéditeur, de la clé publique du destinataire et de l'algorithme d'accord de clé Elliptic Curve Diffie-Hellman (ECDH). Le trousseau de clés utilise ensuite le secret partagé pour dériver la clé d'encapsulation partagée qui protège vos clés de chiffrement des données. La fonction de dérivation de clé utilisée par le SDK AWS de chiffrement de base de données (`KDF_CTR_HMAC_SHA384`) pour dériver la clé d'encapsulation partagée est conforme aux [recommandations du NIST](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf) pour la dérivation de clés.
La fonction de dérivation de clés renvoie 64 octets de matériel de saisie. Pour garantir que les deux parties utilisent le bon matériel de saisie, le SDK de chiffrement de AWS base de données utilise les 32 premiers octets comme clé d'engagement et les 32 derniers octets comme clé d'encapsulation partagée. Lors du déchiffrement, si le trousseau de clés ne peut pas reproduire la même clé d'engagement et la même clé d'encapsulation partagée que celles stockées dans le champ de description du matériel de l'enregistrement crypté, l'opération échoue. Par exemple, si vous chiffrez un enregistrement avec un trousseau de clés configuré avec la clé privée d'**Alice** et la clé publique **de Bob**, un trousseau de clés configuré avec la clé privée **de Bob** et la clé publique d'**Alice** reproduira la même clé d'engagement et la même clé d'encapsulation partagée et pourra déchiffrer l'enregistrement. Si la clé publique de Bob provient d'une AWS KMS key paire, Bob peut créer un jeu de [clés AWS KMS ECDH](use-kms-ecdh-keyring.md) pour déchiffrer l'enregistrement.
Le trousseau de clés ECDH brut chiffre les enregistrements avec une clé symétrique à l'aide de l'AES-GCM. La clé de données est ensuite cryptée par enveloppe avec la clé d'encapsulation partagée dérivée à l'aide d'AES-GCM. [Chaque porte-clés Raw ECDH ne peut avoir qu'une seule clé d'encapsulation partagée, mais vous pouvez inclure plusieurs porte-clés Raw ECDH, seuls ou avec d'autres porte-clés, dans un porte-clés multiple.](use-multi-keyring.md)
Vous êtes responsable de la génération, du stockage et de la protection de vos clés privées, de préférence dans un module de sécurité matériel (HSM) ou un système de gestion des clés. Les paires de clés de l'expéditeur et du destinataire doivent se trouver sur la même courbe elliptique. Le SDK AWS Database Encryption prend en charge les spécifications de courbe elliptique suivantes :
+ `ECC_NIST_P256`
+ `ECC_NIST_P384`
+ `ECC_NIST_P512`
## Création d'un porte-clés ECDH brut
Le trousseau de clés Raw ECDH prend en charge trois schémas d'accord clés :`RawPrivateKeyToStaticPublicKey`,, et`EphemeralPrivateKeyToStaticPublicKey`. `PublicKeyDiscovery` Le schéma d'accord de clé que vous sélectionnez détermine les opérations cryptographiques que vous pouvez effectuer et la manière dont les matériaux de clé sont assemblés.
**Topics**
+ [RawPrivateKeyToStaticPublicKey](#raw-ecdh-RawPrivateKeyToStaticPublicKey)
+ [EphemeralPrivateKeyToStaticPublicKey](#raw-ecdh-EphemeralPrivateKeyToStaticPublicKey)
+ [PublicKeyDiscovery](#raw-ecdh-PublicKeyDiscovery)
### RawPrivateKeyToStaticPublicKey
Utilisez le schéma d'accord des `RawPrivateKeyToStaticPublicKey` clés pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire dans le trousseau de clés. Ce schéma d'accord clé permet de chiffrer et de déchiffrer des enregistrements.
Pour initialiser un jeu de clés ECDH brut avec le schéma d'accord de `RawPrivateKeyToStaticPublicKey` clés, fournissez les valeurs suivantes :
+ **Clé privée de l'expéditeur**
[Vous devez fournir la clé privée codée PEM de l'expéditeur ( PrivateKeyInfo structures PKCS \$18), telle que définie dans la RFC 5958.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Clé publique du destinataire**
[Vous devez fournir la clé publique X.509 codée DER du destinataire, également connue sous le nom de `SubjectPublicKeyInfo` (SPKI), telle que définie dans la RFC 5280.](https://tools.ietf.org/html/rfc5280)
Vous pouvez spécifier la clé publique d'une paire de clés KMS à accord de clé asymétrique ou la clé publique à partir d'une paire de clés générée en dehors de AWS.
+ **Spécification de la courbe**
Identifie la spécification de la courbe elliptique dans les paires de clés spécifiées. Les paires de clés de l'expéditeur et du destinataire doivent avoir la même spécification de courbe.
Valeurs valides : `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var BobPrivateKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH static keyring
var staticConfiguration = new RawEcdhStaticConfigurations()
{
RawPrivateKeyToStaticPublicKey = new RawPrivateKeyToStaticPublicKeyInput
{
SenderStaticPrivateKey = BobPrivateKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'exemple Java suivant utilise le schéma d'accord de `RawPrivateKeyToStaticPublicKey` clé pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire. Les deux paires de clés sont sur la `ECC_NIST_P256` courbe.
```
private static void StaticRawKeyring() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
KeyPair senderKeys = GetRawEccKey();
KeyPair recipient = GetRawEccKey();
// Create the Raw ECDH static keyring
final CreateRawEcdhKeyringInput rawKeyringInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.RawPrivateKeyToStaticPublicKey(
RawPrivateKeyToStaticPublicKeyInput.builder()
// Must be a PEM-encoded private key
.senderStaticPrivateKey(ByteBuffer.wrap(senderKeys.getPrivate().getEncoded()))
// Must be a DER-encoded X.509 public key
.recipientPublicKey(ByteBuffer.wrap(recipient.getPublic().getEncoded()))
.build()
)
.build()
).build();
final IKeyring staticKeyring = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```
------
#### [ Rust ]
L'exemple Python suivant utilise le schéma d'accord de `raw_ecdh_static_configuration` clé pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire. Les deux paires de clés doivent se trouver sur la même courbe.
```
// Create keyring input
let raw_ecdh_static_configuration_input =
RawPrivateKeyToStaticPublicKeyInput::builder()
// Must be a UTF8 PEM-encoded private key
.sender_static_private_key(private_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let raw_ecdh_static_configuration = RawEcdhStaticConfigurations::RawPrivateKeyToStaticPublicKey(raw_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create raw ECDH static keyring
let raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(raw_ecdh_static_configuration)
.send()
.await?;
```
------
### EphemeralPrivateKeyToStaticPublicKey
Les porte-clés configurés avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clés créent une nouvelle paire de clés localement et dérivent une clé d'encapsulation partagée unique pour chaque appel de chiffrement.
Ce schéma d'accord clé ne peut chiffrer que des enregistrements. Pour déchiffrer les enregistrements chiffrés avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clé, vous devez utiliser un schéma d'accord de clé de découverte configuré avec la clé publique du même destinataire. Pour le déchiffrer, vous pouvez utiliser un jeu de clés ECDH brut avec l'algorithme d'accord de [`PublicKeyDiscovery`](#raw-ecdh-PublicKeyDiscovery)clés ou, si la clé publique du destinataire provient d'une paire de clés KMS à accord de clé asymétrique, vous pouvez utiliser un porte-clés AWS KMS ECDH avec le schéma d'accord de clés. [KmsPublicKeyDiscovery](use-kms-ecdh-keyring.md#kms-ecdh-discovery)
Pour initialiser un jeu de clés ECDH brut avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clés, fournissez les valeurs suivantes :
+ **Clé publique du destinataire**
[Vous devez fournir la clé publique X.509 codée DER du destinataire, également connue sous le nom de `SubjectPublicKeyInfo` (SPKI), telle que définie dans la RFC 5280.](https://tools.ietf.org/html/rfc5280)
Vous pouvez spécifier la clé publique d'une paire de clés KMS à accord de clé asymétrique ou la clé publique à partir d'une paire de clés générée en dehors de AWS.
+ **Spécification de la courbe**
Identifie la spécification de la courbe elliptique dans la clé publique spécifiée.
Lors du chiffrement, le trousseau de clés crée une nouvelle paire de clés sur la courbe spécifiée et utilise la nouvelle clé privée et la clé publique spécifiée pour dériver une clé d'encapsulation partagée.
Valeurs valides : `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clés. Lors du chiffrement, le trousseau de clés créera une nouvelle paire de clés localement sur la courbe spécifiée`ECC_NIST_P256`.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH ephemeral keyring
var ephemeralConfiguration = new RawEcdhStaticConfigurations()
{
EphemeralPrivateKeyToStaticPublicKey = new EphemeralPrivateKeyToStaticPublicKeyInput
{
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = ephemeralConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clés. Lors du chiffrement, le trousseau de clés créera une nouvelle paire de clés localement sur la courbe spécifiée`ECC_NIST_P256`.
```
private static void EphemeralRawEcdhKeyring() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
ByteBuffer recipientPublicKey = getPublicKeyBytes();
// Create the Raw ECDH ephemeral keyring
final CreateRawEcdhKeyringInput ephemeralInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.EphemeralPrivateKeyToStaticPublicKey(
EphemeralPrivateKeyToStaticPublicKeyInput.builder()
.recipientPublicKey(recipientPublicKey)
.build()
)
.build()
).build();
final IKeyring ephemeralKeyring = materialProviders.CreateRawEcdhKeyring(ephemeralInput);
}
```
------
#### [ Rust ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `ephemeral_raw_ecdh_static_configuration` clés. Lors du chiffrement, le trousseau de clés créera une nouvelle paire de clés localement sur la courbe spécifiée.
```
// Create EphemeralPrivateKeyToStaticPublicKeyInput
let ephemeral_raw_ecdh_static_configuration_input =
EphemeralPrivateKeyToStaticPublicKeyInput::builder()
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let ephemeral_raw_ecdh_static_configuration =
RawEcdhStaticConfigurations::EphemeralPrivateKeyToStaticPublicKey(ephemeral_raw_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create raw ECDH ephemeral private key keyring
let ephemeral_raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(ephemeral_raw_ecdh_static_configuration)
.send()
.await?;
```
------
### PublicKeyDiscovery
Lors du déchiffrement, il est recommandé de spécifier les clés d'encapsulation que le SDK de chiffrement de AWS base de données peut utiliser. Pour suivre cette bonne pratique, utilisez un trousseau de clés ECDH qui spécifie à la fois la clé privée de l'expéditeur et la clé publique du destinataire. Cependant, vous pouvez également créer un jeu de clés de découverte ECDH brut, c'est-à-dire un jeu de clés ECDH brut capable de déchiffrer tout enregistrement dont la clé publique spécifiée correspond à la clé publique du destinataire stockée dans le champ de description matérielle de l'enregistrement crypté. Ce schéma d'accord clé ne peut déchiffrer que les enregistrements.
**Important**
Lorsque vous déchiffrez des enregistrements à l'aide du schéma d'accord de `PublicKeyDiscovery` clés, vous acceptez toutes les clés publiques, quel que soit leur propriétaire.
Pour initialiser un jeu de clés ECDH brut avec le schéma d'accord de `PublicKeyDiscovery` clés, fournissez les valeurs suivantes :
+ **Clé privée statique du destinataire**
[Vous devez fournir la clé privée codée PEM du destinataire ( PrivateKeyInfo structures PKCS \$18), telle que définie dans la RFC 5958.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Spécification de la courbe**
Identifie la spécification de la courbe elliptique dans la clé privée spécifiée. Les paires de clés de l'expéditeur et du destinataire doivent avoir la même spécification de courbe.
Valeurs valides : `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `PublicKeyDiscovery` clés. Ce porte-clés peut déchiffrer tout enregistrement dont la clé publique de la clé privée spécifiée correspond à la clé publique du destinataire stockée dans le champ de description du matériel de l'enregistrement crypté.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var AlicePrivateKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH discovery keyring
var discoveryConfiguration = new RawEcdhStaticConfigurations()
{
PublicKeyDiscovery = new PublicKeyDiscoveryInput
{
RecipientStaticPrivateKey = AlicePrivateKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `PublicKeyDiscovery` clés. Ce porte-clés peut déchiffrer tout enregistrement dont la clé publique de la clé privée spécifiée correspond à la clé publique du destinataire stockée dans le champ de description du matériel de l'enregistrement crypté.
```
private static void RawEcdhDiscovery() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
KeyPair recipient = GetRawEccKey();
// Create the Raw ECDH discovery keyring
final CreateRawEcdhKeyringInput rawKeyringInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.PublicKeyDiscovery(
PublicKeyDiscoveryInput.builder()
// Must be a PEM-encoded private key
.recipientStaticPrivateKey(ByteBuffer.wrap(sender.getPrivate().getEncoded()))
.build()
)
.build()
).build();
final IKeyring publicKeyDiscovery = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```
------
#### [ Rust ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `discovery_raw_ecdh_static_configuration` clés. Ce porte-clés peut déchiffrer tout message dont la clé publique de la clé privée spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message.
```
// Create PublicKeyDiscoveryInput
let discovery_raw_ecdh_static_configuration_input =
PublicKeyDiscoveryInput::builder()
// Must be a UTF8 PEM-encoded private key
.recipient_static_private_key(private_key_recipient_utf8_bytes)
.build()?;
let discovery_raw_ecdh_static_configuration =
RawEcdhStaticConfigurations::PublicKeyDiscovery(discovery_raw_ecdh_static_configuration_input);
// Create raw ECDH discovery private key keyring
let discovery_raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(discovery_raw_ecdh_static_configuration)
.send()
.await?;
```
------
# Porte-clés multiples
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Vous pouvez combiner plusieurs porte-clés au sein d'un porte-clés multiple. Un *porte-clés multiple* est un porte-clés qui se compose d'un ou plusieurs porte-clés individuels différents ou partageant le même type. L'effet est semblable à l'utilisation de plusieurs porte-clés en série. Lorsque vous utilisez un porte-clés multiple pour chiffrer des données, toutes les clés d'encapsulage de tous ses porte-clés sont capables de déchiffrer les données.
Lorsque vous créez un porte-clés multiple pour chiffrer des données, vous désignez l'un des porte-clés en tant que *porte-clés générateur*. Tous les autres porte-clés sont appelés *porte-clés enfants*. Le porte-clés générateur génère et chiffre la clé de données en texte brut. Ensuite, toutes les clés d'encapsulage dans l'ensemble des porte-clés enfants chiffrent la même clé de données en texte brut. Le porte-clés multiple renvoie la clé en texte brut et une clé de données chiffrée pour chaque clé d'encapsulage du porte-clés multiple. Si le trousseau de clés du générateur est un [trousseau KMS](use-kms-keyring.md), la clé du générateur du AWS KMS trousseau génère et chiffre la clé en texte brut. Ensuite, toutes les clés supplémentaires AWS KMS keys du AWS KMS trousseau de clés et toutes les clés enveloppantes de tous les porte-clés enfants du trousseau de clés multiples chiffrent la même clé en texte brut.
Lors du déchiffrement, le SDK de chiffrement de AWS base de données utilise les trousseaux de clés pour tenter de déchiffrer l'une des clés de données chiffrées. Les porte-clés sont appelés dans l'ordre dans lequel ils sont spécifiées dans le porte-clés multiple. Le traitement s'arrête dès qu'une clé d'un porte-clés peut déchiffrer une clé de données chiffrée.
Pour créer un porte-clés multiple, vous devez d'abord instancier les porte-clés enfants. Dans cet exemple, nous utilisons un AWS KMS porte-clés et un porte-clés AES brut, mais vous pouvez combiner tous les porte-clés compatibles dans un porte-clés multiple.
------
#### [ Java ]
```
// 1. Create the raw AES keyring.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateRawAesKeyringInput createRawAesKeyringInput = CreateRawAesKeyringInput.builder()
.keyName("AES_256_012")
.keyNamespace("HSM_01")
.wrappingKey(AESWrappingKey)
.wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
.build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(createRawAesKeyringInput);
// 2. Create the AWS KMS keyring.
final CreateAwsKmsMrkMultiKeyringInput createAwsKmsMrkMultiKeyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyArn)
.build();
IKeyring awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// 1. Create the raw AES keyring.
var keyNamespace = "HSM_01";
var keyName = "AES_256_012";
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createRawAesKeyringInput = new CreateRawAesKeyringInput
{
KeyName = "keyName",
KeyNamespace = "myNamespaces",
WrappingKey = AESWrappingKey,
WrappingAlg = AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
};
var rawAesKeyring = matProv.CreateRawAesKeyring(createRawAesKeyringInput);
// 2. Create the AWS KMS keyring.
// We create a MRK multi keyring, as this interface also supports
// single-region KMS keys,
// and creates the KMS client for us automatically.
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = keyArn
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
// 1. Create the raw AES keyring
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name("AES_256_012")
.key_namespace("HSM_01")
.wrapping_key(aes_key_bytes)
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
// 2. Create the AWS KMS keyring
let aws_kms_mrk_multi_keyring = mpl
.create_aws_kms_mrk_multi_keyring()
.generator(key_arn)
.send()
.await?;
```
------
Ensuite, créez le porte-clés multiple et spécifiez son porte-clés générateur, le cas échéant. Dans cet exemple, nous créons un porte-clés multiple dans lequel le porte-clés est le AWS KMS porte-clés générateur et le porte-clés AES est le porte-clés enfant.
------
#### [ Java ]
Le `CreateMultiKeyringInput` constructeur Java vous permet de définir un porte-clés générateur et des trouses-clés enfants. L'`createMultiKeyringInput`objet obtenu est immuable.
```
final CreateMultiKeyringInput createMultiKeyringInput = CreateMultiKeyringInput.builder()
.generator(awsKmsMrkMultiKeyring)
.childKeyrings(Collections.singletonList(rawAesKeyring))
.build();
IKeyring multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
Le `CreateMultiKeyringInput` constructeur .NET vous permet de définir un porte-clés générateur et un trousseau de clés enfant. L'`CreateMultiKeyringInput`objet obtenu est immuable.
```
var createMultiKeyringInput = new CreateMultiKeyringInput
{
Generator = awsKmsMrkMultiKeyring,
ChildKeyrings = new List { rawAesKeyring }
};
var multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
```
------
#### [ Rust ]
```
let multi_keyring = mpl
.create_multi_keyring()
.generator(aws_kms_mrk_multi_keyring)
.child_keyrings(vec![raw_aes_keyring.clone()])
.send()
.await?;
```
------
À présent, vous pouvez utiliser le porte-clés multiple pour chiffrer et déchiffrer les données.