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.
# AWS SDK de chiffrement de base de données pour DynamoDB
****
| |
| --- |
| 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 pour DynamoDB est une bibliothèque logicielle qui vous permet d'inclure le chiffrement côté client dans votre conception Amazon DynamoDB.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) Le SDK AWS de chiffrement de base de données pour DynamoDB fournit un chiffrement au niveau des attributs et vous permet de spécifier les éléments à chiffrer et ceux à inclure dans les signatures afin de garantir l'authenticité de vos données. Le chiffrement de vos données sensibles en transit et au repos permet de garantir que vos données en texte brut ne sont pas accessibles à des tiers, y compris. AWS
**Note**
Le SDK AWS de chiffrement de base de données ne prend pas en charge partiQL.
Dans DynamoDB, [une table est un ensemble d'](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes)éléments. Chaque *élément* est une collection d'*attributs*. Chaque attribut a un nom et une valeur. Le SDK AWS de chiffrement de base de données pour DynamoDB chiffre les valeurs des attributs. Puis, il calcule une signature sur les attributs. Vous spécifiez les valeurs d'attribut à chiffrer et celles à inclure dans la signature lors des actions [cryptographiques](concepts.md#crypt-actions).
Les rubriques de ce chapitre fournissent une vue d'ensemble du SDK de chiffrement de AWS base de données pour DynamoDB, notamment les champs chiffrés, des conseils sur l'installation et la configuration du client, ainsi que des exemples Java pour vous aider à démarrer.
**Topics**
+ [Chiffrement côté client et côté serveur](client-server-side.md)
+ [Quels sont les champs chiffrés et signés ?](DDB-encrypted-and-signed.md)
+ [Chiffrement consultable dans DynamoDB](ddb-searchable-encryption.md)
+ [Mettre à jour votre modèle de données](ddb-update-data-model.md)
+ [AWS SDK de chiffrement de base de données pour DynamoDB, langages de programmation disponibles](ddb-programming-languages.md)
+ [Ancien client de chiffrement DynamoDB](legacy-dynamodb-encryption-client.md)
# Chiffrement côté client et côté serveur
****
| |
| --- |
| 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 de chiffrement de base de données pour DynamoDB *prend en charge le chiffrement côté client*, dans le cadre duquel vous cryptez les données de votre table avant de les envoyer à votre base de données. DynamoDB fournit toutefois une fonctionnalité de *chiffrement au repos côté serveur* qui chiffre de manière transparente votre table lorsqu'elle est conservée sur le disque et la déchiffre lorsque vous accédez à la table.
Les outils que vous choisissez dépendent de la sensibilité de vos données et des exigences de sécurité de votre application. Vous pouvez utiliser à la fois le SDK AWS de chiffrement de base de données pour DynamoDB et le chiffrement au repos. Lorsque vous envoyez des éléments chiffrés et signés à DynamoDB, DynamoDB ne les reconnaît pas comme étant protégés. Il détecte simplement les éléments de table classiques avec ses valeurs d'attribut binaires.
**Chiffrement côté serveur au repos**
DynamoDB [prend en charge le chiffrement au](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/EncryptionAtRest.html) repos, *une fonctionnalité de chiffrement côté serveur* dans laquelle DynamoDB chiffre de manière transparente vos tables pour vous lorsque celles-ci sont conservées sur le disque, et les déchiffre lorsque vous accédez aux données des tables.
Lorsque vous utilisez un AWS SDK pour interagir avec DynamoDB, par défaut, vos données sont chiffrées en transit via une connexion HTTPS, déchiffrées au point de terminaison DynamoDB, puis rechiffrées avant d'être stockées dans DynamoDB.
+ **Chiffrement par défaut.** DynamoDB chiffre et déchiffre de manière transparente toutes les tables lorsqu'elles sont écrites. Aucune option ne permet d'activer ou de désactiver le chiffrement au repos.
+ **DynamoDB crée et gère les clés cryptographiques.**La clé unique de chaque table est protégée par un code [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)qui ne laisse jamais [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) non chiffré. Par défaut, DynamoDB utilise une clé intégrée [Clé détenue par AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk)au service DynamoDB, mais vous pouvez choisir [Clé gérée par AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)une clé [ou une clé gérée par le client dans votre compte pour protéger certaines ou](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) toutes vos tables.
+ **Toutes les données de la table sont cryptées sur le disque.**[Lorsqu'une table chiffrée est enregistrée sur disque, DynamoDB chiffre toutes les données de la table, y compris [la clé primaire](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) et les index secondaires locaux et globaux.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.SecondaryIndexes) Si votre table a une clé de tri, certaines clés de tri qui marquent les limites de plage sont stockées en texte brut dans les métadonnées de la table.
+ **Les objets liés aux tables sont également chiffrés.** Le chiffrement au repos protège les flux [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html)[, les tables globales](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) [et](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) les sauvegardes chaque fois qu'ils sont écrits sur un support durable.
+ **Vos éléments sont déchiffrés lorsque vous y accédez.**Lorsque vous accédez à la table, DynamoDB déchiffre la partie de la table qui inclut votre élément cible et vous renvoie l'élément en texte brut.
**AWS SDK de chiffrement de base de données pour DynamoDB**
Le chiffrement côté client end-to-end protège vos données, en transit et au repos, depuis leur source jusqu'à leur stockage dans DynamoDB. Vos données en texte brut ne sont jamais exposées à des tiers, y compris AWS. Vous pouvez utiliser le SDK AWS de chiffrement de base de données pour DynamoDB avec les nouvelles tables DynamoDB, ou vous pouvez migrer vos tables Amazon DynamoDB existantes vers la dernière version du SDK de chiffrement de base de données pour DynamoDB. AWS
+ **Vos données sont protégées en transit et au repos.** Il n'est jamais exposé à des tiers, y compris AWS.
+ **Vous pouvez signer les éléments de vos tables.** Vous pouvez demander au SDK AWS de chiffrement de base de données pour DynamoDB de calculer une signature sur tout ou partie d'un élément de table, y compris les attributs de clé primaire. Cette signature vous permet de détecter les modifications non autorisées sur l'élément comme un tout, y compris l'ajout ou la suppression d'attributs, ou le remplacement d'une valeur d'attribut par une autre.
+ **Vous déterminez comment vos données sont protégées** [en sélectionnant un trousseau de clés.](keyrings.md) 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.
+ **Le SDK AWS de chiffrement de base de données pour DynamoDB ne chiffre pas l'intégralité de la table.** Vous choisissez les attributs qui sont chiffrés dans vos articles. Le SDK AWS de chiffrement de base de données pour DynamoDB ne chiffre pas un élément entier. Il ne chiffre pas les noms d'attribut, ou les noms ou valeurs des attributs de clé primaire (clé de partition et clé de tri).
**AWS Encryption SDK**
Si vous chiffrez des données que vous stockez dans DynamoDB, nous vous recommandons AWS le SDK de chiffrement de base de données pour DynamoDB.
Le kit [AWS Encryption SDK](https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/) est une bibliothèque de chiffrement côté serveur qui vous aide à chiffrer et déchiffrer les données génériques. Même s'il peut protéger tout type de données, il n'est pas conçu pour fonctionner avec des données structurées, comme les enregistrements de base de données. Contrairement au SDK AWS de chiffrement de base de données pour DynamoDB, AWS Encryption SDK il ne peut pas fournir de contrôle d'intégrité au niveau des éléments et il n'a aucune logique permettant de reconnaître les attributs ou d'empêcher le chiffrement des clés primaires.
Si vous utilisez le AWS Encryption SDK pour chiffrer un élément de votre table, n'oubliez pas qu'il n'est pas compatible avec le SDK de chiffrement de AWS base de données pour DynamoDB. Vous ne pouvez pas chiffrer avec une bibliothèque et déchiffrer avec l'autre.
# Quels sont les champs chiffrés et signé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 pour DynamoDB est une bibliothèque de chiffrement côté client spécialement conçue pour les applications Amazon DynamoDB. Amazon DynamoDB stocke les données [dans](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes) des tables, qui sont un ensemble d'éléments. Chaque *élément* est une collection d'*attributs*. Chaque attribut a un nom et une valeur. Le SDK AWS de chiffrement de base de données pour DynamoDB chiffre les valeurs des attributs. Puis, il calcule une signature sur les attributs. Vous pouvez spécifier les valeurs d'attribut à chiffrer et celles à inclure dans la signature.
Le chiffrement protège la confidentialité de la valeur d'attribut. La signature assure l'intégrité de tous les attributs signés et de leurs relations entre eux, et fournit l'authentification. Elle vous permet de détecter les modifications non autorisées sur l'élément comme un tout, y compris l'ajout ou la suppression d'attributs, ou le remplacement d'une valeur chiffrée par une autre.
Dans un élément chiffré, certaines données restent en texte brut, notamment le nom de la table, tous les noms d'attributs, les valeurs d'attribut que vous ne chiffrez pas, les noms et valeurs des attributs de la clé primaire (clé de partition et clé de tri) et les types d'attributs. Ne stockez pas les données sensibles dans ces champs.
Pour plus d'informations sur le fonctionnement du SDK AWS de chiffrement de base de données pour DynamoDB, consultez. [Fonctionnement du SDK AWS de chiffrement de base de données](how-it-works.md)
**Note**
[Toutes les mentions d'*actions d'attributs dans les* rubriques du SDK AWS de chiffrement de base de données pour DynamoDB font référence aux actions cryptographiques.](concepts.md#crypt-actions)
**Topics**
+ [Chiffrement des valeurs d'attribut](#encrypt-attribute-values)
+ [Signature de l'élément](#sign-the-item)
## Chiffrement des valeurs d'attribut
Le SDK AWS de chiffrement de base de données pour DynamoDB chiffre les valeurs (mais pas le nom ou le type d'attribut) des attributs que vous spécifiez. Pour déterminer quelles sont les valeurs d'attribut chiffrées, utilisez les [actions d'attribut](concepts.md#crypt-actions).
Par exemple, cet élément inclut les attributs `example` et `test`.
```
'example': 'data',
'test': 'test-value',
...
```
Si vous chiffrez l'attribut `example`, mais pas l'attribut `test`, les résultats se présentent comme suit. La valeur d'attribut `example` chiffrée est une donnée binaire, et non une chaîne.
```
'example': Binary(b"'b\x933\x9a+s\xf1\xd6a\xc5\xd5\x1aZ\xed\xd6\xce\xe9X\xf0T\xcb\x9fY\x9f\xf3\xc9C\x83\r\xbb\\"),
'test': 'test-value'
...
```
Les attributs de clé primaire (clé de partition et clé de tri) de chaque élément doivent rester en texte brut car DynamoDB les utilise pour rechercher l'élément dans le tableau. Ils doivent être signés, mais pas chiffrés.
Le SDK AWS de chiffrement de base de données pour DynamoDB identifie les attributs de clé primaire pour vous et garantit que leurs valeurs sont signées, mais pas chiffrées. Et, si vous identifiez votre clé primaire, puis essayez de la chiffrer, le client lève une exception.
Le client enregistre la [description du matériau](concepts.md#material-description) dans un nouvel attribut (`aws_dbe_head`) qu'il ajoute à l'article. La description du matériel décrit comment l'article a été crypté et signé. Le client utilise ces informations pour vérifier et déchiffrer l'élément. Le champ qui contient la description du matériau n'est pas crypté.
## Signature de l'élément
[Après avoir chiffré les valeurs d'attribut spécifiées, le SDK de chiffrement de AWS base de données pour DynamoDB calcule les codes d'authentification des messages basés sur le hachage (HMACs) et une [signature numérique](concepts.md#digital-sigs) lors de la canonisation de la description du matériel, du [contexte de chiffrement et de chaque champ marqué, ou dans](concepts.md#encryption-context) les actions d'attribut. `ENCRYPT_AND_SIGN``SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](concepts.md#crypt-actions) Les signatures ECDSA sont activées par défaut, mais ne sont pas obligatoires. Le client enregistre les signatures HMACs et dans un nouvel attribut (`aws_dbe_foot`) qu'il ajoute à l'élément.
# Chiffrement consultable dans DynamoDB
Pour configurer vos tables Amazon DynamoDB pour le chiffrement consultable, vous devez utiliser [AWS KMS le trousseau de clés hiérarchique](use-hierarchical-keyring.md) pour générer, chiffrer et déchiffrer les clés de données utilisées pour protéger vos articles. Vous devez également inclure le [`SearchConfig`](ddb-net-using.md#ddb-net-search-config)dans la configuration de chiffrement de votre table.
**Note**
Si vous utilisez la bibliothèque de chiffrement côté client Java pour DynamoDB, vous devez utiliser le SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB pour chiffrer, signer, vérifier et déchiffrer les éléments de votre table. Le client DynamoDB amélioré et les `DynamoDBItemEncryptor` niveaux inférieurs ne prennent pas en charge le chiffrement consultable.
**Topics**
+ [Configuration des index secondaires avec des balises](#ddb-beacon-indexes)
+ [Tester les sorties des balises](#ddb-beacon-testing)
## Configuration des index secondaires avec des balises
Après avoir [configuré vos balises](configure-beacons.md), vous devez configurer un index secondaire qui reflète chaque balise avant de pouvoir effectuer une recherche sur les attributs chiffrés.
Lorsque vous configurez une balise standard ou composée, le SDK AWS Database Encryption ajoute le `aws_dbe_b_` préfixe au nom de la balise afin que le serveur puisse facilement identifier les balises. Par exemple, si vous nommez une balise composée`compoundBeacon`, le nom complet de la balise est en fait`aws_dbe_b_compoundBeacon`. Si vous souhaitez configurer [des index secondaires](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) qui incluent une balise standard ou composée, vous devez inclure le `aws_dbe_b_` préfixe lorsque vous identifiez le nom de la balise.
**Clés de partition et de tri**
Vous ne pouvez pas chiffrer les valeurs des clés primaires. Vos clés de partition et de tri doivent être signées. Les valeurs de votre clé primaire ne peuvent pas être une balise standard ou composée.
Les valeurs de votre clé primaire doivent être`SIGN_ONLY`, sauf si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Les valeurs de vos clés primaires peuvent être des balises signées. Si vous avez configuré des balises signées distinctes pour chacune de vos valeurs de clé primaire, vous devez spécifier le nom d'attribut qui identifie la valeur de clé primaire comme le nom de balise signé. Toutefois, le SDK AWS de chiffrement de base de données n'ajoute pas le `aws_dbe_b_` préfixe aux balises signées. Même si vous avez configuré des balises signées distinctes pour les valeurs de votre clé primaire, il vous suffit de spécifier les noms d'attribut pour les valeurs de clé primaire lorsque vous configurez un index secondaire.
**Index locaux secondaires**
La clé de tri d'un [index secondaire local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSI.html) peut être une balise.
Si vous spécifiez une balise pour la clé de tri, le type doit être String. Si vous spécifiez une balise standard ou composée pour la clé de tri, vous devez inclure le `aws_dbe_b_` préfixe lorsque vous spécifiez le nom de la balise. Si vous spécifiez une balise signée, spécifiez le nom de la balise sans aucun préfixe.
**Index secondaires globaux**
Les clés de partition et de tri d'un [index secondaire global](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) peuvent toutes deux être des balises.
Si vous spécifiez une balise pour la partition ou la clé de tri, le type doit être String. Si vous spécifiez une balise standard ou composée pour la clé de tri, vous devez inclure le `aws_dbe_b_` préfixe lorsque vous spécifiez le nom de la balise. Si vous spécifiez une balise signée, spécifiez le nom de la balise sans aucun préfixe.
**Projections d’attribut**
Une [projection](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html#GSI.Projections) est l’ensemble d’attributs copié à partir d’une table dans un index secondaire. Les clés de partition et de tri de la table sont toujours projetées dans l’index. Vous pouvez projeter d’autres attributs en fonction des exigences de requête de votre application. DynamoDB propose trois options différentes pour les projections d'attributs `KEYS_ONLY` :`INCLUDE`, et. `ALL`
Si vous utilisez la projection d'attributs INCLUDE pour effectuer une recherche sur une balise, vous devez spécifier le nom de tous les attributs à partir desquels la balise est construite, ainsi que le nom de la balise avec le `aws_dbe_b_` préfixe. Par exemple, si vous avez configuré une balise composée `compoundBeacon``field1`, à partir de `field2``field3`, et, vous devez spécifier `aws_dbe_b_compoundBeacon``field1`,`field2`, et `field3` dans la projection.
Un index secondaire global ne peut utiliser que les attributs explicitement spécifiés dans la projection, mais un index secondaire local peut utiliser n'importe quel attribut.
## Tester les sorties des balises
Si vous avez [configuré des balises composées](configure-beacons.md#config-compound-beacons) ou créé vos balises à l'aide de [champs virtuels](configure-beacons.md#create-virtual-field), nous vous recommandons de vérifier que ces balises produisent le résultat attendu avant de remplir votre table DynamoDB.
Le SDK AWS Database Encryption fournit le `DynamoDbEncryptionTransforms` service qui vous aide à résoudre les problèmes liés aux champs virtuels et aux sorties de balises composées.
### Tester des champs virtuels
L'extrait suivant crée des éléments de test, définit le `DynamoDbEncryptionTransforms` service avec la [configuration de chiffrement des tables DynamoDB](ddb-java-using.md#ddb-config-encrypt) et montre comment vérifier que le champ virtuel produit le résultat attendu. `ResolveAttributes`
------
#### [ Java ]
**Voir l'exemple de code complet** : [VirtualBeaconSearchableEncryptionExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption/VirtualBeaconSearchableEncryptionExample.java)
```
// Create test items
final PutItemRequest itemWithHasTestResultPutRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(itemWithHasTestResult)
.build();
final PutItemResponse itemWithHasTestResultPutResponse = ddb.putItem(itemWithHasTestResultPutRequest);
final PutItemRequest itemWithNoHasTestResultPutRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(itemWithNoHasTestResult)
.build();
final PutItemResponse itemWithNoHasTestResultPutResponse = ddb.putItem(itemWithNoHasTestResultPutRequest);
// Define the DynamoDbEncryptionTransforms service
final DynamoDbEncryptionTransforms trans = DynamoDbEncryptionTransforms.builder()
.DynamoDbTablesEncryptionConfig(encryptionConfig).build();
// Verify configuration
final ResolveAttributesInput resolveInput = ResolveAttributesInput.builder()
.TableName(ddbTableName)
.Item(itemWithHasTestResult)
.Version(1)
.build();
final ResolveAttributesOutput resolveOutput = trans.ResolveAttributes(resolveInput);
// Verify that VirtualFields has the expected value
Map vf = new HashMap<>();
vf.put("stateAndHasTestResult", "CAt");
assert resolveOutput.VirtualFields().equals(vf);
```
------
#### [ C\$1 / .NET ]
**Consultez l'exemple de code complet** : [VirtualBeaconSearchableEncryptionExample.cs.](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/VirtualBeaconSearchableEncryptionExample.cs)
```
// Create item with hasTestResult=true
var itemWithHasTestResult = new Dictionary
{
["customer_id"] = new AttributeValue("ABC-123"),
["create_time"] = new AttributeValue { N = "1681495205" },
["state"] = new AttributeValue("CA"),
["hasTestResult"] = new AttributeValue { BOOL = true }
};
// Create item with hasTestResult=false
var itemWithNoHasTestResult = new Dictionary
{
["customer_id"] = new AttributeValue("DEF-456"),
["create_time"] = new AttributeValue { N = "1681495205" },
["state"] = new AttributeValue("CA"),
["hasTestResult"] = new AttributeValue { BOOL = false }
};
// Define the DynamoDbEncryptionTransforms service
var trans = new DynamoDbEncryptionTransforms(encryptionConfig);
// Verify configuration
var resolveInput = new ResolveAttributesInput
{
TableName = ddbTableName,
Item = itemWithHasTestResult,
Version = 1
};
var resolveOutput = trans.ResolveAttributes(resolveInput);
// Verify that VirtualFields has the expected value
Debug.Assert(resolveOutput.VirtualFields.Count == 1);
Debug.Assert(resolveOutput.VirtualFields["stateAndHasTestResult"] == "CAt");
```
------
#### [ Rust ]
**Consultez l'exemple de code complet** : [virtual\$1beacon\$1searchable\$1encryption.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/virtual_beacon_searchable_encryption.rs).
```
// Create item with hasTestResult=true
let item_with_has_test_result = HashMap::from([
(
"customer_id".to_string(),
AttributeValue::S("ABC-123".to_string()),
),
(
"create_time".to_string(),
AttributeValue::N("1681495205".to_string()),
),
("state".to_string(), AttributeValue::S("CA".to_string())),
("hasTestResult".to_string(), AttributeValue::Bool(true)),
]);
// Create item with hasTestResult=false
let item_with_no_has_test_result = HashMap::from([
(
"customer_id".to_string(),
AttributeValue::S("DEF-456".to_string()),
),
(
"create_time".to_string(),
AttributeValue::N("1681495205".to_string()),
),
("state".to_string(), AttributeValue::S("CA".to_string())),
("hasTestResult".to_string(), AttributeValue::Bool(false)),
]);
// Define the transform service
let trans = transform_client::Client::from_conf(encryption_config.clone())?;
// Verify the configuration
let resolve_output = trans
.resolve_attributes()
.table_name(ddb_table_name)
.item(item_with_has_test_result.clone())
.version(1)
.send()
.await?;
// Verify that VirtualFields has the expected value
let virtual_fields = resolve_output.virtual_fields.unwrap();
assert_eq!(virtual_fields.len(), 1);
assert_eq!(virtual_fields["stateAndHasTestResult"], "CAt");
```
------
### Tester des balises composées
L'extrait suivant crée un élément de test, définit le `DynamoDbEncryptionTransforms` service avec la [configuration de chiffrement des tables DynamoDB](ddb-java-using.md#ddb-config-encrypt) et montre comment vérifier que la balise composée produit le résultat attendu. `ResolveAttributes`
------
#### [ Java ]
**Voir l'exemple de code complet** : [CompoundBeaconSearchableEncryptionExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption/CompoundBeaconSearchableEncryptionExample.java)
```
// Create an item with both attributes used in the compound beacon.
final HashMap item = new HashMap<>();
item.put("work_id", AttributeValue.builder().s("9ce39272-8068-4efd-a211-cd162ad65d4c").build());
item.put("inspection_date", AttributeValue.builder().s("2023-06-13").build());
item.put("inspector_id_last4", AttributeValue.builder().s("5678").build());
item.put("unit", AttributeValue.builder().s("011899988199").build());
// Define the DynamoDbEncryptionTransforms service
final DynamoDbEncryptionTransforms trans = DynamoDbEncryptionTransforms.builder()
.DynamoDbTablesEncryptionConfig(encryptionConfig).build();
// Verify configuration
final ResolveAttributesInput resolveInput = ResolveAttributesInput.builder()
.TableName(ddbTableName)
.Item(item)
.Version(1)
.build();
final ResolveAttributesOutput resolveOutput = trans.ResolveAttributes(resolveInput);
// Verify that CompoundBeacons has the expected value
Map cbs = new HashMap<>();
cbs.put("last4UnitCompound", "L-5678.U-011899988199");
assert resolveOutput.CompoundBeacons().equals(cbs);
// Note : the compound beacon actually stored in the table is not "L-5678.U-011899988199"
// but rather something like "L-abc.U-123", as both parts are EncryptedParts
// and therefore the text is replaced by the associated beacon
```
------
#### [ C\$1 / .NET ]
**Voir l'exemple de code complet** : [CompoundBeaconSearchableEncryptionExample.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/CompoundBeaconSearchableEncryptionExample.cs)
```
// Create an item with both attributes used in the compound beacon
var item = new Dictionary
{
["work_id"] = new AttributeValue("9ce39272-8068-4efd-a211-cd162ad65d4c"),
["inspection_date"] = new AttributeValue("2023-06-13"),
["inspector_id_last4"] = new AttributeValue("5678"),
["unit"] = new AttributeValue("011899988199")
};
// Define the DynamoDbEncryptionTransforms service
var trans = new DynamoDbEncryptionTransforms(encryptionConfig);
// Verify configuration
var resolveInput = new ResolveAttributesInput
{
TableName = ddbTableName,
Item = item,
Version = 1
};
var resolveOutput = trans.ResolveAttributes(resolveInput);
// Verify that CompoundBeacons has the expected value
Debug.Assert(resolveOutput.CompoundBeacons.Count == 1);
Debug.Assert(resolveOutput.CompoundBeacons["last4UnitCompound"] == "L-5678.U-011899988199");
// Note : the compound beacon actually stored in the table is not "L-5678.U-011899988199"
// but rather something like "L-abc.U-123", as both parts are EncryptedParts
// and therefore the text is replaced by the associated beacon
```
------
#### [ Rust ]
**Voir l'exemple de code complet** : [compound\$1beacon\$1searchable\$1encryption.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/compound_beacon_searchable_encryption.rs)
```
// Create an item with both attributes used in the compound beacon
let item = HashMap::from([
(
"work_id".to_string(),
AttributeValue::S("9ce39272-8068-4efd-a211-cd162ad65d4c".to_string()),
),
(
"inspection_date".to_string(),
AttributeValue::S("2023-06-13".to_string()),
),
(
"inspector_id_last4".to_string(),
AttributeValue::S("5678".to_string()),
),
(
"unit".to_string(),
AttributeValue::S("011899988199".to_string()),
),
]);
// Define the transforms service
let trans = transform_client::Client::from_conf(encryption_config.clone())?;
// Verify configuration
let resolve_output = trans
.resolve_attributes()
.table_name(ddb_table_name)
.item(item.clone())
.version(1)
.send()
.await?;
// Verify that CompoundBeacons has the expected value
let compound_beacons = resolve_output.compound_beacons.unwrap();
assert_eq!(compound_beacons.len(), 1);
assert_eq!(
compound_beacons["last4UnitCompound"],
"L-5678.U-011899988199"
);
// but rather something like "L-abc.U-123", as both parts are EncryptedParts
// and therefore the text is replaced by the associated beacon
```
------
# Mettre à jour votre modèle de données
****
| |
| --- |
| 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 configurez le SDK AWS de chiffrement de base de données pour DynamoDB, vous fournissez des actions attributaires.](concepts.md#crypt-actions) Lors du chiffrement, le SDK AWS de chiffrement de base de données utilise les actions d'attributs pour identifier les attributs à chiffrer et à signer, les attributs à signer (mais pas à chiffrer) et ceux à ignorer. Vous définissez également les [attributs non signés autorisés](ddb-java-using.md#allowed-unauth) pour indiquer explicitement au client quels attributs sont exclus des signatures. Lors du déchiffrement, le SDK AWS de chiffrement de base de données utilise les attributs non signés autorisés que vous avez définis pour identifier les attributs qui ne sont pas inclus dans les signatures. Les actions d'attribut ne sont pas enregistrées dans l'élément chiffré et le SDK AWS de chiffrement de base de données ne met pas automatiquement à jour vos actions d'attribut.
Choisissez soigneusement vos actions d'attribut. En cas de doute, utilisez **Chiffrer et signer**. Une fois que vous avez utilisé le SDK AWS de chiffrement de base de données pour protéger vos éléments, vous ne pouvez pas modifier un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut ou un attribut existant `ENCRYPT_AND_SIGN` en`DO_NOTHING`. `SIGN_ONLY` Cependant, vous pouvez effectuer les modifications suivantes en toute sécurité.
+ [Ajouter `ENCRYPT_AND_SIGN` de `SIGN_ONLY` nouveaux `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs et](#ddb-add-auth-attribute)
+ [Supprimer les attributs existants](#ddb-remove-attribute)
+ [Remplacer un `ENCRYPT_AND_SIGN` attribut existant par `SIGN_ONLY` ou `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](#ddb-encrypt-to-sign)
+ [Modifier un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut `SIGN_ONLY` ou un existant en `ENCRYPT_AND_SIGN`](#ddb-sign-to-encrypt)
+ [Ajouter un nouvel `DO_NOTHING` attribut](#ddb-add-unauth-attribute)
+ [Modifier un `SIGN_ONLY` attribut existant en `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](#ddb-signOnly-to-signInclude)
+ [Modifier un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut existant en `SIGN_ONLY`](#ddb-signInclude-to-signOnly)
**Considérations relatives au chiffrement consultable**
Avant de mettre à jour votre modèle de données, réfléchissez bien à l'impact que vos mises à jour peuvent avoir sur les [balises](beacons.md) que vous avez créées à partir des attributs. Une fois que vous avez écrit de nouveaux enregistrements avec une balise, vous ne pouvez pas mettre à jour la configuration de la balise. Vous ne pouvez pas mettre à jour les actions d'attribut associées aux attributs que vous avez utilisés pour créer des balises. Si vous supprimez un attribut existant et sa balise associée, vous ne pourrez pas interroger les enregistrements existants à l'aide de cette balise. Vous pouvez créer de nouvelles balises pour les nouveaux champs que vous ajoutez à votre enregistrement, mais vous ne pouvez pas mettre à jour les balises existantes pour inclure le nouveau champ.
**Considérations relatives aux `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs**
Par défaut, les clés de partition et de tri sont les seuls attributs inclus dans le contexte de chiffrement. Vous pouvez envisager de définir des champs supplémentaires `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` afin que le fournisseur d'ID de clé de branche pour votre jeu de [clés AWS KMS hiérarchique](use-hierarchical-keyring.md) puisse identifier la clé de branche requise pour le déchiffrement à partir du contexte de chiffrement. Pour plus d'informations, consultez le [fournisseur d'ID de clé de branche](use-hierarchical-keyring.md#branch-key-id-supplier). Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Note**
Pour utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique, vous devez utiliser la version 3.3 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de [mettre à jour votre modèle de données](#ddb-update-data-model) pour l'inclure`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
## Ajouter `ENCRYPT_AND_SIGN` de `SIGN_ONLY` nouveaux `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs et
Pour ajouter un nouvel attribut `ENCRYPT_AND_SIGN``SIGN_ONLY`, ou un nouvel `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut, définissez-le dans vos actions d'attribut.
Vous ne pouvez pas supprimer un `DO_NOTHING` attribut existant et le réajouter en tant qu'`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`attribut `ENCRYPT_AND_SIGN``SIGN_ONLY`, ou.
**Utilisation d'une classe de données annotée**
Si vous avez défini vos actions d'attribut avec un`TableSchema`, ajoutez le nouvel attribut à votre classe de données annotée. Si vous ne spécifiez aucune annotation d'action d'attribut pour le nouvel attribut, le client chiffrera et signera le nouvel attribut par défaut (sauf si l'attribut fait partie de la clé primaire). Si vous souhaitez uniquement signer le nouvel attribut, vous devez l'ajouter avec l'`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`annotation `@DynamoDBEncryptionSignOnly` or.
**Utilisation d'un modèle d'objet**
Si vous avez défini manuellement vos actions d'attribut, ajoutez le nouvel attribut aux actions d'attribut de votre modèle d'objet et spécifiez `ENCRYPT_AND_SIGN``SIGN_ONLY`, ou `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` en tant qu'action d'attribut.
## Supprimer les attributs existants
Si vous décidez que vous n'avez plus besoin d'un attribut, vous pouvez arrêter d'écrire des données dans cet attribut ou vous pouvez le supprimer officiellement de vos actions d'attribut. Lorsque vous arrêtez d'écrire de nouvelles données dans un attribut, celui-ci apparaît toujours dans vos actions d'attribut. Cela peut être utile si vous devez recommencer à utiliser l'attribut à l'avenir. La suppression officielle de l'attribut de vos actions d'attribut ne le supprime pas de votre ensemble de données. Votre jeu de données contiendra toujours des éléments qui incluent cet attribut.
Pour supprimer officiellement un attribut existant`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, ou un `DO_NOTHING` attribut, mettez à jour vos actions d'attribut.
Si vous supprimez un `DO_NOTHING` attribut, vous ne devez pas le supprimer de vos [attributs non signés autorisés](ddb-java-using.md#allowed-unauth). Même si vous n'écrivez plus de nouvelles valeurs dans cet attribut, le client doit tout de même savoir que l'attribut n'est pas signé pour pouvoir lire les éléments existants qui le contiennent.
**Utilisation d'une classe de données annotée**
Si vous avez défini vos actions d'attribut avec un`TableSchema`, supprimez l'attribut de votre classe de données annotée.
**Utilisation d'un modèle d'objet**
Si vous avez défini manuellement vos actions d'attribut, supprimez l'attribut des actions d'attribut de votre modèle d'objet.
## Remplacer un `ENCRYPT_AND_SIGN` attribut existant par `SIGN_ONLY` ou `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Pour remplacer un `ENCRYPT_AND_SIGN` attribut existant par `SIGN_ONLY` ou`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, vous devez mettre à jour vos actions d'attribut. Une fois la mise à jour déployée, le client sera en mesure de vérifier et de déchiffrer les valeurs existantes écrites dans l'attribut, mais il ne signera que les nouvelles valeurs écrites dans l'attribut.
**Note**
Réfléchissez bien à vos exigences de sécurité avant de remplacer un `ENCRYPT_AND_SIGN` attribut existant par `SIGN_ONLY` ou`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Tout attribut susceptible de stocker des données sensibles doit être chiffré.
**Utilisation d'une classe de données annotée**
Si vous avez défini vos actions d'attribut avec un`TableSchema`, mettez à jour l'attribut existant pour inclure l'`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`annotation `@DynamoDBEncryptionSignOnly` ou dans votre classe de données annotée.
**Utilisation d'un modèle d'objet**
Si vous avez défini manuellement vos actions d'attribut, mettez à jour l'action d'attribut associée à l'attribut existant depuis `SIGN_ONLY` ou `ENCRYPT_AND_SIGN` `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` vers votre modèle d'objet.
## Modifier un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut `SIGN_ONLY` ou un existant en `ENCRYPT_AND_SIGN`
Pour remplacer un attribut existant `SIGN_ONLY` ou par un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut`ENCRYPT_AND_SIGN`, vous devez mettre à jour vos actions d'attribut. Une fois la mise à jour déployée, le client sera en mesure de vérifier les valeurs existantes écrites dans l'attribut, puis de chiffrer et de signer les nouvelles valeurs écrites dans l'attribut.
**Utilisation d'une classe de données annotée**
Si vous avez défini vos actions d'attribut avec un`TableSchema`, supprimez l'`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`annotation `@DynamoDBEncryptionSignOnly` ou de l'attribut existant.
**Utilisation d'un modèle d'objet**
Si vous avez défini manuellement vos actions d'attribut, mettez à jour l'action d'attribut associée à l'attribut depuis `SIGN_ONLY` ou `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` vers `ENCRYPT_AND_SIGN` dans votre modèle d'objet.
## Ajouter un nouvel `DO_NOTHING` attribut
Pour réduire le risque d'erreur lors de l'ajout d'un nouvel `DO_NOTHING` attribut, nous vous recommandons de spécifier un préfixe distinct lorsque vous nommez vos `DO_NOTHING` attributs, puis d'utiliser ce préfixe pour définir les attributs [non signés autorisés](ddb-java-using.md#allowed-unauth).
Vous ne pouvez pas supprimer un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut ou un attribut existant `ENCRYPT_AND_SIGN` de votre classe de données annotée, puis le réintégrer en tant qu'`DO_NOTHING`attribut. `SIGN_ONLY` Vous ne pouvez ajouter que des `DO_NOTHING` attributs entièrement nouveaux.
Les étapes à suivre pour ajouter un nouvel `DO_NOTHING` attribut varient selon que vous avez défini vos attributs non signés autorisés de manière explicite dans une liste ou à l'aide d'un préfixe.
**Utilisation d'un préfixe d'attributs non signés autorisé**
Si vous avez défini vos actions d'attribut avec un`TableSchema`, ajoutez le nouvel `DO_NOTHING` attribut à votre classe de données annotée avec l'`@DynamoDBEncryptionDoNothing`annotation. Si vous avez défini manuellement vos actions d'attribut, mettez-les à jour pour inclure le nouvel attribut. Assurez-vous de configurer explicitement le nouvel attribut avec l'action d'`DO_NOTHING`attribut. Vous devez inclure le même préfixe distinct dans le nom du nouvel attribut.
**Utilisation d'une liste d'attributs non signés autorisés**
1. Ajoutez le nouvel `DO_NOTHING` attribut à votre liste d'attributs non signés autorisés et déployez la liste mise à jour.
1. Déployez la modification depuis **l'étape 1**.
Vous ne pouvez pas passer à l'**étape 3** tant que la modification ne s'est pas propagée à tous les hôtes qui ont besoin de lire ces données.
1. Ajoutez le nouvel `DO_NOTHING` attribut à vos actions d'attribut.
1. Si vous avez défini vos actions d'attribut avec un`TableSchema`, ajoutez le nouvel `DO_NOTHING` attribut à votre classe de données annotée avec l'`@DynamoDBEncryptionDoNothing`annotation.
1. Si vous avez défini manuellement vos actions d'attribut, mettez-les à jour pour inclure le nouvel attribut. Assurez-vous de configurer explicitement le nouvel attribut avec l'action d'`DO_NOTHING`attribut.
1. Déployez la modification depuis **l'étape 3**.
## Modifier un `SIGN_ONLY` attribut existant en `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Pour remplacer un `SIGN_ONLY` attribut existant par`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, vous devez mettre à jour vos actions d'attribut. Une fois la mise à jour déployée, le client sera en mesure de vérifier les valeurs existantes écrites dans l'attribut et continuera à signer les nouvelles valeurs écrites dans l'attribut. Les nouvelles valeurs écrites dans l'attribut seront incluses dans le [contexte de chiffrement](concepts.md#encryption-context).
Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Utilisation d'une classe de données annotée**
Si vous avez défini vos actions d'attribut avec un`TableSchema`, mettez à jour l'action d'attribut associée à l'attribut de `@DynamoDBEncryptionSignOnly` à`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`.
**Utilisation d'un modèle d'objet**
Si vous avez défini manuellement vos actions d'attribut, mettez à jour l'action d'attribut associée à l'attribut de `SIGN_ONLY` à `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` dans votre modèle d'objet.
## Modifier un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut existant en `SIGN_ONLY`
Pour remplacer un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut existant par`SIGN_ONLY`, vous devez mettre à jour vos actions d'attribut. Une fois la mise à jour déployée, le client sera en mesure de vérifier les valeurs existantes écrites dans l'attribut et continuera à signer les nouvelles valeurs écrites dans l'attribut. Les nouvelles valeurs écrites dans l'attribut ne seront pas incluses dans le [contexte de chiffrement](concepts.md#encryption-context).
Avant de remplacer un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attribut existant par`SIGN_ONLY`, réfléchissez bien à l'impact que vos mises à jour peuvent avoir sur les fonctionnalités de votre [fournisseur d'ID de clé de succursale](use-hierarchical-keyring.md#branch-key-id-supplier).
**Utilisation d'une classe de données annotée**
Si vous avez défini vos actions d'attribut avec un`TableSchema`, mettez à jour l'action d'attribut associée à l'attribut de `@DynamoDBEncryptionSignAndIncludeInEncryptionContext` à`@DynamoDBEncryptionSignOnly`.
**Utilisation d'un modèle d'objet**
Si vous avez défini manuellement vos actions d'attribut, mettez à jour l'action d'attribut associée à l'attribut de `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` à `SIGN_ONLY` dans votre modèle d'objet.
# AWS SDK de chiffrement de base de données pour DynamoDB, langages de programmation disponibles
Le SDK AWS de chiffrement de base de données pour DynamoDB est disponible pour les langages de programmation suivants. Les bibliothèques spécifiques au langage varient, mais les implémentations qui en résultent sont interopérables. Vous pouvez chiffrer avec une implémentation de langage et déchiffrer avec une autre. L'interopérabilité peut être soumise à des contraintes de langage. Si c'est le cas, ces contraintes sont décrites dans la rubrique relative à l'implémentation du langage.
**Topics**
+ [Java](ddb-java.md)
+ [.NET](ddb-net.md)
+ [Rust](ddb-rust.md)
# Java
****
| |
| --- |
| 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). |
Cette rubrique explique comment installer et utiliser la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB. Pour plus de détails sur la programmation avec le SDK AWS de chiffrement de base de données pour DynamoDB, consultez les exemples [Java dans aws-database-encryption-sdk le référentiel -dynamodb](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) sur. GitHub
**Note**
Les rubriques suivantes portent sur la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB.
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). Le SDK AWS Database Encryption continue de prendre en charge les [anciennes versions du client de chiffrement DynamoDB](legacy-dynamodb-encryption-client.md).
**Topics**
+ [Conditions préalables](#ddb-java-prerequisites)
+ [Installation](#ddb-java-installation)
+ [Utilisation du client Java](ddb-java-using.md)
+ [Exemples Java](ddb-java-examples.md)
+ [Ajouter la version 3.x à une table existante](ddb-java-config-existing-table.md)
+ [Migrer vers la version 3.x](ddb-java-migrate.md)
## Conditions préalables
Avant d'installer la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB, assurez-vous de remplir les conditions préalables suivantes.
**Environnement de développement Java**
Vous aurez besoin de Java 8 ou version ultérieure. Sur le site web d'Oracle, consultez la page [Téléchargements Java SE](https://www.oracle.com/java/technologies/downloads/), puis téléchargez et installez le kit Java SE Development (JDK).
Si vous utilisez le kit JDK Oracle, vous devez également télécharger et installer les [fichiers Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK for Java 2.x**
Le SDK AWS de chiffrement de base de données pour DynamoDB nécessite [le module DynamoDB Enhanced Client du](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html). AWS SDK for Java 2.x Vous pouvez installer la totalité du kit SDK ou le seul module.
Pour plus d'informations sur la mise à jour de votre version du AWS SDK pour Java, voir [Migration de la version 1.x vers la version 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) du. AWS SDK pour Java
AWS SDK pour Java Il est disponible via Apache Maven. Vous pouvez déclarer une dépendance pour l'ensemble AWS SDK pour Java ou uniquement pour le `dynamodb-enhanced` module.
**Installez le à l' AWS SDK pour Java aide d'Apache Maven**
+ Pour [importer tout le AWS SDK pour Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) en tant que dépendance, déclarez-le dans votre fichier `pom.xml`.
+ Pour créer une dépendance uniquement pour le module Amazon DynamoDB dans AWS SDK pour Java le, suivez les instructions [pour](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies) spécifier des modules particuliers. Réglez le `groupId` to `software.amazon.awssdk` et le `artifactID` to`dynamodb-enhanced`.
**Note**
Si vous utilisez le AWS KMS trousseau de clés ou le trousseau de clés AWS KMS hiérarchique, vous devez également créer une dépendance pour le AWS KMS module. Réglez le `groupId` to `software.amazon.awssdk` et le `artifactID` to`kms`.
## Installation
Vous pouvez installer la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB de la manière suivante.
**Utilisation d'Apache Maven**
Le client de chiffrement Amazon DynamoDB pour Java est disponible [via Apache](https://maven.apache.org/) Maven avec la définition de dépendance suivante.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Utilisation de Gradle Kotlin**
Vous pouvez utiliser [Gradle](https://gradle.org/) pour déclarer une dépendance vis-à-vis du client de chiffrement Amazon DynamoDB pour Java en ajoutant ce qui suit *à* la section des dépendances de votre projet Gradle.
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**Manuellement**
[Pour installer la bibliothèque de chiffrement côté client Java pour DynamoDB, clonez ou téléchargez le référentiel -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
Après avoir installé le SDK, commencez par consulter l'exemple de code de ce guide et les [exemples Java du référentiel](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk -dynamodb sur. GitHub
# Utilisation de la bibliothèque de chiffrement côté client Java pour DynamoDB
****
| |
| --- |
| 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). |
Cette rubrique décrit certaines des fonctions et classes d'assistance de la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB.
[Pour plus de détails sur la programmation avec la bibliothèque de chiffrement côté client Java pour DynamoDB, consultez les exemples Java, les [exemples Java](java-examples.md) dans le référentiel -dynamodb sur.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk GitHub
**Topics**
+ [Chiffreurs d'éléments](#ddb-item-encryptors)
+ [Actions d'attribut](#ddb-attribute-actions)
+ [Configuration du chiffrement](#ddb-config-encrypt)
+ [Mettre à jour des éléments](#ddb-update-items)
+ [Déchiffrer des sets signés](#ddb-java-signed-sets)
## Chiffreurs d'éléments
À la base, le SDK de chiffrement AWS de base de données pour DynamoDB est un outil de chiffrement d'éléments. Vous pouvez utiliser la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB afin de chiffrer, signer, vérifier et déchiffrer les éléments de votre table DynamoDB de la manière suivante.
**Le client amélioré DynamoDB**
Vous pouvez configurer le client [DynamoDB amélioré](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) pour chiffrer et signer automatiquement `DynamoDbEncryptionInterceptor` les éléments côté client avec vos demandes DynamoDB. `PutItem` Avec le client DynamoDB Enhanced, vous pouvez définir vos actions attributaires à l'aide d'[une](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) classe de données annotée. Nous vous recommandons d'utiliser le client DynamoDB amélioré dans la mesure du possible.
[Le client DynamoDB Enhanced ne prend pas en charge le chiffrement consultable.](searchable-encryption.md)
Le SDK AWS de chiffrement de base de données ne prend pas en charge les annotations sur les attributs [imbriqués](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
**L'API DynamoDB de bas niveau**
Vous pouvez configurer l'API [DynamoDB de bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) pour chiffrer et signer automatiquement `DynamoDbEncryptionInterceptor` les éléments côté client avec vos demandes DynamoDB. `PutItem`
[Vous devez utiliser l'API DynamoDB de bas niveau pour utiliser le chiffrement consultable.](searchable-encryption.md)
**Le niveau inférieur `DynamoDbItemEncryptor`**
Le niveau inférieur chiffre, signe ou déchiffre et vérifie `DynamoDbItemEncryptor` directement les éléments de votre table sans appeler DynamoDB. Il n'émet pas de DynamoDB ni de `PutItem` requêtes`GetItem`. Par exemple, vous pouvez utiliser le niveau inférieur `DynamoDbItemEncryptor` pour déchiffrer et vérifier directement un élément DynamoDB que vous avez déjà récupéré.
Le niveau inférieur `DynamoDbItemEncryptor` ne prend pas en charge le chiffrement [consultable](searchable-encryption.md).
## Actions relatives aux attributs dans le SDK de chiffrement AWS de base de données pour DynamoDB
Les [actions d'](concepts.md#crypt-actions)attribut déterminent quelles valeurs d'attribut sont cryptées et signées, lesquelles sont uniquement signées, lesquelles sont signées et incluses dans le contexte de chiffrement, et lesquelles sont ignorées.
**Note**
Pour utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique, vous devez utiliser la version 3.3 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de [mettre à jour votre modèle de données](ddb-update-data-model.md) pour l'inclure`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Si vous utilisez l'API DynamoDB de bas niveau ou de `DynamoDbItemEncryptor` niveau inférieur, vous devez définir manuellement vos actions attributaires. [Si vous utilisez le client DynamoDB amélioré, vous pouvez soit définir manuellement vos actions attributaires, soit utiliser une classe de données annotée pour générer un. `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Pour simplifier le processus de configuration, nous vous recommandons d'utiliser une classe de données annotée. Lorsque vous utilisez une classe de données annotée, vous ne devez modéliser votre objet qu'une seule fois.
**Note**
Après avoir défini les actions relatives aux attributs, vous devez définir quels attributs sont exclus des signatures. Pour faciliter l'ajout de nouveaux attributs non signés à l'avenir, nous vous recommandons de choisir un préfixe distinct (tel que `:` « ») pour identifier vos attributs non signés. Incluez ce préfixe dans le nom d'attribut pour tous les attributs marqués lorsque vous `DO_NOTHING` définissez votre schéma DynamoDB et vos actions d'attribut.
### Utiliser une classe de données annotée
Utilisez une [classe de données annotée](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) pour spécifier vos actions attributaires avec le client DynamoDB amélioré et. `DynamoDbEncryptionInterceptor` Le SDK AWS de chiffrement de base de données pour DynamoDB utilise les annotations d'attribut [DynamoDB standard qui définissent le type d'attribut](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html) afin de déterminer comment protéger un attribut. Par défaut, tous les attributs sont chiffrés et signés à l'exception des clés primaires, qui sont signées, mais pas chiffrées.
**Note**
Pour utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique, vous devez utiliser la version 3.3 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de [mettre à jour votre modèle de données](ddb-update-data-model.md) pour l'inclure`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Consultez [SimpleClass.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) dans le référentiel aws-database-encryption-sdk -dynamodb GitHub pour plus d'informations sur les annotations du client DynamoDB Enhanced.
Par défaut, les attributs de clé primaire sont signés mais pas chiffrés (`SIGN_ONLY`) et tous les autres attributs sont chiffrés et signés (`ENCRYPT_AND_SIGN`). Si vous définissez des attributs comme`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Pour spécifier des exceptions, utilisez les annotations de chiffrement définies dans la bibliothèque de chiffrement côté client Java pour DynamoDB. Par exemple, si vous souhaitez qu'un attribut particulier soit uniquement signé, utilisez l'`@DynamoDbEncryptionSignOnly`annotation. Si vous souhaitez qu'un attribut particulier soit signé et inclus dans le contexte de chiffrement, utilisez le`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`. Si vous souhaitez qu'un attribut particulier ne soit ni signé ni chiffré (`DO_NOTHING`), utilisez l'`@DynamoDbEncryptionDoNothing`annotation.
**Note**
Le SDK AWS de chiffrement de base de données ne prend pas en charge les annotations sur les attributs [imbriqués](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
L'exemple suivant montre les annotations utilisées pour définir `ENCRYPT_AND_SIGN` et `DO_NOTHING` attribuer des actions. `SIGN_ONLY` Pour un exemple illustrant les annotations utilisées pour définir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consultez le [SimpleClassfichier 4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java).
```
@DynamoDbBean
public class SimpleClass {
private String partitionKey;
private int sortKey;
private String attribute1;
private String attribute2;
private String attribute3;
@DynamoDbPartitionKey
@DynamoDbAttribute(value = "partition_key")
public String getPartitionKey() {
return this.partitionKey;
}
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
@DynamoDbSortKey
@DynamoDbAttribute(value = "sort_key")
public int getSortKey() {
return this.sortKey;
}
public void setSortKey(int sortKey) {
this.sortKey = sortKey;
}
public String getAttribute1() {
return this.attribute1;
}
public void setAttribute1(String attribute1) {
this.attribute1 = attribute1;
}
@DynamoDbEncryptionSignOnly
public String getAttribute2() {
return this.attribute2;
}
public void setAttribute2(String attribute2) {
this.attribute2 = attribute2;
}
@DynamoDbEncryptionDoNothing
public String getAttribute3() {
return this.attribute3;
}
@DynamoDbAttribute(value = ":attribute3")
public void setAttribute3(String attribute3) {
this.attribute3 = attribute3;
}
}
```
Utilisez votre classe de données annotée pour créer le, `TableSchema` comme indiqué dans l'extrait de code suivant.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Définissez manuellement les actions de vos attributs
Pour spécifier manuellement les actions d'attribut, créez un `Map` objet dans lequel les paires nom-valeur représentent les noms d'attributs et les actions spécifiées.
Spécifiez `ENCRYPT_AND_SIGN` le chiffrement et la signature d'un attribut. Spécifiez `SIGN_ONLY` pour signer un attribut, mais pas pour le chiffrer. Spécifiez `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` de signer un attribut et de l'inclure dans le contexte de chiffrement. Vous ne pouvez pas chiffrer un attribut sans le signer également. Spécifiez `DO_NOTHING` si un attribut doit être ignoré.
Les attributs de partition et de tri doivent être l'un `SIGN_ONLY` ou l'autre`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous définissez des attributs comme`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Note**
Pour utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique, vous devez utiliser la version 3.3 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de [mettre à jour votre modèle de données](ddb-update-data-model.md) pour l'inclure`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be signed
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
// The sort attribute must be signed
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute3", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put(":attribute4", CryptoAction.DO_NOTHING);
```
## Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB
Lorsque vous utilisez le SDK AWS Database Encryption, vous devez définir explicitement une configuration de chiffrement pour votre table DynamoDB. Les valeurs requises dans votre configuration de chiffrement varient selon que vous avez défini vos actions attributaires manuellement ou à l'aide d'une classe de données annotée.
L'extrait suivant définit une configuration de chiffrement de table DynamoDB à l'aide du client DynamoDB amélioré et autorise les attributs non signés définis par un préfixe distinct [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html).
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
// Optional: only required if you use beacons
.search(SearchConfig.builder()
.writeVersion(1) // MUST be 1
.versions(beaconVersions)
.build())
.build());
```
**Nom de table logique**
Nom de table logique pour votre table DynamoDB.
Le nom de table logique est lié de manière cryptographique à toutes les données stockées dans la table afin de simplifier les opérations de restauration DynamoDB. Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Vous devez toujours spécifier le même nom de table logique. Pour que le déchiffrement réussisse, le nom de la table logique doit correspondre au nom spécifié lors du chiffrement. Si le nom de votre table DynamoDB change après la [restauration de votre table DynamoDB à partir d'une sauvegarde, le nom logique de la table garantit que l'opération de déchiffrement](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) reconnaît toujours la table.
**Attributs non signés autorisés**
Les attributs marqués `DO_NOTHING` dans vos actions d'attributs.
Les attributs non signés autorisés indiquent au client quels attributs sont exclus des signatures. Le client suppose que tous les autres attributs sont inclus dans la signature. Ensuite, lors du déchiffrement d'un enregistrement, le client détermine les attributs qu'il doit vérifier et ceux à ignorer parmi les attributs non signés autorisés que vous avez spécifiés. Vous ne pouvez pas supprimer un attribut de vos attributs non signés autorisés.
Vous pouvez définir explicitement les attributs non signés autorisés en créant un tableau répertoriant tous vos `DO_NOTHING` attributs. Vous pouvez également spécifier un préfixe distinct lorsque vous nommez vos `DO_NOTHING` attributs et utiliser le préfixe pour indiquer au client quels attributs ne sont pas signés. Nous vous recommandons vivement de spécifier un préfixe distinct, car cela simplifie le processus d'ajout d'un nouvel `DO_NOTHING` attribut à l'avenir. Pour de plus amples informations, veuillez consulter [Mettre à jour votre modèle de données](ddb-update-data-model.md).
Si vous ne spécifiez pas de préfixe pour tous les `DO_NOTHING` attributs, vous pouvez configurer un `allowedUnsignedAttributes` tableau répertoriant explicitement tous les attributs que le client doit s'attendre à voir non signés lorsqu'il les rencontre lors du déchiffrement. Vous ne devez définir explicitement vos attributs non signés autorisés que si cela est absolument nécessaire.
**Configuration de la recherche (facultatif)**
`SearchConfig`Définit la [version de la balise](using-beacons.md#beacon-version).
Le `SearchConfig` doit être spécifié pour utiliser un [chiffrement consultable](searchable-encryption.md) ou des [balises signées](configure.md#signed-beacons).
**Suite d'algorithmes (facultatif)**
`algorithmSuiteId`Définit la suite d'algorithmes utilisée par le SDK AWS de chiffrement de base de données.
À moins que vous ne spécifiiez explicitement une suite d'algorithmes alternative, le SDK AWS de chiffrement de base de données utilise la [suite d'algorithmes par défaut](supported-algorithms.md#recommended-algorithms). [La suite d'algorithmes par défaut utilise l'algorithme AES-GCM avec dérivation de clés, [signatures numériques et engagement](concepts.md#digital-sigs) de clés.](concepts.md#key-commitment) Bien que la suite d'algorithmes par défaut soit susceptible de convenir à la plupart des applications, vous pouvez choisir une autre suite d'algorithmes. Par exemple, certains modèles de confiance seraient satisfaits par une suite d'algorithmes sans signature numérique. Pour plus d'informations sur les suites d'algorithmes prises en charge par le SDK AWS de chiffrement de base de données, consultez[Suites d'algorithmes prises en charge dans le SDK AWS de chiffrement de base de données](supported-algorithms.md).
Pour sélectionner la [suite d'algorithmes AES-GCM sans signature numérique ECDSA](supported-algorithms.md#other-algorithms), incluez l'extrait suivant dans votre configuration de chiffrement de table.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Mise à jour d'éléments avec le SDK AWS de chiffrement de base de données
Le SDK AWS de chiffrement de base de données ne prend pas en charge [ddb : UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) pour les éléments chiffrés ou signés. Pour mettre à jour un élément chiffré ou signé, vous devez utiliser [ddb : PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html). Lorsque vous spécifiez la même clé primaire qu'un élément existant dans votre `PutItem` demande, le nouvel élément remplace complètement l'élément existant. Vous pouvez également utiliser [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) pour effacer et remplacer tous les attributs lors de la sauvegarde après avoir mis à jour vos articles.
## Déchiffrer des sets signés
Dans les versions 3.0.0 et 3.1.0 du SDK de chiffrement de AWS base de données, si vous définissez un attribut de [type set](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) comme`SIGN_ONLY`, les valeurs de l'ensemble sont canonisées dans l'ordre dans lequel elles sont fournies. DynamoDB ne préserve pas l'ordre des ensembles. Par conséquent, il est possible que la validation de signature de l'élément contenant l'ensemble échoue. La validation de signature échoue lorsque les valeurs de l'ensemble sont renvoyées dans un ordre différent de celui dans lequel elles ont été fournies au SDK AWS Database Encryption, même si les attributs de l'ensemble contiennent les mêmes valeurs.
**Note**
Les versions 3.1.1 et ultérieures du SDK de chiffrement de AWS base de données canonisent les valeurs de tous les attributs de type défini, afin que les valeurs soient lues dans le même ordre que celui dans lequel elles ont été écrites dans DynamoDB.
Si la validation de signature échoue, l'opération de déchiffrement échoue et renvoie le message d'erreur suivant.
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: Aucune étiquette de destinataire ne correspond. |
Si le message d'erreur ci-dessus s'affiche et que vous pensez que l'élément que vous essayez de déchiffrer inclut un ensemble signé à l'aide de la version 3.0.0 ou 3.1.0, consultez le [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)répertoire du dépôt aws-database-encryption-sdk -dynamodb-java GitHub pour savoir comment valider correctement l'ensemble.
# Exemples Java
****
| |
| --- |
| 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). |
Les exemples suivants montrent comment utiliser la bibliothèque de chiffrement côté client Java pour DynamoDB afin de protéger les éléments de table de votre application. Vous pouvez trouver d'autres exemples (et apporter les vôtres) dans les [exemples Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) du référentiel aws-database-encryption-sdk -dynamodb sur. GitHub
Les exemples suivants montrent comment configurer la bibliothèque de chiffrement côté client Java pour DynamoDB dans une nouvelle table Amazon DynamoDB non remplie. Si vous souhaitez configurer vos tables Amazon DynamoDB existantes pour le chiffrement côté client, consultez. [Ajouter la version 3.x à une table existante](ddb-java-config-existing-table.md)
**Topics**
+ [Utilisation du client amélioré DynamoDB](#ddb-java-enhanced-client-example)
+ [Utilisation de l'API DynamoDB de bas niveau](#ddb-java-lowlevel-API-example)
+ [Utiliser le niveau inférieur DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Utilisation du client amélioré DynamoDB
L'exemple suivant montre comment utiliser le client amélioré DynamoDB `DynamoDbEncryptionInterceptor` et [AWS KMS un](use-kms-keyring.md) trousseau de clés pour chiffrer des éléments de table DynamoDB dans le cadre de vos appels d'API DynamoDB.
Vous pouvez utiliser n'importe quel trousseau de [clés](keyrings.md) compatible avec le client DynamoDB amélioré, mais nous vous recommandons d'utiliser l'un des trousseaux de clés dans la mesure du AWS KMS possible.
**Note**
[Le client DynamoDB Enhanced ne prend pas en charge le chiffrement consultable.](searchable-encryption.md) Utilisez le `DynamoDbEncryptionInterceptor` avec l'API DynamoDB de bas niveau pour utiliser le chiffrement consultable.
**Voir l'exemple de code complet** : [EnhancedPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/EnhancedPutGetExample.java)
**Étape 1 : Création du AWS KMS porte-clés**
L'exemple suivant permet de `CreateAwsKmsMrkMultiKeyring` créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Étape 2 : Création d'un schéma de table à partir de la classe de données annotée**
L'exemple suivant utilise la classe de données annotée pour créer le`TableSchema`.
Cet exemple suppose que les actions de classe de données et d'attribut annotées ont été définies à l'aide du [SimpleClassfichier .java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) Pour plus d'informations sur l'annotation des actions de vos attributs, consultez[Utiliser une classe de données annotée](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
Le SDK AWS de chiffrement de base de données ne prend pas en charge les annotations sur les attributs [imbriqués](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
```
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```
**Étape 3 : définir les attributs exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client suppose que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Étape 4 : Création de la configuration de chiffrement**
L'exemple suivant définit une `tableConfigs` carte qui représente la configuration de chiffrement de la table DynamoDB.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-java-using.md#logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Pour utiliser le [chiffrement consultable](searchable-encryption.md) ou les [balises signées](configure.md#signed-beacons), vous devez également les inclure [`SearchConfig`](ddb-java-using.md#ddb-search-config)dans votre configuration de chiffrement.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Étape 5 : Crée le `DynamoDbEncryptionInterceptor`**
L'exemple suivant en crée un nouveau `DynamoDbEncryptionInterceptor` à `tableConfigs` partir de l'**étape 4**.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Étape 6 : créer un nouveau client DynamoDB du AWS SDK**
**L'exemple suivant crée un nouveau client DynamoDB du AWS SDK à l'aide `interceptor` de l'étape 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Étape 7 : Création du client DynamoDB amélioré et création d'une table**
L'exemple suivant crée le client DynamoDB amélioré à l'aide du client DynamoDB AWS SDK créé à l'**étape 6 et crée une table à l'aide de la classe** de données annotée.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Étape 8 : Chiffrer et signer un élément du tableau**
L'exemple suivant place un élément dans la table DynamoDB à l'aide du client DynamoDB amélioré. L'élément est chiffré et signé côté client avant d'être envoyé à DynamoDB.
```
final SimpleClass item = new SimpleClass();
item.setPartitionKey("EnhancedPutGetExample");
item.setSortKey(0);
item.setAttribute1("encrypt and sign me!");
item.setAttribute2("sign me!");
item.setAttribute3("ignore me!");
table.putItem(item);
```
## Utilisation de l'API DynamoDB de bas niveau
L'exemple suivant montre comment utiliser l'API DynamoDB de bas niveau avec [AWS KMS un](use-kms-keyring.md) trousseau de clés pour chiffrer et signer automatiquement des éléments côté client avec vos demandes DynamoDB. `PutItem`
Vous pouvez utiliser n'importe quel [porte-clés](keyrings.md) compatible, mais nous vous recommandons d'utiliser l'un des AWS KMS porte-clés dans la mesure du possible.
**Voir l'exemple de code complet** : [BasicPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)
**Étape 1 : Création du AWS KMS porte-clés**
L'exemple suivant permet de `CreateAwsKmsMrkMultiKeyring` créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Étape 2 : configurer les actions de vos attributs**
L'exemple suivant définit une `attributeActionsOnEncrypt` carte qui représente des exemples d'[actions attributaires](concepts.md#crypt-actions) pour un élément de table.
L'exemple suivant ne définit aucun attribut en tant que`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Étape 3 : définir les attributs exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client suppose que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Étape 4 : définir la configuration du chiffrement des tables DynamoDB**
L'exemple suivant définit une `tableConfigs` carte qui représente la configuration de chiffrement pour cette table DynamoDB.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-java-using.md#logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Pour utiliser le [chiffrement consultable](searchable-encryption.md) ou les [balises signées](configure.md#signed-beacons), vous devez également les inclure [`SearchConfig`](ddb-java-using.md#ddb-search-config)dans votre configuration de chiffrement.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
tableConfigs.put(ddbTableName, config);
```
**Étape 5 : Création du `DynamoDbEncryptionInterceptor`**
L'exemple suivant crée le `DynamoDbEncryptionInterceptor` à l'aide `tableConfigs` de l'**étape 4**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Étape 6 : créer un nouveau client DynamoDB du AWS SDK**
**L'exemple suivant crée un nouveau client DynamoDB du AWS SDK à l'aide `interceptor` de l'étape 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Étape 7 : Chiffrer et signer un élément de table DynamoDB**
L'exemple suivant définit une `item` carte qui représente un exemple d'élément de table et place l'élément dans la table DynamoDB. L'élément est chiffré et signé côté client avant d'être envoyé à DynamoDB.
```
final HashMap item = new HashMap<>();
item.put("partition_key", AttributeValue.builder().s("BasicPutGetExample").build());
item.put("sort_key", AttributeValue.builder().n("0").build());
item.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
item.put("attribute2", AttributeValue.builder().s("sign me!").build());
item.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final PutItemRequest putRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(item)
.build();
final PutItemResponse putResponse = ddb.putItem(putRequest);
```
## Utiliser le niveau inférieur DynamoDbItemEncryptor
L'exemple suivant montre comment utiliser le niveau inférieur `DynamoDbItemEncryptor` avec un [AWS KMS trousseau de clés](use-kms-keyring.md) pour chiffrer et signer directement des éléments de table. L'élément `DynamoDbItemEncryptor` n'est pas placé dans votre table DynamoDB.
Vous pouvez utiliser n'importe quel trousseau de [clés](keyrings.md) compatible avec le client DynamoDB amélioré, mais nous vous recommandons d'utiliser l'un des trousseaux de clés dans la mesure du AWS KMS possible.
**Note**
Le niveau inférieur `DynamoDbItemEncryptor` ne prend pas en charge le chiffrement [consultable](searchable-encryption.md). Utilisez le `DynamoDbEncryptionInterceptor` avec l'API DynamoDB de bas niveau pour utiliser le chiffrement consultable.
**Voir l'exemple de code complet** : [ItemEncryptDecryptExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/itemencryptor/ItemEncryptDecryptExample.java)
**Étape 1 : Création du AWS KMS porte-clés**
L'exemple suivant permet de `CreateAwsKmsMrkMultiKeyring` créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Étape 2 : configurer les actions de vos attributs**
L'exemple suivant définit une `attributeActionsOnEncrypt` carte qui représente des exemples d'[actions attributaires](concepts.md#crypt-actions) pour un élément de table.
L'exemple suivant ne définit aucun attribut en tant que`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Étape 3 : définir les attributs exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client suppose que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Étape 4 : définir la `DynamoDbItemEncryptor` configuration**
L'exemple suivant définit la configuration de`DynamoDbItemEncryptor`.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-java-using.md#logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
```
final DynamoDbItemEncryptorConfig config = DynamoDbItemEncryptorConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
```
**Étape 5 : Création du `DynamoDbItemEncryptor`**
L'exemple suivant en crée un nouveau à `DynamoDbItemEncryptor` l'aide de l'étape 4 `config` à partir de l'**étape 4**.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Étape 6 : Chiffrer et signer directement un élément du tableau**
L'exemple suivant chiffre et signe directement un élément à l'aide du`DynamoDbItemEncryptor`. L'élément `DynamoDbItemEncryptor` n'est pas placé dans votre table DynamoDB.
```
final Map originalItem = new HashMap<>();
originalItem.put("partition_key", AttributeValue.builder().s("ItemEncryptDecryptExample").build());
originalItem.put("sort_key", AttributeValue.builder().n("0").build());
originalItem.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
originalItem.put("attribute2", AttributeValue.builder().s("sign me!").build());
originalItem.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final Map encryptedItem = itemEncryptor.EncryptItem(
EncryptItemInput.builder()
.plaintextItem(originalItem)
.build()
).encryptedItem();
```
# Configurer une table DynamoDB existante pour utiliser AWS le SDK de chiffrement de base de données pour DynamoDB
****
| |
| --- |
| 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). |
Avec la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB, vous pouvez configurer vos tables Amazon DynamoDB existantes pour le chiffrement côté client. Cette rubrique fournit des conseils sur les trois étapes à suivre pour ajouter la version 3. *x* vers une table DynamoDB existante et renseignée.
**Conditions préalables**
Version 3. *x* [de la bibliothèque de chiffrement côté client Java pour DynamoDB nécessite le client DynamoDB amélioré fourni dans.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) AWS SDK for Java 2.x Si vous utilisez toujours [Dynamo DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html), vous devez effectuer la migration AWS SDK for Java 2.x vers le client DynamoDB amélioré.
Suivez les instructions de [migration de la version 1.x vers la version 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) du. AWS SDK pour Java
Suivez ensuite les instructions pour [commencer à utiliser l'API client améliorée DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html).
[Avant de configurer votre table pour utiliser la bibliothèque de chiffrement côté client Java pour DynamoDB, vous devez générer une `TableSchema` classe de [données annotée et créer un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) client amélioré.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient)
## Étape 1 : Préparez-vous à lire et à écrire des éléments chiffrés
Procédez comme suit pour préparer votre client du SDK AWS Database Encryption à lire et à écrire des éléments chiffrés. Après avoir déployé les modifications suivantes, votre client continuera à lire et à écrire des éléments en texte brut. Il ne chiffrera ni ne signera aucun nouvel élément inscrit dans la table, mais il sera en mesure de déchiffrer les éléments chiffrés dès leur apparition. Ces modifications préparent le client à commencer à [chiffrer de nouveaux éléments](#ddb-java-add-step2). Les modifications suivantes doivent être déployées sur chaque lecteur avant de passer à l'étape suivante.
**1. Définissez vos [actions attributaires](concepts.md#crypt-actions)**
Mettez à jour votre classe de données annotée pour inclure des actions d'attribut qui définissent les valeurs d'attribut qui seront chiffrées et signées, celles qui seront uniquement signées et celles qui seront ignorées.
Consultez le [SimpleClassfichier .java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) dans le référentiel aws-database-encryption-sdk -dynamodb GitHub pour plus d'informations sur les annotations du client DynamoDB Enhanced.
Par défaut, les attributs de clé primaire sont signés mais pas chiffrés (`SIGN_ONLY`) et tous les autres attributs sont chiffrés et signés (`ENCRYPT_AND_SIGN`). Pour spécifier des exceptions, utilisez les annotations de chiffrement définies dans la bibliothèque de chiffrement côté client Java pour DynamoDB. Par exemple, si vous souhaitez qu'un attribut particulier soit un signe, utilisez uniquement l'`@DynamoDbEncryptionSignOnly`annotation. Si vous souhaitez qu'un attribut particulier soit signé et inclus dans le contexte de chiffrement, utilisez l'`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`annotation. Si vous souhaitez qu'un attribut particulier ne soit ni signé ni chiffré (`DO_NOTHING`), utilisez l'`@DynamoDbEncryptionDoNothing`annotation.
Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Pour un exemple illustrant les annotations utilisées pour définir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consultez le [SimpleClassfichier 4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java).
Pour des exemples d'annotations, voir[Utiliser une classe de données annotée](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**2. Définissez les attributs qui seront exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client supposera que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. Créez un [porte-clés](keyrings.md)**
L'exemple suivant crée un [AWS KMS trousseau de clés.](use-kms-keyring.md) Le AWS KMS trousseau de clés utilise le chiffrement symétrique ou le RSA asymétrique AWS KMS keys pour générer, chiffrer et déchiffrer les clés de données.
Cet exemple permet `CreateMrkMultiKeyring` de créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Définition de la configuration du chiffrement des tables DynamoDB **
L'exemple suivant définit une `tableConfigs` carte qui représente la configuration de chiffrement pour cette table DynamoDB.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-java-using.md#logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Vous devez le spécifier `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` comme remplacement en texte brut. Cette politique continue de lire et d'écrire des éléments en texte brut, de lire des éléments chiffrés et de préparer le client à écrire des éléments chiffrés.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
**5. Créer le `DynamoDbEncryptionInterceptor`**
L'exemple suivant crée le `DynamoDbEncryptionInterceptor` à l'aide `tableConfigs` de l'**étape 3**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Étape 2 : Écrire des éléments chiffrés et signés
Mettez à jour la politique de texte brut dans votre `DynamoDbEncryptionInterceptor` configuration pour permettre au client d'écrire des éléments chiffrés et signés. Après avoir déployé la modification suivante, le client chiffre et signe les nouveaux éléments en fonction des actions d'attribut que vous avez configurées à l'**étape 1**. Le client pourra lire les éléments en texte brut et les éléments chiffrés et signés.
Avant de passer à l'[étape 3](#ddb-java-add-step3), vous devez chiffrer et signer tous les éléments en texte brut existants dans votre tableau. Il n'existe pas de métrique ou de requête unique que vous puissiez exécuter pour chiffrer rapidement vos éléments en texte brut existants. Utilisez le processus le mieux adapté à votre système. Par exemple, vous pouvez utiliser un processus asynchrone qui analyse lentement la table et réécrit les éléments à l'aide des actions attributaires et de la configuration de chiffrement que vous avez définies. Pour identifier les éléments en texte brut de votre tableau, nous vous recommandons de rechercher tous les éléments qui ne contiennent pas les `aws_dbe_foot` attributs `aws_dbe_head` et que le SDK de chiffrement de AWS base de données ajoute aux éléments lorsqu'ils sont chiffrés et signés.
L'exemple suivant met à jour la configuration de chiffrement des tables depuis **l'étape 1**. Vous devez mettre à jour le remplacement en texte brut avec. `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` Cette politique continue de lire les éléments en texte brut, mais également de lire et d'écrire des éléments chiffrés. Créez-en un nouveau `DynamoDbEncryptionInterceptor` à l'aide de la mise à jour`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
## Étape 3 : lire uniquement les éléments chiffrés et signés
Une fois que vous avez chiffré et signé tous vos éléments, mettez à jour la dérogation en texte brut dans votre `DynamoDbEncryptionInterceptor` configuration pour autoriser uniquement le client à lire et écrire des éléments chiffrés et signés. Après avoir déployé la modification suivante, le client chiffre et signe les nouveaux éléments en fonction des actions d'attribut que vous avez configurées à l'**étape 1**. Le client ne pourra lire que les éléments chiffrés et signés.
L'exemple suivant met à jour la configuration de chiffrement des tables depuis **l'étape 2**. Vous pouvez soit mettre à jour la règle de remplacement en texte brut, `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` soit la supprimer de votre configuration. Le client lit et écrit uniquement les éléments chiffrés et signés par défaut. Créez-en un nouveau `DynamoDbEncryptionInterceptor` à l'aide de la mise à jour`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
// Optional: you can also remove the plaintext policy from your configuration
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
# Migrer vers la version 3.x de la bibliothèque de chiffrement côté client Java pour DynamoDB
****
| |
| --- |
| 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). |
Version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB est une réécriture majeure du 2. base de code *x.* Il inclut de nombreuses mises à jour, telles qu'un nouveau format de données structuré, une prise en charge améliorée de la mutualisation, des modifications de schéma fluides et la prise en charge du chiffrement consultable. Cette rubrique fournit des conseils sur la façon de migrer votre code vers la version 3. *x.*
## Migration de la version 1.x vers la version 2.x
Migrez vers la version 2. *x* avant de migrer vers la version 3. *x.* Version 2. *x* a changé le symbole du fournisseur le plus récent de `MostRecentProvider` à`CachingMostRecentProvider`. Si vous utilisez actuellement la version 1. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB avec le `MostRecentProvider` symbole, vous devez mettre à jour le nom du symbole dans votre code en. `CachingMostRecentProvider` Pour plus d'informations, voir [Mises à jour du fournisseur le plus récent](most-recent-provider.md#mrp-versions).
## Migration de la version 2.x vers la version 3.x
Les procédures suivantes décrivent comment migrer votre code depuis la version 2. *x* vers la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB.
### Étape 1. Préparez-vous à lire les éléments dans le nouveau format
Procédez comme suit pour préparer votre client AWS Database Encryption SDK à lire les éléments dans le nouveau format. Après avoir déployé les modifications suivantes, votre client continuera à se comporter de la même manière que dans la version 2. *x.* Votre client continuera à lire et à écrire des éléments dans la version 2. format *x*, mais ces modifications préparent le client à [lire les éléments dans le nouveau format](#ddb-java-migrate-step2).
**Mettez à jour votre AWS SDK pour Java version 2.x**
Version 3. *x* [de la bibliothèque de chiffrement côté client Java pour DynamoDB nécessite le client DynamoDB amélioré.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) Le client DynamoDB amélioré remplace le DBMapper Dynamo utilisé [dans les versions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) précédentes. Pour utiliser le client amélioré, vous devez utiliser le AWS SDK for Java 2.x.
Suivez les instructions de [migration de la version 1.x vers la version 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) du. AWS SDK pour Java
Pour plus d'informations sur les AWS SDK for Java 2.x modules requis, consultez[Conditions préalables](ddb-java.md#ddb-java-prerequisites).
**Configurez votre client pour lire les éléments chiffrés par les anciennes versions**
Les procédures suivantes fournissent une vue d'ensemble des étapes illustrées dans l'exemple de code ci-dessous.
1. Créez un [porte-clés.](keyrings.md)
Les porte-clés et les [gestionnaires de matériel cryptographique](concepts.md#crypt-materials-manager) remplacent les fournisseurs de matériel cryptographique utilisés dans les versions précédentes de la bibliothèque de chiffrement côté client Java pour DynamoDB.
**Important**
Les clés d'encapsulation que vous spécifiez lors de la création d'un jeu de clés doivent être les mêmes que celles que vous avez utilisées avec votre fournisseur de matériel cryptographique dans la version 2. *x.*
1. Créez un schéma de table au-dessus de votre classe annotée.
Cette étape définit les actions d'attribut qui seront utilisées lorsque vous commencerez à écrire des éléments dans le nouveau format.
*Pour obtenir des conseils sur l'utilisation du nouveau client DynamoDB amélioré, reportez-vous à la section [Generate `TableSchema` a du](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) guide du développeur.AWS SDK pour Java *
L'exemple suivant suppose que vous avez mis à jour votre classe annotée à partir de la version 2. *x* en utilisant les nouvelles annotations d'actions d'attribut. Pour plus d'informations sur l'annotation des actions de vos attributs, consultez[Utiliser une classe de données annotée](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**Note**
Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Pour un exemple illustrant les annotations utilisées pour définir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consultez [SimpleClass4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java).
1. Définissez les [attributs exclus de la signature](ddb-java-using.md#allowed-unauth).
1. Configurez une carte explicite des actions d'attributs configurées dans votre classe modélisée de la version 2.x.
Cette étape définit les actions d'attribut utilisées pour écrire des éléments dans l'ancien format.
1. Configurez le `DynamoDBEncryptor` que vous avez utilisé dans la version 2. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB.
1. Configurez le comportement existant.
1. Créez un `DynamoDbEncryptionInterceptor`.
1. Créez un nouveau client AWS DynamoDB SDK.
1. Créez le `DynamoDBEnhancedClient` et créez un tableau avec votre classe modélisée.
Pour plus d'informations sur le client DynamoDB amélioré, [voir créer un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client amélioré.
```
public class MigrationExampleStep1 {
public static void MigrationStep1(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Create a Keyring.
// This example creates an AWS KMS Keyring that specifies the
// same kmsKeyId previously used in the version 2.x configuration.
// It uses the 'CreateMrkMultiKeyring' method to create the
// keyring, so that the keyring can correctly handle both single
// region and Multi-Region KMS Keys.
// Note that this example uses the AWS SDK for Java v2 KMS client.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
// 2. Create a Table Schema over your annotated class.
// For guidance on using the new attribute actions
// annotations, see SimpleClass.java in the
// aws-database-encryption-sdk-dynamodb GitHub repository.
// All primary key attributes must be signed but not encrypted
// and by default all non-primary key attributes
// are encrypted and signed (ENCRYPT_AND_SIGN).
// If you want a particular non-primary key attribute to be signed but
// not encrypted, use the 'DynamoDbEncryptionSignOnly' annotation.
// If you want a particular attribute to be neither signed nor encrypted
// (DO_NOTHING), use the 'DynamoDbEncryptionDoNothing' annotation.
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
// 3. Define which attributes the client should expect to be excluded
// from the signature when reading items.
// This value represents all unsigned attributes across the entire
// dataset.
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 4. Configure an explicit map of the attribute actions configured
// in your version 2.x modeled class.
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
// 5. Configure the DynamoDBEncryptor that you used in version 2.x.
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 6. Configure the legacy behavior.
// Input the DynamoDBEncryptor and attribute actions created in
// the previous steps. For Legacy Policy, use
// 'FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy continues to read
// and write items using the old format, but will be able to read
// items written in the new format as soon as they appear.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 7. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 8. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 7.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 9. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb client
// created in Step 8, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
### Étape 2. Écrire des éléments dans le nouveau format
Après avoir déployé les modifications apportées à l'étape 1 sur tous les lecteurs, effectuez les étapes suivantes pour configurer votre client AWS Database Encryption SDK afin d'écrire des éléments dans le nouveau format. Après avoir déployé les modifications suivantes, votre client continuera à lire les éléments dans l'ancien format et commencera à écrire et à lire des éléments dans le nouveau format.
Les procédures suivantes fournissent une vue d'ensemble des étapes illustrées dans l'exemple de code ci-dessous.
1. Continuez à configurer votre trousseau de clés, votre schéma de table, vos anciennes actions attributaires`allowedUnsignedAttributes`, `DynamoDBEncryptor` comme vous l'avez fait à l'[**étape 1**](#ddb-java-migrate-step1).
1. Mettez à jour votre ancien comportement pour n'écrire que les nouveaux éléments en utilisant le nouveau format.
1. Créer une `DynamoDbEncryptionInterceptor `
1. Créez un nouveau client AWS DynamoDB SDK.
1. Créez le `DynamoDBEnhancedClient` et créez un tableau avec votre classe modélisée.
Pour plus d'informations sur le client DynamoDB amélioré, [voir créer un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client amélioré.
```
public class MigrationExampleStep2 {
public static void MigrationStep2(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema, legacy
// attribute actions, allowedUnsignedAttributes, and
// DynamoDBEncryptor as you did in Step 1.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 2. Update your legacy behavior to only write new items using the new
// format.
// For Legacy Policy, use 'FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy
// continues to read items in both formats, but will only write items
// using the new format.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb Client created
// in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
Après avoir déployé les modifications de l'étape 2, vous devez rechiffrer tous les anciens éléments de votre tableau avec le nouveau format avant de [passer à l'étape](#ddb-java-migrate-step3) 3. Il n'existe pas de métrique ou de requête unique que vous puissiez exécuter pour chiffrer rapidement vos éléments existants. Utilisez le processus le mieux adapté à votre système. Par exemple, vous pouvez utiliser un processus asynchrone qui analyse lentement la table et réécrit les éléments à l'aide des nouvelles actions attributaires et de la nouvelle configuration de chiffrement que vous avez définies.
### Étape 3. Lisez et écrivez uniquement les éléments dans le nouveau format
Après avoir rechiffré tous les éléments de votre tableau avec le nouveau format, vous pouvez supprimer le comportement existant de votre configuration. Procédez comme suit pour configurer votre client de manière à ce qu'il lise et écrive uniquement les éléments dans le nouveau format.
Les procédures suivantes fournissent une vue d'ensemble des étapes illustrées dans l'exemple de code ci-dessous.
1. Continuez à configurer votre trousseau de clés, votre schéma de table, `allowedUnsignedAttributes` comme vous l'avez fait à l'[**étape 1**](#ddb-java-migrate-step1). Supprimez les anciennes actions attributaires et `DynamoDBEncryptor` supprimez-les de votre configuration.
1. Créez un `DynamoDbEncryptionInterceptor`.
1. Créez un nouveau client AWS DynamoDB SDK.
1. Créez le `DynamoDBEnhancedClient` et créez un tableau avec votre classe modélisée.
Pour plus d'informations sur le client DynamoDB amélioré, [voir créer un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client amélioré.
```
public class MigrationExampleStep3 {
public static void MigrationStep3(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema,
// and allowedUnsignedAttributes as you did in Step 1.
// Do not include the configurations for the DynamoDBEncryptor or
// the legacy attribute actions.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
// Do not configure any legacy behavior.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK Client
// created in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
# .NET
Cette rubrique explique comment installer et utiliser la version 3. *x* de la bibliothèque de chiffrement côté client .NET pour DynamoDB. Pour plus de détails sur la programmation avec le SDK AWS de chiffrement de base de données pour DynamoDB, consultez les exemples [.NET dans aws-database-encryption-sdk le référentiel -dynamodb](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/) sur. GitHub
La bibliothèque de chiffrement côté client .NET pour DynamoDB est destinée aux développeurs qui écrivent des applications en C\$1 et dans d'autres langages de programmation .NET. Elle est prise en charge sur Windows, macOS et Linux.
Toutes les implémentations en [langage de programmation](ddb-programming-languages.md) du SDK de chiffrement de AWS base de données pour DynamoDB sont interopérables. Toutefois, les valeurs vides SDK pour .NET ne sont pas prises en charge pour les types de données de liste ou de carte. Cela signifie que si vous utilisez la bibliothèque de chiffrement côté client Java pour DynamoDB pour écrire un élément contenant des valeurs vides pour un type de données de liste ou de carte, vous ne pouvez pas déchiffrer et lire cet élément à l'aide de la bibliothèque de chiffrement côté client .NET pour DynamoDB.
**Topics**
+ [Installation](#ddb-net-install)
+ [Débogage](#ddb-net-debugging)
+ [Utilisation du client .NET](ddb-net-using.md)
+ [Exemples .NET](ddb-net-examples.md)
+ [Ajouter la version 3.x à une table existante](ddb-net-config-existing-table.md)
## Installation de la bibliothèque de chiffrement côté client .NET pour DynamoDB
[La bibliothèque de chiffrement côté client .NET pour DynamoDB est disponible sous le nom de AWS.Cryptography. DbEncryptionSDK. DynamoDb](https://www.nuget.org/packages/AWS.Cryptography.DbEncryptionSDK.DynamoDb/)emballer dans NuGet. Pour plus de détails sur l'installation et la création de la bibliothèque, consultez le fichier [.NET README.md](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/DynamoDbEncryption/runtimes/net/README.md) dans le aws-database-encryption-sdk référentiel -dynamodb. La bibliothèque de chiffrement côté client .NET pour DynamoDB nécessite les clés SDK pour .NET même si vous n'utilisez pas (). AWS Key Management Service AWS KMS Le SDK pour .NET est installé avec le NuGet package.
Version 3. *x* de la bibliothèque de chiffrement côté client .NET pour DynamoDB prend en charge .NET 6.0 et .NET Framework net48 et versions ultérieures.
## Débogage avec .NET
La bibliothèque de chiffrement côté client .NET pour DynamoDB ne génère aucun journal. Les exceptions de la bibliothèque de chiffrement côté client .NET pour DynamoDB génèrent un message d'exception, mais aucune trace de pile.
Pour vous aider à déboguer, veillez à activer la connexion au SDK pour .NET. Les journaux et les messages d'erreur du SDK pour .NET peuvent vous aider à distinguer les erreurs survenant dans la bibliothèque de chiffrement côté client .NET pour DynamoDB SDK pour .NET de celles qui se produisent dans la bibliothèque de chiffrement .NET. Pour obtenir de l'aide SDK pour .NET concernant la journalisation, consultez [AWSLogging](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-config-other.html#config-setting-awslogging)le *guide du AWS SDK pour .NET développeur*. (Pour consulter le sujet, développez la section **Ouvrir pour afficher le contenu du .NET Framework**.)
# Utilisation de la bibliothèque de chiffrement côté client .NET pour DynamoDB
Cette rubrique décrit certaines des fonctions et classes d'assistance de la version 3. *x* de la bibliothèque de chiffrement côté client .NET pour DynamoDB.
Pour plus de détails sur la programmation avec la bibliothèque de chiffrement côté client .NET pour DynamoDB, consultez les [exemples .NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/) dans le référentiel -dynamodb sur. aws-database-encryption-sdk GitHub
**Topics**
+ [Chiffreurs d'éléments](#ddb-net-item-encryptors)
+ [Actions d'attribut](#ddb-net-attribute-actions)
+ [Configuration du chiffrement](#ddb-net-config-encrypt)
+ [Mettre à jour des éléments](#ddb-net-update-items)
## Chiffreurs d'éléments
À la base, le SDK de chiffrement AWS de base de données pour DynamoDB est un outil de chiffrement d'éléments. Vous pouvez utiliser la version 3. *x* de la bibliothèque de chiffrement côté client .NET pour DynamoDB afin de chiffrer, signer, vérifier et déchiffrer les éléments de votre table DynamoDB de la manière suivante.
**Le SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB**
Vous pouvez utiliser votre [configuration de chiffrement de table](#ddb-net-config-encrypt) pour créer un client DynamoDB qui chiffre et signe automatiquement les éléments côté client avec vos requêtes DynamoDB. `PutItem` Vous pouvez utiliser ce client directement ou créer un modèle de [document ou un modèle](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-document) de [persistance d'objet](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-object-persistence).
[Vous devez utiliser le SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB afin d'utiliser le chiffrement consultable.](searchable-encryption.md)
**Le niveau inférieur `DynamoDbItemEncryptor`**
Le niveau inférieur chiffre, signe ou déchiffre et vérifie `DynamoDbItemEncryptor` directement les éléments de votre table sans appeler DynamoDB. Il n'émet pas de DynamoDB ni de `PutItem` requêtes`GetItem`. Par exemple, vous pouvez utiliser le niveau inférieur `DynamoDbItemEncryptor` pour déchiffrer et vérifier directement un élément DynamoDB que vous avez déjà récupéré. Si vous utilisez le niveau inférieur`DynamoDbItemEncryptor`, nous vous recommandons d'utiliser le [modèle de programmation de bas niveau](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-low-level) SDK pour .NET fourni pour communiquer avec DynamoDB.
Le niveau inférieur `DynamoDbItemEncryptor` ne prend pas en charge le chiffrement [consultable](searchable-encryption.md).
## Actions relatives aux attributs dans le SDK de chiffrement AWS de base de données pour DynamoDB
Les [actions d'](concepts.md#crypt-actions)attribut déterminent quelles valeurs d'attribut sont cryptées et signées, lesquelles sont uniquement signées, lesquelles sont signées et incluses dans le contexte de chiffrement, et lesquelles sont ignorées.
Pour spécifier des actions d'attribut avec le client .NET, définissez manuellement les actions d'attribut à l'aide d'un modèle d'objet. Spécifiez vos actions d'attribut en créant un `Dictionary` objet dans lequel les paires nom-valeur représentent les noms d'attributs et les actions spécifiées.
Spécifiez `ENCRYPT_AND_SIGN` le chiffrement et la signature d'un attribut. Spécifiez `SIGN_ONLY` pour signer un attribut, mais pas pour le chiffrer. Spécifiez `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` de signer un attribut et de l'inclure dans le contexte de chiffrement. Vous ne pouvez pas chiffrer un attribut sans le signer également. Spécifiez `DO_NOTHING` pour ignorer un attribut.
Les attributs de partition et de tri doivent être `SIGN_ONLY` soit`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous définissez des attributs comme`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Note**
Après avoir défini vos actions d'attribut, vous devez définir quels attributs sont exclus des signatures. Pour faciliter l'ajout de nouveaux attributs non signés à l'avenir, nous vous recommandons de choisir un préfixe distinct (tel que `:` « ») pour identifier vos attributs non signés. Incluez ce préfixe dans le nom de tous les attributs marqués lorsque vous `DO_NOTHING` définissez votre schéma DynamoDB et vos actions d'attribut.
Le modèle d'objet suivant montre comment spécifier`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, et `DO_NOTHING` attribuer des actions avec le client .NET. Cet exemple utilise le préfixe « `:` » pour identifier les `DO_NOTHING` attributs.
**Note**
Pour utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique, vous devez utiliser la version 3.3 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de [mettre à jour votre modèle de données](ddb-update-data-model.md) pour l'inclure`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT, // The partition attribute must be signed
["sort_key"] = CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT, // The sort attribute must be signed
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
["attribute3"] = CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT,
[":attribute4"] = CryptoAction.DO_NOTHING
};
```
## Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB
Lorsque vous utilisez le SDK AWS Database Encryption, vous devez définir explicitement une configuration de chiffrement pour votre table DynamoDB. Les valeurs requises dans votre configuration de chiffrement varient selon que vous avez défini vos actions attributaires manuellement ou à l'aide d'une classe de données annotée.
L'extrait suivant définit une configuration de chiffrement de table DynamoDB à l'aide du SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB et des attributs non signés autorisés définis par un préfixe distinct.
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix,
// Optional: SearchConfig only required if you use beacons
Search = new SearchConfig
{
WriteVersion = 1, // MUST be 1
Versions = beaconVersions
}
};
tableConfigs.Add(ddbTableName, config);
```
**Nom de table logique**
Nom de table logique pour votre table DynamoDB.
Le nom de table logique est lié de manière cryptographique à toutes les données stockées dans la table afin de simplifier les opérations de restauration DynamoDB. Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Vous devez toujours spécifier le même nom de table logique. Pour que le déchiffrement réussisse, le nom de la table logique doit correspondre au nom spécifié lors du chiffrement. Si le nom de votre table DynamoDB change après la [restauration de votre table DynamoDB à partir d'une sauvegarde, le nom logique de la table garantit que l'opération de déchiffrement](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) reconnaît toujours la table.
**Attributs non signés autorisés**
Les attributs marqués `DO_NOTHING` dans vos actions d'attributs.
Les attributs non signés autorisés indiquent au client quels attributs sont exclus des signatures. Le client suppose que tous les autres attributs sont inclus dans la signature. Ensuite, lors du déchiffrement d'un enregistrement, le client détermine les attributs qu'il doit vérifier et ceux à ignorer parmi les attributs non signés autorisés que vous avez spécifiés. Vous ne pouvez pas supprimer un attribut de vos attributs non signés autorisés.
Vous pouvez définir explicitement les attributs non signés autorisés en créant un tableau répertoriant tous vos `DO_NOTHING` attributs. Vous pouvez également spécifier un préfixe distinct lorsque vous nommez vos `DO_NOTHING` attributs et utiliser le préfixe pour indiquer au client quels attributs ne sont pas signés. Nous vous recommandons vivement de spécifier un préfixe distinct, car cela simplifie le processus d'ajout d'un nouvel `DO_NOTHING` attribut à l'avenir. Pour de plus amples informations, veuillez consulter [Mettre à jour votre modèle de données](ddb-update-data-model.md).
Si vous ne spécifiez pas de préfixe pour tous les `DO_NOTHING` attributs, vous pouvez configurer un `allowedUnsignedAttributes` tableau répertoriant explicitement tous les attributs que le client doit s'attendre à voir non signés lorsqu'il les rencontre lors du déchiffrement. Vous ne devez définir explicitement vos attributs non signés autorisés que si cela est absolument nécessaire.
**Configuration de la recherche (facultatif)**
`SearchConfig`Définit la [version de la balise](using-beacons.md#beacon-version).
Le `SearchConfig` doit être spécifié pour utiliser un [chiffrement consultable](searchable-encryption.md) ou des [balises signées](configure.md#signed-beacons).
**Suite d'algorithmes (facultatif)**
`algorithmSuiteId`Définit la suite d'algorithmes utilisée par le SDK AWS de chiffrement de base de données.
À moins que vous ne spécifiiez explicitement une suite d'algorithmes alternative, le SDK AWS de chiffrement de base de données utilise la [suite d'algorithmes par défaut](supported-algorithms.md#recommended-algorithms). [La suite d'algorithmes par défaut utilise l'algorithme AES-GCM avec dérivation de clés, [signatures numériques et engagement](concepts.md#digital-sigs) de clés.](concepts.md#key-commitment) Bien que la suite d'algorithmes par défaut soit susceptible de convenir à la plupart des applications, vous pouvez choisir une autre suite d'algorithmes. Par exemple, certains modèles de confiance seraient satisfaits par une suite d'algorithmes sans signature numérique. Pour plus d'informations sur les suites d'algorithmes prises en charge par le SDK AWS de chiffrement de base de données, consultez[Suites d'algorithmes prises en charge dans le SDK AWS de chiffrement de base de données](supported-algorithms.md).
Pour sélectionner la [suite d'algorithmes AES-GCM sans signature numérique ECDSA](supported-algorithms.md#other-algorithms), incluez l'extrait suivant dans votre configuration de chiffrement de table.
```
AlgorithmSuiteId = DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384
```
## Mise à jour d'éléments avec le SDK AWS de chiffrement de base de données
Le SDK AWS de chiffrement de base de données ne prend pas en charge [ddb : UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) pour les éléments qui incluent des attributs chiffrés ou signés. Pour mettre à jour un attribut chiffré ou signé, vous devez utiliser [ddb : PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html). Lorsque vous spécifiez la même clé primaire qu'un élément existant dans votre `PutItem` demande, le nouvel article remplace complètement l'élément existant. Vous pouvez également utiliser [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) pour effacer et remplacer tous les attributs lors de la sauvegarde après avoir mis à jour vos articles.
# Exemples .NET
Les exemples suivants montrent comment utiliser la bibliothèque de chiffrement côté client .NET pour DynamoDB afin de protéger les éléments de table de votre application. Pour trouver d'autres exemples (et apporter les vôtres), consultez les [exemples .NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/net/src) dans le référentiel aws-database-encryption-sdk -dynamodb sur. GitHub
Les exemples suivants montrent comment configurer la bibliothèque de chiffrement côté client .NET pour DynamoDB dans une nouvelle table Amazon DynamoDB non remplie. Si vous souhaitez configurer vos tables Amazon DynamoDB existantes pour le chiffrement côté client, consultez. [Ajouter la version 3.x à une table existante](ddb-net-config-existing-table.md)
**Topics**
+ [Utilisation du SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB](#ddb-net-lowlevel-API-example)
+ [Utiliser le niveau inférieur `DynamoDbItemEncryptor`](#ddb-net-itemencryptor)
## Utilisation du SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB
L'exemple suivant montre comment utiliser le SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB avec un jeu de [AWS KMS clés](use-kms-keyring.md) afin de chiffrer et de signer automatiquement des éléments côté client avec vos demandes DynamoDB. `PutItem`
Vous pouvez utiliser n'importe quel [porte-clés](keyrings.md) compatible, mais nous vous recommandons d'utiliser l'un des AWS KMS porte-clés dans la mesure du possible.
**Voir l'exemple de code complet** : [BasicPutGetExample.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/BasicPutGetExample.cs)
**Étape 1 : Création du AWS KMS porte-clés**
L'exemple suivant permet de `CreateAwsKmsMrkMultiKeyring` créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. Le `CreateAwsKmsMrkMultiKeyring` procédé garantit que le trousseau de clés gère correctement les clés à région unique et à zones multiples.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Étape 2 : configurer les actions de vos attributs**
L'exemple suivant définit un `attributeActionsOnEncrypt` dictionnaire qui représente des exemples d'[actions attributaires](concepts.md#crypt-actions) pour un élément de table.
L'exemple suivant ne définit aucun attribut en tant que`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**Étape 3 : définir les attributs exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client suppose que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
const String unsignAttrPrefix = ":";
```
**Étape 4 : définir la configuration du chiffrement des tables DynamoDB**
L'exemple suivant définit une `tableConfigs` carte qui représente la configuration de chiffrement pour cette table DynamoDB.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-net-using.md#net-logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-net-using.md#ddb-net-config-encrypt).
Pour utiliser le [chiffrement consultable](searchable-encryption.md) ou les [balises signées](configure.md#signed-beacons), vous devez également les inclure [`SearchConfig`](ddb-java-using.md#ddb-search-config)dans votre configuration de chiffrement.
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix
};
tableConfigs.Add(ddbTableName, config);
```
**Étape 5 : créer un nouveau client DynamoDB du AWS SDK**
**L'exemple suivant crée un nouveau client DynamoDB du AWS SDK à l'aide `TableEncryptionConfigs` de l'étape 4.**
```
var ddb = new Client.DynamoDbClient(
new DynamoDbTablesEncryptionConfig { TableEncryptionConfigs = tableConfigs });
```
**Étape 6 : Chiffrer et signer un élément de table DynamoDB**
L'exemple suivant définit un `item` dictionnaire qui représente un exemple d'élément de table et place cet élément dans la table DynamoDB. L'élément est chiffré et signé côté client avant d'être envoyé à DynamoDB.
```
var item = new Dictionary
{
["partition_key"] = new AttributeValue("BasicPutGetExample"),
["sort_key"] = new AttributeValue { N = "0" },
["attribute1"] = new AttributeValue("encrypt and sign me!"),
["attribute2"] = new AttributeValue("sign me!"),
[":attribute3"] = new AttributeValue("ignore me!")
};
PutItemRequest putRequest = new PutItemRequest
{
TableName = ddbTableName,
Item = item
};
PutItemResponse putResponse = await ddb.PutItemAsync(putRequest);
```
## Utiliser le niveau inférieur `DynamoDbItemEncryptor`
L'exemple suivant montre comment utiliser le niveau inférieur `DynamoDbItemEncryptor` avec un [AWS KMS trousseau de clés](use-kms-keyring.md) pour chiffrer et signer directement des éléments de table. L'élément `DynamoDbItemEncryptor` n'est pas placé dans votre table DynamoDB.
Vous pouvez utiliser n'importe quel trousseau de [clés](keyrings.md) compatible avec le client DynamoDB amélioré, mais nous vous recommandons d'utiliser l'un des trousseaux de clés dans la mesure du AWS KMS possible.
**Note**
Le niveau inférieur `DynamoDbItemEncryptor` ne prend pas en charge le chiffrement [consultable](searchable-encryption.md). Utilisez le SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB afin d'utiliser le chiffrement consultable.
**Voir l'exemple de code complet** : [ItemEncryptDecryptExample.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/itemencryptor/ItemEncryptDecryptExample.cs)
**Étape 1 : Création du AWS KMS porte-clés**
L'exemple suivant permet de `CreateAwsKmsMrkMultiKeyring` créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. Le `CreateAwsKmsMrkMultiKeyring` procédé garantit que le trousseau de clés gère correctement les clés à région unique et à zones multiples.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Étape 2 : configurer les actions de vos attributs**
L'exemple suivant définit un `attributeActionsOnEncrypt` dictionnaire qui représente des exemples d'[actions attributaires](concepts.md#crypt-actions) pour un élément de table.
L'exemple suivant ne définit aucun attribut en tant que`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**Étape 3 : définir les attributs exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client suppose que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
String unsignAttrPrefix = ":";
```
**Étape 4 : Définition de la `DynamoDbItemEncryptor` configuration**
L'exemple suivant définit la configuration de`DynamoDbItemEncryptor`.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-net-using.md#net-logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-net-using.md#ddb-net-config-encrypt).
```
var config = new DynamoDbItemEncryptorConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix
};
```
**Étape 5 : Création du `DynamoDbItemEncryptor`**
L'exemple suivant en crée un nouveau à `DynamoDbItemEncryptor` l'aide de l'étape 4 `config` à partir de l'**étape 4**.
```
var itemEncryptor = new DynamoDbItemEncryptor(config);
```
**Étape 6 : Chiffrer et signer directement un élément du tableau**
L'exemple suivant chiffre et signe directement un élément à l'aide du`DynamoDbItemEncryptor`. L'élément `DynamoDbItemEncryptor` n'est pas placé dans votre table DynamoDB.
```
var originalItem = new Dictionary
{
["partition_key"] = new AttributeValue("ItemEncryptDecryptExample"),
["sort_key"] = new AttributeValue { N = "0" },
["attribute1"] = new AttributeValue("encrypt and sign me!"),
["attribute2"] = new AttributeValue("sign me!"),
[":attribute3"] = new AttributeValue("ignore me!")
};
var encryptedItem = itemEncryptor.EncryptItem(
new EncryptItemInput { PlaintextItem = originalItem }
).EncryptedItem;
```
# Configurer une table DynamoDB existante pour utiliser AWS le SDK de chiffrement de base de données pour DynamoDB
Avec la version 3. *x* de la bibliothèque de chiffrement côté client .NET pour DynamoDB, vous pouvez configurer vos tables Amazon DynamoDB existantes pour le chiffrement côté client. Cette rubrique fournit des conseils sur les trois étapes à suivre pour ajouter la version 3. *x* vers une table DynamoDB existante et renseignée.
## Étape 1 : Préparez-vous à lire et à écrire des éléments chiffrés
Procédez comme suit pour préparer votre client du SDK AWS Database Encryption à lire et à écrire des éléments chiffrés. Après avoir déployé les modifications suivantes, votre client continuera à lire et à écrire des éléments en texte brut. Il ne chiffrera ni ne signera aucun nouvel élément inscrit dans la table, mais il sera en mesure de déchiffrer les éléments chiffrés dès leur apparition. Ces modifications préparent le client à commencer à [chiffrer de nouveaux éléments](#ddb-net-add-step2). Les modifications suivantes doivent être déployées sur chaque lecteur avant de passer à l'étape suivante.
**1. Définissez vos [actions attributaires](concepts.md#crypt-actions)**
Créez un modèle d'objet pour définir les valeurs d'attribut qui seront cryptées et signées, celles qui seront uniquement signées et celles qui seront ignorées.
Par défaut, les attributs de clé primaire sont signés mais pas chiffrés (`SIGN_ONLY`) et tous les autres attributs sont chiffrés et signés (`ENCRYPT_AND_SIGN`).
Spécifiez `ENCRYPT_AND_SIGN` le chiffrement et la signature d'un attribut. Spécifiez `SIGN_ONLY` pour signer un attribut, mais pas pour le chiffrer. Spécifiez `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` à signer et à attribuer et à inclure dans le contexte de chiffrement. Vous ne pouvez pas chiffrer un attribut sans le signer également. Spécifiez `DO_NOTHING` si un attribut doit être ignoré. Pour de plus amples informations, veuillez consulter [Actions relatives aux attributs dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-net-using.md#ddb-net-attribute-actions).
Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**2. Définissez les attributs qui seront exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client supposera que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
const String unsignAttrPrefix = ":";
```
**3. Créez un [porte-clés](keyrings.md)**
L'exemple suivant crée un [AWS KMS trousseau de clés.](use-kms-keyring.md) Le AWS KMS trousseau de clés utilise le chiffrement symétrique ou le RSA asymétrique AWS KMS keys pour générer, chiffrer et déchiffrer les clés de données.
Cet exemple permet `CreateMrkMultiKeyring` de créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Définition de la configuration du chiffrement des tables DynamoDB **
L'exemple suivant définit une `tableConfigs` carte qui représente la configuration de chiffrement pour cette table DynamoDB.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-net-using.md#net-logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois.
Vous devez le spécifier `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` comme remplacement en texte brut. Cette politique continue de lire et d'écrire des éléments en texte brut, de lire des éléments chiffrés et de préparer le client à écrire des éléments chiffrés.
Pour plus d'informations sur les valeurs incluses dans la configuration du chiffrement des tables, consultez[Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix,
PlaintextOverride = FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT
};
tableConfigs.Add(ddbTableName, config);
```
**5. Création d'un nouveau client AWS DynamoDB SDK**
**L'exemple suivant crée un nouveau client DynamoDB AWS SDK à l'aide `TableEncryptionConfigs` de l'étape 4.**
```
var ddb = new Client.DynamoDbClient(
new DynamoDbTablesEncryptionConfig { TableEncryptionConfigs = tableConfigs });
```
## Étape 2 : Écrire des éléments chiffrés et signés
Mettez à jour la politique de texte brut dans votre configuration de chiffrement de table pour permettre au client d'écrire des éléments chiffrés et signés. Après avoir déployé la modification suivante, le client chiffre et signe les nouveaux éléments en fonction des actions d'attribut que vous avez configurées à l'**étape 1**. Le client pourra lire les éléments en texte brut et les éléments chiffrés et signés.
Avant de passer à l'[étape 3](#ddb-net-add-step3), vous devez chiffrer et signer tous les éléments en texte brut existants dans votre tableau. Il n'existe pas de métrique ou de requête unique que vous puissiez exécuter pour chiffrer rapidement vos éléments en texte brut existants. Utilisez le processus le mieux adapté à votre système. Par exemple, vous pouvez utiliser un processus asynchrone qui analyse lentement la table et réécrit les éléments à l'aide des actions attributaires et de la configuration de chiffrement que vous avez définies. Pour identifier les éléments en texte brut de votre tableau, nous vous recommandons de rechercher tous les éléments qui ne contiennent pas les `aws_dbe_foot` attributs `aws_dbe_head` et que le SDK de chiffrement de AWS base de données ajoute aux éléments lorsqu'ils sont chiffrés et signés.
L'exemple suivant met à jour la configuration de chiffrement des tables depuis **l'étape 1**. Vous devez mettre à jour le remplacement en texte brut avec. `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` Cette politique continue de lire les éléments en texte brut, mais également de lire et d'écrire des éléments chiffrés. Créez un nouveau client DynamoDB du AWS SDK à l'aide de la version mise à jour. `TableEncryptionConfigs`
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix,
PlaintextOverride = FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT
};
tableConfigs.Add(ddbTableName, config);
```
## Étape 3 : lire uniquement les éléments chiffrés et signés
Une fois que vous avez chiffré et signé tous vos éléments, mettez à jour la dérogation en texte brut dans votre configuration de chiffrement de table pour autoriser uniquement le client à lire et écrire des éléments chiffrés et signés. Après avoir déployé la modification suivante, le client chiffre et signe les nouveaux éléments en fonction des actions d'attribut que vous avez configurées à l'**étape 1**. Le client ne pourra lire que les éléments chiffrés et signés.
L'exemple suivant met à jour la configuration de chiffrement des tables depuis **l'étape 2**. Vous pouvez soit mettre à jour la règle de remplacement en texte brut, `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` soit la supprimer de votre configuration. Le client lit et écrit uniquement les éléments chiffrés et signés par défaut. Créez un nouveau client DynamoDB du AWS SDK à l'aide de la version mise à jour. `TableEncryptionConfigs`
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix,
// Optional: you can also remove the plaintext policy from your configuration
PlaintextOverride = FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT
};
tableConfigs.Add(ddbTableName, config);
```
# Rust
Cette rubrique explique comment installer et utiliser la version 1. *x* de la bibliothèque de chiffrement côté client Rust pour DynamoDB. Pour plus de détails sur la programmation avec le SDK AWS de chiffrement de base de données pour DynamoDB, consultez les exemples [Rust dans aws-database-encryption-sdk le référentiel -dynamodb](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/) sur. GitHub
Toutes les implémentations en langage de programmation du SDK de chiffrement de AWS base de données pour DynamoDB sont interopérables.
**Topics**
+ [Conditions préalables](#ddb-rust-prerequisites)
+ [Installation](#ddb-rust-install)
+ [Utilisation du client Rust](ddb-rust-using.md)
## Conditions préalables
Avant d'installer la bibliothèque de chiffrement côté client Rust pour DynamoDB, assurez-vous de remplir les conditions préalables suivantes.
**Installez Rust and Cargo**
Installez la version stable actuelle de [Rust](https://www.rust-lang.org/) en utilisant [rustup](https://rustup.rs/).
Pour plus d'informations sur le téléchargement et l'installation de rustup, consultez les [procédures d'installation dans The](https://doc.rust-lang.org/cargo/getting-started/installation.html) Cargo Book.
## Installation
La bibliothèque de chiffrement Rust côté client pour DynamoDB est disponible sous forme de caisse sur Crates.io. [aws-db-esdk](https://crates.io/crates/aws-db-esdk) Pour plus de détails sur l'installation et la création de la bibliothèque, consultez le fichier [README.md](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) dans le aws-database-encryption-sdk référentiel -dynamodb. GitHub
**Manuellement**
[Pour installer la bibliothèque de chiffrement côté client Rust pour DynamoDB, clonez ou téléchargez le référentiel -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
**Pour installer la dernière version**
Exécutez la commande Cargo suivante dans le répertoire de votre projet :
```
cargo add aws-db-esdk
```
Ou ajoutez la ligne suivante à votre Cargo.toml :
```
aws-db-esdk = ""
```
# Utilisation de la bibliothèque de chiffrement côté client Rust pour DynamoDB
Cette rubrique décrit certaines des fonctions et classes d'assistance de la version 1. *x* de la bibliothèque de chiffrement côté client Rust pour DynamoDB.
Pour plus de détails sur la programmation avec la bibliothèque de chiffrement côté client Rust pour DynamoDB, consultez les [exemples Rust](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/) dans le référentiel -dynamodb sur. aws-database-encryption-sdk GitHub
**Topics**
+ [Chiffreurs d'éléments](#ddb-rust-item-encryptors)
+ [Actions d'attribut](#ddb-rust-attribute-actions)
+ [Configuration du chiffrement](#ddb-rust-config-encrypt)
+ [Mettre à jour des éléments](#ddb-rust-update-items)
## Chiffreurs d'éléments
À la base, le SDK de chiffrement AWS de base de données pour DynamoDB est un outil de chiffrement d'éléments. Vous pouvez utiliser la version 1. *x* de la bibliothèque de chiffrement côté client Rust pour DynamoDB pour chiffrer, signer, vérifier et déchiffrer les éléments de votre table DynamoDB de la manière suivante.
**Le SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB**
Vous pouvez utiliser votre [configuration de chiffrement de table](#ddb-rust-config-encrypt) pour créer un client DynamoDB qui chiffre et signe automatiquement les éléments côté client avec vos requêtes DynamoDB. `PutItem`
[Vous devez utiliser le SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB afin d'utiliser le chiffrement consultable.](searchable-encryption.md)
Pour un exemple illustrant comment utiliser le SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB, consultez [basic\$1get\$1put\$1example.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/basic_get_put_example.rs) dans le référentiel -dynamodb sur. aws-database-encryption-sdk GitHub
**Le niveau inférieur `DynamoDbItemEncryptor`**
Le niveau inférieur chiffre, signe ou déchiffre et vérifie `DynamoDbItemEncryptor` directement les éléments de votre table sans appeler DynamoDB. Il n'émet pas de DynamoDB ni de `PutItem` requêtes`GetItem`. Par exemple, vous pouvez utiliser le niveau inférieur `DynamoDbItemEncryptor` pour déchiffrer et vérifier directement un élément DynamoDB que vous avez déjà récupéré.
Le niveau inférieur `DynamoDbItemEncryptor` ne prend pas en charge le chiffrement [consultable](searchable-encryption.md).
Pour un exemple illustrant comment utiliser le niveau inférieur`DynamoDbItemEncryptor`, consultez [item\$1encrypt\$1decrypt.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/itemencryptor/item_encrypt_decrypt.rs) dans le référentiel -dynamodb sur. aws-database-encryption-sdk GitHub
## Actions relatives aux attributs dans le SDK de chiffrement AWS de base de données pour DynamoDB
Les [actions d'](concepts.md#crypt-actions)attribut déterminent quelles valeurs d'attribut sont cryptées et signées, lesquelles sont uniquement signées, lesquelles sont signées et incluses dans le contexte de chiffrement, et lesquelles sont ignorées.
Pour spécifier des actions d'attribut avec le client Rust, définissez manuellement les actions d'attribut à l'aide d'un modèle d'objet. Spécifiez vos actions d'attribut en créant un `HashMap` objet dans lequel les paires nom-valeur représentent les noms d'attributs et les actions spécifiées.
Spécifiez `ENCRYPT_AND_SIGN` le chiffrement et la signature d'un attribut. Spécifiez `SIGN_ONLY` pour signer un attribut, mais pas pour le chiffrer. Spécifiez `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` de signer un attribut et de l'inclure dans le contexte de chiffrement. Vous ne pouvez pas chiffrer un attribut sans le signer également. Spécifiez `DO_NOTHING` si un attribut doit être ignoré.
Les attributs de partition et de tri doivent être l'un `SIGN_ONLY` ou l'autre`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous définissez des attributs comme`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Note**
Après avoir défini vos actions d'attribut, vous devez définir quels attributs sont exclus des signatures. Pour faciliter l'ajout de nouveaux attributs non signés à l'avenir, nous vous recommandons de choisir un préfixe distinct (tel que `:` « ») pour identifier vos attributs non signés. Incluez ce préfixe dans le nom d'attribut pour tous les attributs marqués lorsque vous `DO_NOTHING` définissez votre schéma DynamoDB et vos actions d'attribut.
Le modèle d'objet suivant montre comment spécifier`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, et `DO_NOTHING` attribuer des actions avec le client Rust. Cet exemple utilise le préfixe « `:` » pour identifier les `DO_NOTHING` attributs.
```
let attribute_actions_on_encrypt = HashMap::from([
("partition_key".to_string(), CryptoAction::SignOnly),
("sort_key".to_string(), CryptoAction::SignOnly),
("attribute1".to_string(), CryptoAction::EncryptAndSign),
("attribute2".to_string(), CryptoAction::SignOnly),
(":attribute3".to_string(), CryptoAction::DoNothing),
]);
```
## Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB
Lorsque vous utilisez le SDK AWS Database Encryption, vous devez définir explicitement une configuration de chiffrement pour votre table DynamoDB. Les valeurs requises dans votre configuration de chiffrement varient selon que vous avez défini vos actions attributaires manuellement ou à l'aide d'une classe de données annotée.
L'extrait suivant définit une configuration de chiffrement de table DynamoDB à l'aide du SDK de chiffrement de AWS base de données de bas niveau pour l'API DynamoDB et des attributs non signés autorisés définis par un préfixe distinct.
```
let table_config = DynamoDbTableEncryptionConfig::builder()
.logical_table_name(ddb_table_name)
.partition_key_name("partition_key")
.sort_key_name("sort_key")
.attribute_actions_on_encrypt(attribute_actions_on_encrypt)
.keyring(kms_keyring)
.allowed_unsigned_attribute_prefix(UNSIGNED_ATTR_PREFIX)
// Specifying an algorithm suite is optional
.algorithm_suite_id(
DbeAlgorithmSuiteId::AlgAes256GcmHkdfSha512CommitKeyEcdsaP384SymsigHmacSha384,
)
.build()?;
let table_configs = DynamoDbTablesEncryptionConfig::builder()
.table_encryption_configs(HashMap::from([(ddb_table_name.to_string(), table_config)]))
.build()?;
```
**Nom de table logique**
Nom de table logique pour votre table DynamoDB.
Le nom de table logique est lié de manière cryptographique à toutes les données stockées dans la table afin de simplifier les opérations de restauration DynamoDB. Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Vous devez toujours spécifier le même nom de table logique. Pour que le déchiffrement réussisse, le nom de la table logique doit correspondre au nom spécifié lors du chiffrement. Si le nom de votre table DynamoDB change après la [restauration de votre table DynamoDB à partir d'une sauvegarde, le nom logique de la table garantit que l'opération de déchiffrement](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) reconnaît toujours la table.
**Attributs non signés autorisés**
Les attributs marqués `DO_NOTHING` dans vos actions d'attributs.
Les attributs non signés autorisés indiquent au client quels attributs sont exclus des signatures. Le client suppose que tous les autres attributs sont inclus dans la signature. Ensuite, lors du déchiffrement d'un enregistrement, le client détermine les attributs qu'il doit vérifier et ceux à ignorer parmi les attributs non signés autorisés que vous avez spécifiés. Vous ne pouvez pas supprimer un attribut de vos attributs non signés autorisés.
Vous pouvez définir explicitement les attributs non signés autorisés en créant un tableau répertoriant tous vos `DO_NOTHING` attributs. Vous pouvez également spécifier un préfixe distinct lorsque vous nommez vos `DO_NOTHING` attributs et utiliser le préfixe pour indiquer au client quels attributs ne sont pas signés. Nous vous recommandons vivement de spécifier un préfixe distinct, car cela simplifie le processus d'ajout d'un nouvel `DO_NOTHING` attribut à l'avenir. Pour de plus amples informations, veuillez consulter [Mettre à jour votre modèle de données](ddb-update-data-model.md).
Si vous ne spécifiez pas de préfixe pour tous les `DO_NOTHING` attributs, vous pouvez configurer un `allowedUnsignedAttributes` tableau répertoriant explicitement tous les attributs que le client doit s'attendre à voir non signés lorsqu'il les rencontre lors du déchiffrement. Vous ne devez définir explicitement vos attributs non signés autorisés que si cela est absolument nécessaire.
**Configuration de la recherche (facultatif)**
`SearchConfig`Définit la [version de la balise](using-beacons.md#beacon-version).
Le `SearchConfig` doit être spécifié pour utiliser un [chiffrement consultable](searchable-encryption.md) ou des [balises signées](configure.md#signed-beacons).
**Suite d'algorithmes (facultatif)**
`algorithmSuiteId`Définit la suite d'algorithmes utilisée par le SDK AWS de chiffrement de base de données.
À moins que vous ne spécifiiez explicitement une suite d'algorithmes alternative, le SDK AWS de chiffrement de base de données utilise la [suite d'algorithmes par défaut](supported-algorithms.md#recommended-algorithms). [La suite d'algorithmes par défaut utilise l'algorithme AES-GCM avec dérivation de clés, [signatures numériques et engagement](concepts.md#digital-sigs) de clés.](concepts.md#key-commitment) Bien que la suite d'algorithmes par défaut soit susceptible de convenir à la plupart des applications, vous pouvez choisir une autre suite d'algorithmes. Par exemple, certains modèles de confiance seraient satisfaits par une suite d'algorithmes sans signature numérique. Pour plus d'informations sur les suites d'algorithmes prises en charge par le SDK AWS de chiffrement de base de données, consultez[Suites d'algorithmes prises en charge dans le SDK AWS de chiffrement de base de données](supported-algorithms.md).
Pour sélectionner la [suite d'algorithmes AES-GCM sans signature numérique ECDSA](supported-algorithms.md#other-algorithms), incluez l'extrait suivant dans votre configuration de chiffrement de table.
```
.algorithm_suite_id(
DbeAlgorithmSuiteId::AlgAes256GcmHkdfSha512CommitKeyEcdsaP384SymsigHmacSha384,
)
```
## Mise à jour d'éléments avec le SDK AWS de chiffrement de base de données
Le SDK AWS de chiffrement de base de données ne prend pas en charge [ddb : UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) pour les éléments qui incluent des attributs chiffrés ou signés. Pour mettre à jour un attribut chiffré ou signé, vous devez utiliser [ddb : PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html). Lorsque vous spécifiez la même clé primaire qu'un élément existant dans votre `PutItem` demande, le nouvel élément remplace complètement l'élément existant.
# Ancien client de chiffrement DynamoDB
Le 9 juin 2023, notre bibliothèque de chiffrement côté client a été renommée AWS Database Encryption SDK. Le SDK AWS de chiffrement de base de données continue de prendre en charge les anciennes versions du client de chiffrement DynamoDB. Pour plus d'informations sur les différentes parties de la bibliothèque de chiffrement côté client qui ont changé avec le changement de nom, consultez. [Changement du nom du client de chiffrement Amazon DynamoDB](DDBEC-rename.md)
Pour migrer vers la dernière version de la bibliothèque de chiffrement côté client Java pour DynamoDB, consultez. [Migrer vers la version 3.x](ddb-java-migrate.md)
**Topics**
+ [AWS SDK de chiffrement de base de données pour la prise en charge des versions DynamoDB](#legacy-support)
+ [Fonctionnement du client de chiffrement DynamoDB](DDBEC-legacy-how-it-works.md)
+ [Concepts du client de chiffrement Amazon DynamoDB](DDBEC-legacy-concepts.md)
+ [Fournisseur de matériel cryptographique](crypto-materials-providers.md)
+ [Langages de programmation disponibles pour le client de chiffrement Amazon DynamoDB](programming-languages.md)
+ [Modification de votre modèle de données](data-model.md)
+ [Résolution des problèmes liés à votre application cliente de chiffrement DynamoDB](troubleshooting.md)
## AWS SDK de chiffrement de base de données pour la prise en charge des versions DynamoDB
Les rubriques du chapitre Legacy fournissent des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python.
Le tableau suivant répertorie les langues et les versions qui prennent en charge le chiffrement côté client dans Amazon DynamoDB.
| Langage de programmation | Version | Phase du cycle de vie de la version majeure du SDK |
| --- | --- | --- |
| Java | Versions 1. *x* | [End-of-Support phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), en vigueur en juillet 2022 |
| Java | Versions 2. *x* | [Disponibilité générale](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
| Java | Version 3. *x* | [Disponibilité générale](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
| Python | Versions 1. *x* | [End-of-Support phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), en vigueur en juillet 2022 |
| Python | Versions 2. *x* | [End-of-Support phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), en vigueur en juillet 2022 |
| Python | Versions 3. *x* | [Disponibilité générale](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
# Fonctionnement du client de chiffrement DynamoDB
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Le client de chiffrement DynamoDB est spécialement conçu pour protéger les données que vous stockez dans DynamoDB. Les bibliothèques incluent les implémentations sécurisées que vous pouvez étendre ou utiliser inchangées. Et, la plupart des éléments sont représentés par des éléments abstraits afin que vous puissiez créer et utiliser des composants personnalisés compatibles.
**Chiffrement et signature des éléments de table**
Au cœur du client de chiffrement DynamoDB se trouve *un outil de chiffrement d'éléments* qui chiffre, signe, vérifie et déchiffre les éléments de table. Il prend les informations sur les éléments de table et les instructions sur les éléments à chiffrer et signer. Il obtient les matériaux de chiffrement et les instructions sur leur utilisation auprès d'un [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) que vous sélectionnez et configurez.
Le schéma suivant illustre un aperçu de haut niveau du processus.
![\[Chiffrement et signature d'éléments dans le client de chiffrement DynamoDB\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/arch-encrypt.png)
Pour chiffrer et signer un élément de table, le client de chiffrement DynamoDB a besoin des éléments suivants :
+ **Informations sur le tableau.** Il obtient des informations sur la table à partir d'un contexte de [chiffrement DynamoDB](concepts.md#encryption-context) que vous fournissez. Certains assistants obtiennent les informations requises auprès de DynamoDB et créent le contexte de chiffrement DynamoDB pour vous.
**Note**
Le *contexte de chiffrement DynamoDB dans le client de chiffrement* DynamoDB n'est pas lié au contexte de chiffrement dans () et *le*. AWS Key Management Service AWS KMS AWS Encryption SDK
+ **Attributs à chiffrer et signer.** Il obtient ces informations à partir des [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) que vous fournissez.
+ **Matériaux de chiffrement, clés de chiffrement et de signature incluses.** Il obtient ces informations auprès d'un [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) que vous sélectionnez et configurez.
+ **Instructions pour le chiffrement et la signature de l'élément**. Le fournisseur CMP ajoute les instructions sur l'utilisation des matériaux de chiffrement, algorithmes de chiffrement et de signature inclus, à la [description du matériau réel](DDBEC-legacy-concepts.md#legacy-material-description).
Le [chiffreur d'élément](DDBEC-legacy-concepts.md#item-encryptor) utilise tous ces éléments pour chiffrer et signer l'élément. Le chiffreur d'élément ajoute aussi deux attributs à l'élément : un [attribut de description de matériau](DDBEC-legacy-concepts.md#legacy-material-description) qui contient les instructions de chiffrement et de signature (description du matériau réel), et un attribut qui contient la signature. Vous pouvez interagir directement avec le chiffreur d'élément, ou utilisez les fonctions d'annotation qui interagissent avec le chiffreur d'élément pour que vous implémentiez le comportement par défaut sécurisé.
Il en résulte un élément DynamoDB contenant les données chiffrées et signées.
**Vérification et déchiffrement des éléments de table**
Ces composants fonctionnent aussi ensemble pour vérifier et déchiffrer votre élément, comme illustré dans le schéma suivant.
![\[Vérification et déchiffrement d'éléments dans le client de chiffrement DynamoDB\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/arch-decrypt.png)
Pour vérifier et déchiffrer un élément, le client de chiffrement DynamoDB a besoin des mêmes composants, de composants présentant la même configuration ou de composants spécialement conçus pour déchiffrer les éléments, comme suit :
+ **Informations relatives à la table** issues du contexte de [chiffrement DynamoDB](concepts.md#encryption-context).
+ **Attributs à vérifier et à déchiffrer.** Il obtient ces informations à partir des [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions).
+ **Matériaux de déchiffrement, clés de vérification et de déchiffrement incluses**, depuis le [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) que vous sélectionnez et configurez.
L'élément chiffré n'inclut pas d'enregistrement du CMP qui a été utilisé pour le chiffrer. Vous devez fournir le même CMP, un CMP avec la même configuration ou un CMP qui a été conçu pour déchiffrer les éléments.
+ **Informations sur la façon dont l'élément a été chiffré et signé**, algorithmes de chiffrement et de signature inclus. Le client obtient ces informations à partir de l'[attribut de description du matériau](DDBEC-legacy-concepts.md#legacy-material-description) de l'élément.
Le [chiffreur d'élément](DDBEC-legacy-concepts.md#item-encryptor) utilise tous ces éléments pour vérifier et déchiffrer l'élément. Il supprime aussi les attribut de description de matériau et de signature. Le résultat est un élément DynamoDB en texte brut.
# Concepts du client de chiffrement Amazon DynamoDB
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Cette rubrique explique les concepts et la terminologie utilisés dans le client de chiffrement Amazon DynamoDB.
Pour savoir comment les composants du client de chiffrement DynamoDB interagissent, consultez. [Fonctionnement du client de chiffrement DynamoDB](DDBEC-legacy-how-it-works.md)
**Topics**
+ [Fournisseur CMP (Cryptographic Materials Provider)](#concept-material-provider)
+ [Chiffreurs d'éléments](#item-encryptor)
+ [Actions d'attribut](#legacy-attribute-actions)
+ [Description du matériau](#legacy-material-description)
+ [Client de chiffrement DynamoDB](#legacy-encryption-context)
+ [Magasin de fournisseur](#provider-store)
## Fournisseur CMP (Cryptographic Materials Provider)
*Lorsque vous implémentez le client de chiffrement DynamoDB, l'une de vos premières tâches consiste [à sélectionner un fournisseur de matériel cryptographique](crypto-materials-providers.md) (CMP) (également appelé fournisseur de matériel de chiffrement).* Votre choix détermine une grande part du reste de l'implémentation.
Un *fournisseur CMP* recueille, assemble et retourne les matériaux de chiffrement que le [chiffreur d'élément](#item-encryptor) utilise pour chiffrer et signer vos éléments de table. Le CMP détermine les algorithmes de chiffrement à utiliser, ainsi que la façon de générer et de protéger le chiffrement et les clés de signature.
Le fournisseur CMP interagit avec le chiffreur d'élément. Celui-ci demande les matériaux de chiffrement ou de déchiffrement au CMP, et le CMP les retourne au chiffreur d'élément. Puis, celui-ci utilise les matériaux de chiffrement pour chiffrer et signer, ou vérifier et déchiffrer, l'élément.
Vous spécifiez le CMP lorsque vous configurez le client. Vous pouvez créer un CMP personnalisé compatible ou utiliser l'un des nombreux modèles de CMPs la bibliothèque. La plupart CMPs sont disponibles pour plusieurs langages de programmation.
## Chiffreurs d'éléments
Le *chiffreur d'éléments est* un composant de niveau inférieur qui effectue des opérations de chiffrement pour le client de chiffrement DynamoDB. Il demande les matériaux de chiffrement auprès d'un [fournisseur CMP](#concept-material-provider), puis utilise les matériaux retournés par le CMP pour chiffrer et signer, ou vérifier et déchiffrer, votre élément de table.
Vous pouvez interagir directement avec le chiffreur d'élément ou utiliser les annotations fournis par votre bibliothèque. Par exemple, le client de chiffrement DynamoDB pour Java inclut `AttributeEncryptor` une classe d'assistance que vous pouvez utiliser avec `DynamoDBMapper` le chiffreur d'éléments, au lieu d'interagir directement avec celui-ci. `DynamoDBEncryptor` La bibliothèque Python inclut les classes d'annotations `EncryptedTable`, `EncryptedClient` et `EncryptedResource` qui interagissent avec le chiffreur d'éléments pour vous.
## Actions d'attribut
Les *actions d'attribut* informent le chiffreur d'élément des actions à exécuter sur chaque attribut de l'élément.
L'action d'attribut peut avoir l'une des valeurs suivantes :
+ **Chiffrer et signer** — Chiffrez la valeur de l'attribut. Incluez l'attribut (nom et valeur) dans la signature de l'élément.
+ **Signe uniquement** — Incluez l'attribut dans la signature de l'article.
+ **Ne rien faire** : ne chiffrez ni ne signez l'attribut.
Pour tout attribut pouvant stocker des données sensibles, utilisez **Chiffrer et signer**. Pour les attributs de clé primaire (clé de partition et clé de tri), utilisez **Signer uniquement**. L'[attribut de description de matériau](#legacy-material-description) et l'attribut de signature ne sont pas signés ou chiffrés. Vous n'avez pas besoin de spécifier les actions d'attribut pour ces attributs.
Choisissez soigneusement vos actions d'attribut. En cas de doute, utilisez **Chiffrer et signer**. Une fois que vous avez utilisé le client de chiffrement DynamoDB pour protéger les éléments de votre table, vous ne pouvez pas modifier l'action d'un attribut sans risquer une erreur de validation de signature. Pour en savoir plus, consultez [Modification de votre modèle de données](data-model.md).
**Avertissement**
Ne chiffrez pas les attributs de la clé primaire. Ils doivent rester en texte brut pour que DynamoDB puisse trouver l'élément sans exécuter une analyse complète du tableau.
Si le contexte de [chiffrement DynamoDB](concepts.md#encryption-context) identifie les attributs de votre clé primaire, le client génère une erreur si vous essayez de les chiffrer.
La technique que vous utilisez pour spécifier les actions d'attribut dépend du langage de programmation que vous utilisez. Elle peut aussi être spécifique aux classes d'annotations que vous utilisez.
Pour plus d'informations, consultez la documentation de votre langage de programmation.
+ [Python](python-using.md#python-attribute-actions)
+ [Java](java-using.md#attribute-actions-java)
## Description du matériau
La *description du matériau* pour un élément de table chiffré se compose d'informations, telles que les algorithmes de chiffrement, sur la façon dont l'élément de table est chiffré et signé. Le [fournisseur CMP](#concept-material-provider) enregistre la description du matériau tandis qu'il rassemble les matériaux de chiffrement pour le chiffrement et la signature. Par la suite, quand il doit rassembler les matériaux de chiffrement pour vérifier et chiffrer l'élément, il utilise la description du matériau comme guide.
Dans le client de chiffrement DynamoDB, la description matérielle fait référence à trois éléments connexes :
**Description du matériau demandé**
Certains [fournisseurs de matériel cryptographique](#concept-material-provider) (CMPs) vous permettent de définir des options avancées, telles qu'un algorithme de chiffrement. Pour indiquer vos choix, vous ajoutez des paires nom-valeur à la propriété de description matérielle du [contexte de chiffrement DynamoDB dans votre demande de chiffrement](concepts.md#encryption-context) d'un élément de table. L'élément est appelé *description du matériau demandé*. Les valeurs autorisées pour la description du matériau demandé sont définies par le fournisseur CMP que vous choisissez.
Comme la description du matériau peut remplacer les valeurs par défaut sécurisées, il est recommandé d'omettre la description du matériau demandé à moins que vous n'ayez une excellente raison de l'utiliser.
**Description du matériau réel**
La description matérielle renvoyée par les [fournisseurs de matériel cryptographique](#concept-material-provider) (CMPs) est connue sous le nom de *description matérielle réelle*. Elle décrit les valeurs réelles que le CMP a utilisées quand il a rassemblé les matériaux de chiffrement. Elle se compose généralement de la description du matériau demandé, le cas échéant, avec les ajouts et les modifications.
**Attribut de description du matériau**
Le client enregistre la description du matériau réel dans l'*attribut de description du matériau* de l'élément chiffré. Le nom de l'attribut de description du matériau est `amzn-ddb-map-desc` et sa valeur est la description du matériau réel. Le client utilise les valeurs de l'attribut de description du matériau pour vérifier et déchiffrer l'élément.
## Client de chiffrement DynamoDB
Le contexte de *chiffrement DynamoDB* fournit des informations sur la table et l'élément au fournisseur de [matériel cryptographique](#concept-material-provider) (CMP). [Dans les implémentations avancées, le contexte de chiffrement DynamoDB peut inclure une description matérielle demandée.](#legacy-material-description)
Lorsque vous chiffrez des éléments de table, le contexte de chiffrement DynamoDB est lié cryptographiquement aux valeurs d'attributs chiffrées. Lorsque vous déchiffrez, si le contexte de chiffrement DynamoDB ne correspond pas exactement, en distinguant majuscules et minuscules, au contexte de chiffrement DynamoDB utilisé pour le chiffrement, l'opération de déchiffrement échoue. Si vous interagissez directement avec le [chiffreur d'éléments, vous devez fournir un contexte de chiffrement DynamoDB lorsque vous appelez une méthode de chiffrement ou](#item-encryptor) de déchiffrement. La plupart des assistants créent le contexte de chiffrement DynamoDB pour vous.
**Note**
Le *contexte de chiffrement DynamoDB dans le client de chiffrement* DynamoDB n'est pas lié au contexte de chiffrement dans () et *le*. AWS Key Management Service AWS KMS AWS Encryption SDK
Le contexte de chiffrement DynamoDB peut inclure les champs suivants. Tous les champs et valeurs sont facultatifs.
+ Nom de la table
+ Nom de la clé de partition
+ Nom de la clé de tri
+ Paires nom-valeur des attributs
+ [Description du matériau demandé](#legacy-material-description)
## Magasin de fournisseur
Une *boutique de fournisseurs* est un composant qui renvoie des [fournisseurs de matériel cryptographique](#concept-material-provider) (CMPs). Le magasin du fournisseur peut les créer CMPs ou les obtenir à partir d'une autre source, telle qu'un autre magasin du fournisseur. Le magasin du fournisseur enregistre les versions CMPs qu'il crée dans un stockage persistant dans lequel chaque CMP stocké est identifié par le nom matériel du demandeur et le numéro de version.
Le [fournisseur le plus récent](most-recent-provider.md) du client de chiffrement DynamoDB l'obtient CMPs auprès d'un magasin du fournisseur, mais vous pouvez utiliser le magasin du fournisseur pour CMPs approvisionner n'importe quel composant. Chaque fournisseur le plus récent est associé à une boutique de fournisseurs, mais une boutique de fournisseurs peut fournir des CMPs informations à de nombreux demandeurs sur plusieurs hôtes.
Le magasin du fournisseur crée de nouvelles versions CMPs de On Demand et renvoie les versions nouvelles et existantes. Il retourne aussi le dernier numéro de version d'un nom de matériau donné. Le demandeur peut ainsi savoir lorsque le magasin de fournisseur a une nouvelle version de son fournisseur, puis la demander.
Le client de chiffrement DynamoDB inclut [ MetaStore](most-recent-provider.md#about-metastore)un magasin fournisseur qui crée des clés CMPs Wrapped qui sont stockées dans DynamoDB et chiffrées à l'aide d'un client de chiffrement DynamoDB interne.
**En savoir plus :**
+ Magasin de fournisseur : [Java](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/store/ProviderStore.html), [Python](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/src/dynamodb_encryption_sdk/material_providers/store/__init__.py)
+ MetaStore: [Java](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/store/MetaStore.html), [Python](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/materials_providers/metastore.html#module-dynamodb_encryption_sdk.material_providers.store.meta)
# Fournisseur de matériel cryptographique
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
L'une des décisions les plus importantes que vous prenez lorsque vous utilisez le client de chiffrement DynamoDB est de sélectionner [un fournisseur de matériel cryptographique](DDBEC-legacy-concepts.md#concept-material-provider) (CMP). Le fournisseur CMP assemble et retourne les matériaux de déchiffrement au chiffreur d'élément. Il détermine aussi la façon dont les clés de chiffrement et les clés de signature sont générées, que les nouveaux matériaux de clés soient générés pour chaque élément ou soient réutilisés, et les algorithmes de chiffrement et de signature qui sont utilisés.
Vous pouvez choisir un CMP parmi les implémentations fournies dans les bibliothèques du client de chiffrement DynamoDB ou créer un CMP personnalisé compatible. Le choix du fournisseur CMP peut aussi dépendre du [langage de programmation](programming-languages.md) que vous utilisez.
Cette rubrique décrit les plus courantes CMPs et propose quelques conseils pour vous aider à choisir celle qui convient le mieux à votre application.
**Fournisseur de matériaux KMS direct**
Le fournisseur de matériel KMS direct protège les articles de votre table sous un format [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)qui ne laisse jamais [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) non chiffré. Votre application n'a pas à générer ou gérer des matériaux de chiffrement. Comme il utilise le AWS KMS key pour générer des clés de chiffrement et de signature uniques pour chaque élément, ce fournisseur appelle AWS KMS chaque fois qu'il chiffre ou déchiffre un élément.
Si vous utilisez AWS KMS et qu'un AWS KMS appel par transaction est pratique pour votre application, ce fournisseur est un bon choix.
Pour en savoir plus, consultez [Fournisseur de matériaux KMS direct](direct-kms-provider.md).
**Fournisseur CMP encapsulé**
Le Wrapped Materials Provider (Wrapped CMP) vous permet de générer et de gérer vos clés d'encapsulation et de signature en dehors du client de chiffrement DynamoDB.
Le fournisseur CMP encapsulé génère une clé de chiffrement unique pour chaque élément. Puis, il utilise les clés d'encapsulation (ou de désencapsulation) et de signature que vous fournissez. En tant que tel, vous déterminez de quelle façon les clés d'encapsulation et de signature sont générées, et si elles sont propres à chaque élément ou sont réutilisées. Le Wrapped CMP est une alternative sécurisée au [fournisseur Direct KMS](direct-kms-provider.md) pour les applications qui n'utilisent pas de matériel cryptographique AWS KMS et qui peuvent le gérer en toute sécurité.
Pour en savoir plus, consultez [Fournisseur de matériaux encapsulé](wrapped-provider.md).
**À propos du fournisseur le plus récent**
Le *fournisseur le plus récent* est un [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) conçu pour travailler avec un [magasin de fournisseur](DDBEC-legacy-concepts.md#provider-store). Il CMPs provient du magasin du fournisseur et obtient le matériel cryptographique qu'il renvoie depuis le CMPs. Le fournisseur le plus récent utilise généralement chaque fournisseur CMP pour satisfaire plusieurs demandes de matériaux de chiffrement, mais vous pouvez utiliser les fonctions du magasin de fournisseur pour contrôler l'étendue à laquelle les matériaux sont réutilisés, déterminer à quelle fréquence a lieu la rotation des fournisseurs CMP et, même, modifier le type de fournisseur CMP utilisé sans modifier le fournisseur le plus récent.
Vous pouvez utiliser le fournisseur le plus récent avec n'importe quel magasin de fournisseur compatible. Le client de chiffrement DynamoDB inclut MetaStore un, qui est un magasin fournisseur qui renvoie Wrapped. CMPs
Le fournisseur le plus récent constitue un bon choix pour les applications qui doivent minimiser les appels à leur source de chiffrement, et pour les applications qui peuvent réutiliser certains matériaux de chiffrement sans enfreindre leurs exigences de sécurité. Par exemple, il vous permet de protéger votre matériel cryptographique avec un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) sans avoir à appeler AWS KMS chaque fois que vous chiffrez ou déchiffrez un élément.
Pour en savoir plus, consultez [À propos du fournisseur le plus récent](most-recent-provider.md).
**Fournisseur de matériaux statique**
Le fournisseur de matériaux statiques est conçu pour les tests, les proof-of-concept démonstrations et la compatibilité existante. Il ne génère pas de matériaux de chiffrement uniques pour chaque élément. Il retourne les mêmes clés de chiffrement et de signature que vous fournissez, et ces clés sont utilisées directement pour chiffrer, déchiffrer et signer vos éléments de table.
Le [fournisseur statique asymétrique](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/AsymmetricStaticProvider.html) de la bibliothèque Java n'est pas un fournisseur statique. Il fournit juste d'autres constructeurs au [fournisseur CMP encapsulé](wrapped-provider.md). Il est sûr pour une utilisation en production, mais vous devez utiliser directement le CMP encapsulé chaque fois que possible.
**Topics**
+ [Fournisseur de matériaux KMS direct](direct-kms-provider.md)
+ [Fournisseur de matériaux encapsulé](wrapped-provider.md)
+ [À propos du fournisseur le plus récent](most-recent-provider.md)
+ [Fournisseur de matériaux statique](static-provider.md)
# Fournisseur de matériaux KMS direct
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Le fournisseur de *matériel Direct KMS (fournisseur* direct KMS) protège les éléments de votre table sous un format [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)qui ne laisse jamais [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) non chiffré. Le [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) retourne une clé de chiffrement et une clé de signature uniques pour chaque élément de table. Pour ce faire, il appelle AWS KMS chaque fois que vous chiffrez ou déchiffrez un élément.
Si vous traitez des éléments DynamoDB à une fréquence élevée et à grande échelle, vous risquez de dépasser les limites, ce qui entraîne des AWS KMS [requests-per-secondretards](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second) de traitement. Si vous devez dépasser une limite, créez un dossier dans le [AWS Support Centre](https://console.aws.amazon.com/support/home). Vous pouvez également envisager de faire appel à un fournisseur de matériel cryptographique avec une réutilisation limitée des clés, tel que le [fournisseur le plus récent](most-recent-provider.md).
Pour utiliser le fournisseur Direct KMS, l'appelant doit avoir, au moins [un Compte AWS](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) AWS KMS key, et l'autorisation d'appeler les opérations [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)et de [déchiffrer](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) sur le. AWS KMS key AWS KMS key Il doit s'agir d'une clé de chiffrement symétrique ; le client de chiffrement DynamoDB ne prend pas en charge le chiffrement asymétrique. [Si vous utilisez une table [globale DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html), vous souhaiterez peut-être spécifier AWS KMS une clé multirégionale.](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) Pour en savoir plus, consultez [Comment l'utiliser](#provider-kms-how-to-use).
**Note**
Lorsque vous utilisez le fournisseur Direct KMS, les noms et les valeurs de vos attributs de clé primaire apparaissent en texte clair dans le [contexte de AWS KMS chiffrement](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) et dans AWS CloudTrail les journaux des AWS KMS opérations associées. Toutefois, le client de chiffrement DynamoDB n'expose jamais le texte en clair des valeurs d'attributs chiffrées.
Le fournisseur Direct KMS est l'un des nombreux [fournisseurs de matériel cryptographique](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs) pris en charge par le client de chiffrement DynamoDB. Pour plus d'informations sur l'autre CMPs, voir[Fournisseur de matériel cryptographique](crypto-materials-providers.md).
**Pour obtenir un exemple de code, consultez :**
+ Java: [AwsKmsEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)
+ Python : [aws-kms-encrypted-table](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py), [aws-kms-encrypted-item](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_item.py)
**Topics**
+ [Comment l'utiliser](#provider-kms-how-to-use)
+ [Comment ça marche](#provider-kms-how-it-works)
## Comment l'utiliser
Pour créer un fournisseur KMS direct, utilisez le paramètre Key ID pour spécifier une [clé KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) de chiffrement symétrique dans votre compte. La valeur du paramètre Key ID peut être l'ID de clé, l'ARN de clé, le nom d'alias ou l'ARN d'alias du AWS KMS key. Pour plus de détails sur les identificateurs de clé, 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*.
Le fournisseur Direct KMS nécessite une clé KMS de chiffrement symétrique. Vous ne pouvez pas utiliser de clé KMS asymétrique. Toutefois, vous pouvez utiliser une clé KMS multirégionale, une clé KMS contenant des éléments clés importés ou une clé KMS dans un magasin de clés personnalisé. Vous devez disposer des autorisations [kms : GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) et [KMS:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) sur la clé KMS. Vous devez donc utiliser une clé gérée par le client, et non une clé KMS AWS gérée ou AWS détenue.
Le client de chiffrement DynamoDB pour Python détermine la région à AWS KMS appeler depuis la région dans la valeur du paramètre ID clé, s'il en inclut une. Sinon, il utilise la région du AWS KMS client, si vous en spécifiez une, ou la région que vous configurez dans le AWS SDK pour Python (Boto3). Pour plus d'informations sur la sélection de régions en Python, consultez [Configuration](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html) dans le manuel de AWS référence de l'API SDK for Python (Boto3).
Le client de chiffrement DynamoDB pour Java détermine la région à AWS KMS appeler depuis la région du client, si AWS KMS le client que vous spécifiez inclut une région. Dans le cas contraire, il utilise la région que vous configurez dans le AWS SDK pour Java. Pour plus d'informations sur la sélection des régions dans le AWS SDK pour Java, voir [Région AWS sélection](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-region-selection.html) dans le guide du AWS SDK pour Java développeur.
------
#### [ Java ]
```
// Replace the example key ARN and Region with valid values for your application
final String keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
final String region = 'us-west-2'
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
------
#### [ Python ]
L'exemple suivant utilise la clé ARN pour spécifier le AWS KMS key. Si votre identifiant de clé n'inclut pas de Région AWS, le client de chiffrement DynamoDB obtient la région à partir de la session Botocore configurée, s'il en existe une, ou à partir des paramètres par défaut de Boto.
```
# Replace the example key ID with a valid value
kms_key = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key)
```
------
Si vous utilisez des tables [globales Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html), nous vous recommandons de chiffrer vos données sous une clé multirégionale. AWS KMS Les clés multirégionales sont AWS KMS keys différentes Régions AWS et peuvent être utilisées de manière interchangeable car elles ont le même identifiant de clé et le même matériau de clé. Pour plus de détails, consultez la section [Utilisation de clés multirégionales](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) dans le *Guide du AWS Key Management Service développeur*.
**Note**
Si vous utilisez la [version 2017.11.29](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html) des tables globales, vous devez définir des actions attributaires afin que les champs de réplication réservés ne soient ni chiffrés ni signés. Pour en savoir plus, consultez [Problèmes liés aux anciennes versions des tables globales](troubleshooting.md#fix-global-tables).
Pour utiliser une clé multirégionale avec le client de chiffrement DynamoDB, créez une clé multirégionale et répliquez-la dans les régions dans lesquelles votre application s'exécute. Configurez ensuite le fournisseur Direct KMS pour utiliser la clé multirégionale dans la région dans laquelle le client de chiffrement DynamoDB appelle. AWS KMS
L'exemple suivant configure le client de chiffrement DynamoDB pour chiffrer les données dans la région USA Est (Virginie du Nord) (us-east-1) et les déchiffrer dans la région USA Ouest (Oregon) (us-west-2) à l'aide d'une clé multirégionale.
------
#### [ Java ]
Dans cet exemple, le client de chiffrement DynamoDB obtient la région à AWS KMS appeler depuis la région du client. AWS KMS La `keyArn` valeur identifie une clé multirégionale dans la même région.
```
// Encrypt in us-east-1
// Replace the example key ARN and Region with valid values for your application
final String usEastKey = 'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
final String region = 'us-east-1'
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, usEastKey);
```
```
// Decrypt in us-west-2
// Replace the example key ARN and Region with valid values for your application
final String usWestKey = 'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
final String region = 'us-west-2'
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, usWestKey);
```
------
#### [ Python ]
Dans cet exemple, le client de chiffrement DynamoDB obtient la région à AWS KMS appeler depuis la région dans l'ARN de la clé.
```
# Encrypt in us-east-1
# Replace the example key ID with a valid value
us_east_key = 'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=us_east_key)
```
```
# Decrypt in us-west-2
# Replace the example key ID with a valid value
us_west_key = 'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=us_west_key)
```
------
## Comment ça marche
Le fournisseur Direct KMS renvoie des clés de chiffrement et de signature protégées par un AWS KMS key code que vous spécifiez, comme indiqué dans le schéma suivant.
![\[Entrée, traitement et sortie du fournisseur KMS direct dans le client de chiffrement DynamoDB\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/directKMS.png)
+ Pour générer du matériel de chiffrement, le fournisseur Direct KMS demande de AWS KMS [générer une clé de données unique](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) pour chaque élément à l'aide d'une clé AWS KMS key que vous spécifiez. Il dérive les clés de chiffrement et de signature de l'élément depuis la copie en texte brut de la [clé de données](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys), puis retourne les clés de chiffrement et de signature, ainsi que la clé des données chiffrées, qui est stockée dans l'[attribut de description de matériau](DDBEC-legacy-concepts.md#legacy-material-description) de l'élément.
Le chiffreur d'élément utilise les clés de chiffrement et de signature, et les supprime de la mémoire dès que possible. Seule la copie chiffrée de la clé de données à partir de laquelle elles ont été dérivées est enregistrée dans l'élément chiffré.
+ Pour générer du matériel de déchiffrement, le fournisseur KMS direct demande de AWS KMS déchiffrer la clé de données chiffrée. Puis, il dérive les clés de vérification et de signature de la clé de données en texte brut, et les retourne au chiffreur d'élément.
Le chiffreur d'élément vérifie l'élément et, si la vérification aboutit, déchiffre les valeurs chiffrées. Puis, il supprime les clés de la mémoire dès que possible.
### Obtention des matériaux de chiffrement
Cette section décrit en détail les entrées, les sorties et le traitement du fournisseur KMS direct quand il reçoit une demande de matériaux de chiffrement de la part du [chiffreur d'élément](DDBEC-legacy-concepts.md#item-encryptor).
**Entrée ** (depuis l'application)
+ L'identifiant clé d'un AWS KMS key.
**Entrée** (depuis le chiffreur d'élément)
+ [Contexte de chiffrement DynamoDB](concepts.md#encryption-context)
**Sortie** (vers le chiffreur d'élément)
+ Clé de chiffrement (texte brut)
+ Clé de signature
+ Dans [Description du matériau réel](DDBEC-legacy-concepts.md#legacy-material-description) : ces valeurs sont enregistrées dans l'attribut de description du matériau que le client ajoute à l'élément.
+ amzn-ddb-env-key: clé de données codée en Base64 cryptée par le AWS KMS key
+ amzn-ddb-env-alg: algorithme de chiffrement, par défaut [AES/256](https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/archived-crypto-projects/aes-development)
+ amzn-ddb-sig-alg: algorithme de signature, par défaut, [Hmac /256 SHA256](https://en.wikipedia.org/wiki/HMAC)
+ amzn-ddb-wrap-alg: km
**Traitement**
1. Le fournisseur Direct KMS envoie AWS KMS une demande d'utilisation de la clé spécifiée AWS KMS key pour [générer une clé de données unique](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) pour l'article. L'opération retourne une clé en texte brut et une copie chiffrée sous la AWS KMS key. Ce matériau est appelé *matériau de clé initial*.
La demande inclut les valeurs suivantes en texte brut dans le [contexte de chiffrement AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context). Ces valeurs non secrètes sont liées en termes de chiffrement à l'objet chiffré, si bien que le même contexte de chiffrement est requis au déchiffrement. Vous pouvez utiliser ces valeurs pour identifier l'appel AWS KMS dans les [AWS CloudTrail journaux](https://docs.aws.amazon.com/kms/latest/developerguide/monitoring-overview.html).
+ amzn-ddb-env-alg — Algorithme de chiffrement, par défaut AES/256
+ amzn-ddb-sig-alg — Algorithme de signature, par défaut Hmac /256 SHA256
+ (Facultatif) aws-kms-table — *table name*
+ (Facultatif) *partition key name* — *partition key value* (les valeurs binaires sont codées en Base64)
+ (Facultatif) *sort key name* — *sort key value* (les valeurs binaires sont codées en Base64)
Le fournisseur Direct KMS obtient les valeurs du contexte de AWS KMS chiffrement à partir du contexte de chiffrement [DynamoDB de l'élément](concepts.md#encryption-context). Si le contexte de chiffrement DynamoDB n'inclut aucune valeur, telle que le nom de la table, cette paire nom-valeur est omise du contexte de chiffrement. AWS KMS
1. Le fournisseur KMS direct dérive une clé de chiffrement symétrique et une clé de signature à partir de la clé de données. Par défaut, il utilise l'[algorithme de hachage sécurisé (SHA) 256](https://en.wikipedia.org/wiki/SHA-2) et la [fonction de dérivation de clé RFC5869 basée sur HMAC pour dériver une clé](https://tools.ietf.org/html/rfc5869) de chiffrement symétrique AES 256 bits et une clé de signature HMAC-SHA-256 bits.
1. Le fournisseur KMS direct retourne la sortie du chiffreur d'élément.
1. Le chiffreur d'élément utilise la clé de chiffrement pour chiffrer les attributs spécifiés et la clé de signature pour les signer, à l'aide des algorithmes spécifiés dans la description du matériau réel. Il supprime les clés en texte brut de la mémoire dès que possible.
### Obtention des matériaux de déchiffrement
Cette section décrit en détail les entrées, les sorties et le traitement du fournisseur KMS direct quand il reçoit une demande de déchiffrement de matériaux de la part du [chiffreur d'élément](DDBEC-legacy-concepts.md#item-encryptor).
**Entrée ** (depuis l'application)
+ L'identifiant clé d'un AWS KMS key.
La valeur de l'ID de clé peut être l'ID de clé, l'ARN de clé, le nom d'alias ou l'ARN d'alias du AWS KMS key. Toutes les valeurs qui ne sont pas incluses dans l'ID de clé, telles que la région, doivent être disponibles dans le [profil AWS nommé](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles). La clé ARN fournit toutes les valeurs AWS KMS nécessaires.
**Entrée** (depuis le chiffreur d'élément)
+ Copie du contexte de [chiffrement DynamoDB](concepts.md#encryption-context) qui contient le contenu de l'attribut de description du matériau.
**Sortie** (vers le chiffreur d'élément)
+ Clé de chiffrement (texte brut)
+ Clé de signature
**Traitement**
1. Le fournisseur Direct KMS obtient la clé de données chiffrée à partir de l'attribut de description du matériau contenu dans l'élément chiffré.
1. Il demande AWS KMS d'utiliser le paramètre spécifié AWS KMS key pour [déchiffrer](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) la clé de données cryptée. L'opération retourne une clé en texte brut.
Cette demande doit utiliser le même [contexte de chiffrement AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) que celui utilisé pour générer et chiffrer la clé de données.
+ aws-kms-table – *table name*
+ *partition key name*— *partition key value* (les valeurs binaires sont codées en Base64)
+ (Facultatif) *sort key name* — *sort key value* (les valeurs binaires sont codées en Base64)
+ amzn-ddb-env-alg — Algorithme de chiffrement, par défaut AES/256
+ amzn-ddb-sig-alg — Algorithme de signature, par défaut Hmac /256 SHA256
1. Le fournisseur Direct KMS utilise l'[algorithme de hachage sécurisé (SHA) 256](https://en.wikipedia.org/wiki/SHA-2) et une [fonction de dérivation de clé RFC5869 basée sur HMAC pour dériver une clé](https://tools.ietf.org/html/rfc5869) de chiffrement symétrique AES 256 bits et une clé de signature HMAC-SHA-256 bits à partir de la clé de données.
1. Le fournisseur KMS direct retourne la sortie du chiffreur d'élément.
1. Le chiffreur d'élément utilise la clé de signature pour vérifier l'élément. S'il réussit, il utilise la clé de chiffrement symétrique pour déchiffrer les valeurs d'attribut chiffrées. Ces opérations utilisent les algorithmes de chiffrement et de signature spécifiés dans la description du matériau réel. Le chiffreur d'élément supprime les clés en texte brut de la mémoire dès que possible.
# Fournisseur de matériaux encapsulé
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Le *Wrapped Materials Provider* (Wrapped CMP) vous permet d'utiliser des clés d'encapsulation et de signature provenant de n'importe quelle source avec le client de chiffrement DynamoDB. Le CMP Wrapped ne dépend d'aucun AWS service. Cependant, vous devez générer et gérer vos clés d'encapsulation et de signature en dehors du client, y compris la fourniture des clés appropriées pour vérifier et déchiffrer l'élément.
Le fournisseur CMP encapsulé génère une clé de chiffrement d'élément unique pour chaque élément. Il encapsule la clé de chiffrement d'élément avec la clé d'encapsulation que vous fournissez et enregistre la clé de chiffrement d'élément encapsulée dans l'[attribut de description de matériau](DDBEC-legacy-concepts.md#legacy-material-description) de l'élément. Comme vous fournissez les clés d'encapsulation et de signature, vous déterminez de quelle façon les clés d'encapsulation et de signature sont générées, et si elles sont propres à chaque élément ou sont réutilisées.
Le fournisseur CMP encapsulé constitue une implémentation sécurisée et un bon choix pour les applications qui peuvent gérer les matériaux de chiffrement.
Le Wrapped CMP est l'un des nombreux [fournisseurs de matériel cryptographique](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs) pris en charge par le client de chiffrement DynamoDB. Pour plus d'informations sur l'autre CMPs, voir[Fournisseur de matériel cryptographique](crypto-materials-providers.md).
**Pour obtenir un exemple de code, consultez :**
+ Java: [AsymmetricEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AsymmetricEncryptedItem.java)
+ Python : [wrapped-rsa-encrypted-table](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/wrapped_rsa_encrypted_table.py), [wrapped-symmetric-encrypted-table](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/wrapped_symmetric_encrypted_table.py)
**Topics**
+ [Comment l'utiliser](#wrapped-cmp-how-to-use)
+ [Comment ça marche](#wrapped-cmp-how-it-works)
## Comment l'utiliser
Pour créer un fournisseur CMP encapsulé, spécifiez une clé d'encapsulation (requise au chiffrement), une clé de désencapsulation (requise au déchiffrement) et une clé de signature. Vous devez fournir les clés lorsque vous chiffrez et déchiffrez les éléments.
Les clés d'encapsulation, de désencapsulation et de signature peuvent être des clés symétriques ou des paires de clés asymétriques.
------
#### [ Java ]
```
// This example uses asymmetric wrapping and signing key pairs
final KeyPair wrappingKeys = ...
final KeyPair signingKeys = ...
final WrappedMaterialsProvider cmp =
new WrappedMaterialsProvider(wrappingKeys.getPublic(),
wrappingKeys.getPrivate(),
signingKeys);
```
------
#### [ Python ]
```
# This example uses symmetric wrapping and signing keys
wrapping_key = ...
signing_key = ...
wrapped_cmp = WrappedCryptographicMaterialsProvider(
wrapping_key=wrapping_key,
unwrapping_key=wrapping_key,
signing_key=signing_key
)
```
------
## Comment ça marche
Le fournisseur CMP encapsulé génère une nouvelle clé de chiffrement d'élément pour chaque élément. Il utilise les clés d'encapsulation, de désencapsulation et de signature que vous fournissez, comme illustré dans le schéma suivant.
![\[Entrée, traitement et sortie du fournisseur de matériaux encapsulés dans le client de chiffrement DynamoDB\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/wrappedCMP.png)
### Obtention des matériaux de chiffrement
Cette section décrit en détail les entrées, les sorties et le traitement du fournisseur CMP encapsulé quand il reçoit une demande de matériaux de chiffrement.
**Entrée** (depuis l'application)
+ Clé d'encapsulation : clé symétrique [Advanced Encryption Standard](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) (AES) ou clé publique [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem)). Obligatoire si les valeurs d'attribut sont chiffrées. Sinon, elle est facultative et ignorée.
+ Clé de désencapsulation : facultative et ignorée.
+ Clé de signature
**Entrée** (depuis le chiffreur d'élément)
+ [Contexte de chiffrement DynamoDB](concepts.md#encryption-context)
**Sortie** (vers le chiffreur d'élément) :
+ Clé de chiffrement d'élément en texte brut
+ Clé de signature (inchangée)
+ [Description du matériau réel](DDBEC-legacy-concepts.md#legacy-material-description) : ces valeurs sont enregistrées dans l'[attribut de description du matériau](DDBEC-legacy-concepts.md#legacy-material-description) que le client ajoute à l'élément.
+ `amzn-ddb-env-key` : clé de chiffrement d'élément codée en base64
+ `amzn-ddb-env-alg` : algorithme de chiffrement utilisé pour chiffrer l'élément. La valeur par défaut est AES-256-CBC.
+ `amzn-ddb-wrap-alg` : algorithme d'encapsulation utilisé par le fournisseur CMP encapsulé pour encapsuler la clé de chiffrement d'élément. Si la clé d'encapsulation est une clé AES, la clé est encapsulée à l'aide de `AES-Keywrap` non complétée, comme défini dans [RFC 3394](https://tools.ietf.org/html/rfc3394.html). Si la clé d'encapsulation est une clé RSA, elle est chiffrée à l'aide de RSA OAEP avec rembourrage. MGF1
**Traitement**
Lorsque vous chiffrez un élément, vous transmettez une clé d'encapsulation et une clé de signature. Une clé de désencapsulation est facultative et ignorée.
1. Le fournisseur CMP encapsulé génère une clé de chiffrement d'élément symétrique unique pour l'élément de table.
1. Il utilise la clé d'encapsulation que vous spécifiez pour encapsuler la clé de chiffrement d'élément. Puis, il la supprime de la mémoire dès que possible.
1. Il retourne la clé de chiffrement d'élément en texte brut, la clé de signature que vous avez fournie et une [description de matériau réel](DDBEC-legacy-concepts.md#legacy-material-description) qui inclut la clé de chiffrement d'élément encapsulé, ainsi que les algorithmes de chiffrement et d'encapsulation.
1. Le chiffreur d'élément utilise la clé de chiffrement en texte brut pour chiffrer l'élément. Il utilise la clé de signature que vous avez fournie pour signer l'élément. Puis, il supprime les clés en texte brut de la mémoire dès que possible. Il copie les champs de la description du matériel réel, y compris la clé de chiffrement encapsulée (`amzn-ddb-env-key`), dans l'attribut de la description de matériau de l'élément.
### Obtention des matériaux de déchiffrement
Cette section décrit en détail les entrées, les sorties et le traitement du fournisseur CMP encapsulé quand il reçoit une demande de matériaux de déchiffrement.
**Entrée** (depuis l'application)
+ Clé d'encapsulation : facultative et ignorée.
+ Clé de désencapsulation : la même clé symétrique [Advanced Encryption Standard](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) (AES) ou la même clé privée [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem)) qui correspond à la clé publique RSA utilisée pour chiffrer. Obligatoire si les valeurs d'attribut sont chiffrées. Sinon, elle est facultative et ignorée.
+ Clé de signature
**Entrée** (depuis le chiffreur d'élément)
+ Copie du contexte de [chiffrement DynamoDB](concepts.md#encryption-context) qui contient le contenu de l'attribut de description du matériau.
**Sortie** (vers le chiffreur d'élément)
+ Clé de chiffrement d'élément en texte brut
+ Clé de signature (inchangée)
**Traitement**
Lorsque vous déchiffrez un élément, vous transmettez une clé de désencapsulation et une clé de signature. Une clé d'encapsulation est facultative et ignorée.
1. Le fournisseur CMP encapsulé obtient la clé de chiffrement d'élément encapsulé depuis l'attribut de description du matériau de l'élément.
1. Il utilise la clé et l'algorithme de désencapsulation pour désencapsuler la clé de chiffrement d'élément.
1. Il retourne la clé de chiffrement de l'élément en texte brut, la clé de signature, et les algorithmes de chiffrement et de signature au chiffreur d'élément.
1. Le chiffreur d'élément utilise la clé de signature pour vérifier l'élément. S'il réussit, il utilise la clé de chiffrement d'élément pour déchiffrer l'élément. Puis, il supprime les clés en texte brut de la mémoire dès que possible.
# À propos du fournisseur le plus récent
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Le *fournisseur le plus récent* est un [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) conçu pour travailler avec un [magasin de fournisseur](DDBEC-legacy-concepts.md#provider-store). Il CMPs provient du magasin du fournisseur et obtient le matériel cryptographique qu'il renvoie depuis le CMPs. Il utilise généralement chaque CMP pour répondre à plusieurs demandes de matériaux de chiffrement. Cependant, vous pouvez utiliser les fonctions de son magasin de fournisseur pour contrôler jusqu'à quelle mesure les matériaux sont réutilisés, déterminer la fréquence de rotation de son fournisseur CMP et, même, modifier le type de fournisseur CMP utilisé sans modifier le fournisseur le plus récent.
**Note**
Le code associé au `MostRecentProvider` symbole du fournisseur le plus récent peut stocker du matériel cryptographique en mémoire pendant toute la durée de vie du processus. Cela peut permettre à un appelant d'utiliser des clés qu'il n'est plus autorisé à utiliser.
Le `MostRecentProvider` symbole est obsolète dans les anciennes versions prises en charge du client de chiffrement DynamoDB et supprimé de la version 2.0.0. Il est remplacé par le `CachingMostRecentProvider` symbole. Pour en savoir plus, consultez [Mises à jour du fournisseur le plus récent](#mrp-versions).
Le fournisseur le plus récent constitue un bon choix pour les applications qui doivent minimiser les appels au magasin de fournisseur et à sa source de chiffrement, et pour les applications qui peuvent réutiliser certains matériaux de chiffrement sans enfreindre leurs exigences de sécurité. Par exemple, il vous permet de protéger votre matériel cryptographique sous un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) sans appeler AWS KMS chaque fois que vous cryptez ou décryptez un élément.
Le magasin de fournisseurs que vous choisissez détermine le type de magasin utilisé par le fournisseur le plus récent et la fréquence à CMPs laquelle il reçoit un nouveau CMP. Vous pouvez utiliser tout magasin de fournisseur compatible avec le fournisseur le plus récent, y compris les magasins de fournisseur personnalisés que vous concevez.
Le client de chiffrement DynamoDB inclut *MetaStore*un qui crée et [renvoie des fournisseurs de matériaux encapsulés (encapsulés](wrapped-provider.md)). CMPs Il MetaStore enregistre plusieurs versions du Wrapped CMPs qu'il génère dans une table DynamoDB interne et les protège par un chiffrement côté client par une instance interne du client de chiffrement DynamoDB.
Vous pouvez configurer le MetaStore pour utiliser n'importe quel type de CMP interne pour protéger le contenu du tableau, y compris un [fournisseur KMS direct](direct-kms-provider.md) qui génère du matériel cryptographique protégé par vos soins AWS KMS key, un CMP encapsulé qui utilise les clés d'encapsulage et de signature que vous fournissez, ou un CMP personnalisé compatible que vous concevez.
**Pour obtenir un exemple de code, consultez :**
+ Java: [MostRecentEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/MostRecentEncryptedItem.java)
+ Python : [most\$1recent\$1provider\$1encrypted\$1table](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/most_recent_provider_encrypted_table.py)
**Topics**
+ [Comment l'utiliser](#mrp-how-to-use-it)
+ [Comment ça marche](#mrp-how-it-works)
+ [Mises à jour du fournisseur le plus récent](#mrp-versions)
## Comment l'utiliser
Pour créer un fournisseur le plus récent, vous devez créer et configurer un magasin de fournisseur, puis créer un fournisseur le plus récent qui utilise le magasin de fournisseur.
[Les exemples suivants montrent comment créer un fournisseur le plus récent qui utilise un MetaStore et protège les versions de sa table DynamoDB interne avec du matériel cryptographique provenant d'un fournisseur KMS direct.](direct-kms-provider.md) Ces exemples utilisent le [`CachingMostRecentProvider`](#mrp-versions)symbole.
Chaque fournisseur le plus récent possède un nom qui l'identifie CMPs dans le MetaStore tableau, un paramètre [time-to-live](#most-recent-provider-ttl)(TTL) et un paramètre de taille de cache qui détermine le nombre d'entrées que le cache peut contenir. Ces exemples définissent la taille du cache à 1 000 entrées et à un TTL de 60 secondes.
------
#### [ Java ]
```
// Set the name for MetaStore's internal table
final String keyTableName = 'metaStoreTable'
// Set the Region and AWS KMS key
final String region = 'us-west-2'
final String keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
// Set the TTL and cache size
final long ttlInMillis = 60000;
final long cacheSize = 1000;
// Name that identifies the MetaStore's CMPs in the provider store
final String materialName = 'testMRP'
// Create an internal DynamoDB client for the MetaStore
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
// Create an internal Direct KMS Provider for the MetaStore
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider kmsProv = new DirectKmsMaterialProvider(kms, keyArn);
// Create an item encryptor for the MetaStore,
// including the Direct KMS Provider
final DynamoDBEncryptor keyEncryptor = DynamoDBEncryptor.getInstance(kmsProv);
// Create the MetaStore
final MetaStore metaStore = new MetaStore(ddb, keyTableName, keyEncryptor);
//Create the Most Recent Provider
final CachingMostRecentProvider cmp = new CachingMostRecentProvider(metaStore, materialName, ttlInMillis, cacheSize);
```
------
#### [ Python ]
```
# Designate an AWS KMS key
kms_key_id = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
# Set the name for MetaStore's internal table
meta_table_name = 'metaStoreTable'
# Name that identifies the MetaStore's CMPs in the provider store
material_name = 'testMRP'
# Create an internal DynamoDB table resource for the MetaStore
meta_table = boto3.resource('dynamodb').Table(meta_table_name)
# Create an internal Direct KMS Provider for the MetaStore
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
# Create the MetaStore with the Direct KMS Provider
meta_store = MetaStore(
table=meta_table,
materials_provider=kms_cmp
)
# Create a Most Recent Provider using the MetaStore
# Sets the TTL (in seconds) and cache size (# entries)
most_recent_cmp = MostRecentProvider(
provider_store=meta_store,
material_name=material_name,
version_ttl=60.0,
cache_size=1000
)
```
------
## Comment ça marche
Le fournisseur le plus récent CMPs provient d'un magasin de fournisseurs. Puis, il utilise le fournisseur CMP pour générer les matériaux de chiffrement qu'il retourne au chiffreur d'élément.
### À propos du fournisseur le plus récent
Le fournisseur le plus récent obtient un [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) à partir d'un [magasin de fournisseur](DDBEC-legacy-concepts.md#provider-store). Puis, il utilise le fournisseur CMP pour générer les matériaux de chiffrement qu'il retourne. Chaque fournisseur le plus récent est associé à une boutique de fournisseurs, mais une boutique de fournisseurs peut CMPs approvisionner plusieurs fournisseurs sur plusieurs hôtes.
Le fournisseur le plus récent peut travailler avec n'importe quel fournisseur CMP compatible d'un magasin de fournisseur. Il demande du matériel de chiffrement ou de déchiffrement au CMP et renvoie le résultat au chiffreur d'articles. Il n'effectue pas d'opération de chiffrement.
Pour demander un fournisseur CMP auprès de son magasin de fournisseur, le fournisseur le plus récent fournit son nom de matériau et la version d'un fournisseur CMP existant qu'il veut utiliser. Pour les matériaux de chiffrement, le fournisseur le plus récent demande toujours la version maximale (la « plus récente »). Pour les matériaux de chiffrement, il demande la version du fournisseur CMP qui a été utilisée pour créer les matériaux de chiffrement, comme illustré dans le diagramme suivant.
![\[Fournisseur le plus récent\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/most-recent-provider-1.png)
Le fournisseur le plus récent enregistre les versions CMPs renvoyées par le magasin du fournisseur dans un cache local le moins récemment utilisé (LRU) en mémoire. Le cache permet au fournisseur le plus récent d'obtenir CMPs ce dont il a besoin sans avoir à appeler le magasin du fournisseur pour chaque élément. Vous pouvez effacer le cache à la demande.
Le fournisseur le plus récent utilise une [time-to-livevaleur](#most-recent-provider-ttl) configurable que vous pouvez ajuster en fonction des caractéristiques de votre application.
### À propos de MetaStore
Vous pouvez utiliser un fournisseur le plus récent avec n'importe quel magasin de fournisseur, y compris un magasin de fournisseur personnalisé compatible. Le client de chiffrement DynamoDB inclut MetaStore une implémentation sécurisée que vous pouvez configurer et personnaliser.
A *MetaStore*est un [magasin fournisseur](DDBEC-legacy-concepts.md#provider-store) qui crée et renvoie des [Wrapped CMPs](wrapped-provider.md) configurés avec la clé d'encapsulation, la clé de déballage et la clé de signature requises par Wrapped CMPs . A MetaStore est une option sécurisée pour le fournisseur le plus récent, car Wrapped génère CMPs toujours des clés de chiffrement uniques pour chaque article. Seule la clé d'encapsulation qui protège la clé de chiffrement d'élément et la clé de signature sont réutilisées.
Le schéma suivant montre les composants du fournisseur le plus récent MetaStore et la manière dont il interagit avec celui-ci.
![\[UN MetaStore\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/most-recent-provider-2.png)
Il MetaStore génère le Wrapped CMPs, puis le stocke (sous forme cryptée) dans une table DynamoDB interne. La clé de partition est le nom du matériel du fournisseur le plus récent ; la clé de tri son numéro de version. Les éléments de la table sont protégés par un client de chiffrement DynamoDB interne, comprenant un crypteur d'éléments et un fournisseur [interne de matériel cryptographique](DDBEC-legacy-concepts.md#concept-material-provider) (CMP).
Vous pouvez utiliser n'importe quel type de CMP interne MetaStore, y compris un [fournisseur KMS direct](wrapped-provider.md), un CMP encapsulé avec du matériel cryptographique que vous fournissez ou un CMP personnalisé compatible. Si le CMP interne de votre ordinateur MetaStore est un fournisseur KMS direct, vos clés d'emballage et de signature réutilisables sont protégées par un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS). Les MetaStore appels AWS KMS chaque fois qu'il ajoute une nouvelle version CMP à sa table interne ou qu'il obtient une version CMP à partir de sa table interne.
### Définition d'une time-to-live valeur
Vous pouvez définir une valeur time-to-live (TTL) pour chaque fournisseur le plus récent que vous créez. En général, utilisez la valeur TTL la plus basse adaptée à votre application.
L'utilisation de la valeur TTL est modifiée dans le `CachingMostRecentProvider` symbole du fournisseur le plus récent.
**Note**
Le `MostRecentProvider` symbole du fournisseur le plus récent est obsolète dans les anciennes versions prises en charge du client de chiffrement DynamoDB et supprimé de la version 2.0.0. Il est remplacé par le `CachingMostRecentProvider` symbole. Nous vous recommandons de mettre à jour votre code dès que possible. Pour en savoir plus, consultez [Mises à jour du fournisseur le plus récent](#mrp-versions).
**`CachingMostRecentProvider`**
`CachingMostRecentProvider`Utilise la valeur TTL de deux manières différentes.
+ Le TTL détermine la fréquence à laquelle le fournisseur le plus récent vérifie la présence d'une nouvelle version du CMP dans le magasin du fournisseur. Si une nouvelle version est disponible, le fournisseur le plus récent remplace son CMP et actualise son matériel cryptographique. Dans le cas contraire, il continue d'utiliser son CMP et son matériel cryptographique actuels.
+ Le TTL détermine la durée pendant CMPs laquelle le cache peut être utilisé. Avant d'utiliser un CMP mis en cache pour le chiffrement, le fournisseur le plus récent évalue le temps passé dans le cache. Si le temps de cache du CMP dépasse le TTL, le CMP est expulsé du cache et le fournisseur le plus récent obtient une nouvelle version de CMP dans le magasin de son fournisseur.
**`MostRecentProvider`**
Dans le`MostRecentProvider`, le TTL détermine la fréquence à laquelle le fournisseur le plus récent vérifie la présence d'une nouvelle version du CMP dans le magasin du fournisseur. Si une nouvelle version est disponible, le fournisseur le plus récent remplace son CMP et actualise son matériel cryptographique. Dans le cas contraire, il continue d'utiliser son CMP et son matériel cryptographique actuels.
Le TTL ne détermine pas la fréquence à laquelle une nouvelle version du CMP est créée. Vous créez de nouvelles versions CMP en faisant [pivoter les matériaux cryptographiques](#most-recent-provider-rotate).
La valeur TTL idéale varie en fonction de l'application et de ses objectifs de latence et de disponibilité. Un TTL inférieur améliore votre profil de sécurité en réduisant le temps pendant lequel les documents cryptographiques sont stockés en mémoire. En outre, un TTL inférieur actualise les informations critiques plus fréquemment. Par exemple, si votre CMP interne est un [fournisseur KMS direct](direct-kms-provider.md), il vérifie plus fréquemment que l'appelant est toujours autorisé à utiliser un. AWS KMS key
Toutefois, si le TTL est trop bref, les appels fréquents vers le magasin du fournisseur peuvent augmenter vos coûts et obliger ce dernier à limiter les demandes provenant de votre application et d'autres applications partageant votre compte de service. Il peut également être avantageux de coordonner le TTL avec la vitesse à laquelle vous faites pivoter les documents cryptographiques.
Pendant les tests, modifiez le TTL et la taille du cache en fonction des différentes charges de travail jusqu'à ce que vous trouviez une configuration adaptée à votre application et à vos normes de sécurité et de performance.
### Rotation des matériaux de chiffrement
Lorsqu'un fournisseur le plus récent a besoin de matériel de chiffrement, il utilise toujours la version la plus récente de son CMP dont il a connaissance. La fréquence à laquelle il vérifie la présence d'une version plus récente est déterminée par la valeur [time-to-live](#most-recent-provider-ttl)(TTL) que vous définissez lorsque vous configurez le fournisseur le plus récent.
Lorsque le TTL expire, le fournisseur le plus récent vérifie la version la plus récente du CMP dans le magasin du fournisseur. Si un CMP est disponible, le fournisseur le plus récent l'obtient et remplace le CMP dans son cache. Il utilise ce CMP et son matériel cryptographique jusqu'à ce qu'il découvre que le magasin du fournisseur dispose d'une version plus récente.
Pour demander au magasin de fournisseur de créer une version d'un CMP pour un fournisseur le plus récent, appelez l'opération Create New Provider du magasin de fournisseur avec le nom de matériau du fournisseur le plus récent. Le magasin de fournisseur crée un CMP et enregistre une copie chiffrée dans son stockage interne avec un numéro de version supérieur. (Il retourne aussi un CMP, mais vous pouvez l'ignorer.) Par conséquent, la prochaine fois que le fournisseur le plus récent demandera au magasin du fournisseur le numéro de version maximal de celui-ci CMPs, il obtiendra le nouveau numéro de version supérieur et l'utilisera dans les demandes ultérieures adressées au magasin pour voir si une nouvelle version du CMP a été créée.
Vous pouvez planifier vos appels Create New Provider en fonction de l'heure, du nombre d'éléments ou d'attributs traités, ou de toute autre métrique qui revêt un sens pour votre application.
### Obtention des matériaux de chiffrement
Le fournisseur le plus récent utilise le processus suivant, illustré dans le diagramme, pour obtenir les matériaux de chiffrement qu'il retourne au chiffreur d'élément. La sortie dépend du type de fournisseur CMP que le magasin de fournisseur retourne. Le fournisseur le plus récent peut utiliser n'importe quel magasin de fournisseurs compatible, y compris MetaStore celui inclus dans le client de chiffrement DynamoDB.
![\[Entrée, traitement et sortie du fournisseur le plus récent dans le client de chiffrement DynamoDB\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/most-recent-provider-provider-store.png)
Lorsque vous créez un fournisseur le plus récent à l'aide du [`CachingMostRecentProvider`symbole](#mrp-versions), vous spécifiez un magasin de fournisseurs, le nom du fournisseur le plus récent et une valeur [time-to-live](#most-recent-provider-ttl)(TTL). Vous pouvez également éventuellement spécifier une taille de cache, qui détermine le nombre maximal de documents cryptographiques pouvant exister dans le cache.
Quand le chiffreur d'élément demande au fournisseur le plus récent les matériaux de chiffrement, le fournisseur le plus récent commence par chercher dans le cache le dernier numéro de version de ses fournisseurs CMP.
+ S'il trouve la dernière version du CMP dans son cache et que le CMP n'a pas dépassé la valeur TTL, le fournisseur le plus récent utilise le CMP pour générer du matériel de chiffrement. Puis, il retourne les matériaux de chiffrement au chiffreur d'élément. Cette opération ne requiert pas d'appel au magasin de fournisseur.
+ Si la dernière version du CMP n'est pas dans son cache, ou si elle est dans le cache mais a dépassé sa valeur TTL, le fournisseur le plus récent demande un CMP à son magasin de fournisseurs. La demande inclut le nom de matériau du fournisseur le plus récent et le numéro de version maximal qu'il connaît.
1. Le magasin de fournisseur retourne un fournisseur CMP à partir de son stockage permanent. Si le magasin du fournisseur est un MetaStore, il obtient un CMP encapsulé chiffré à partir de sa table DynamoDB interne en utilisant le nom du matériau du fournisseur le plus récent comme clé de partition et le numéro de version comme clé de tri. Il MetaStore utilise son crypteur d'éléments interne et son CMP interne pour déchiffrer le CMP encapsulé. Ensuite, il retourne le fournisseur CMP en texte brut au fournisseur le plus récent. Si le CMP interne est un [fournisseur KMS direct](direct-kms-provider.md), cette étape inclut un appel de [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (AWS KMS).
1. Le fournisseur CMP ajoute le champ `amzn-ddb-meta-id` à la [description du matériau réel](DDBEC-legacy-concepts.md#legacy-material-description). Sa valeur est le nom de matériau et la version du CMP dans sa table interne. Le magasin de fournisseur retourne le fournisseur CMP au fournisseur le plus récent.
1. Le fournisseur le plus récent met en cache mémoire le fournisseur CMP.
1. Le fournisseur le plus récent utilise le fournisseur CMP pour générer les matériaux de chiffrement. Puis, il retourne les matériaux de chiffrement au chiffreur d'élément.
### Obtention des matériaux de déchiffrement
Quand le chiffreur d'élément demande au fournisseur le plus récent les matériaux de chiffrement, le fournisseur le plus récent utilise le processus suivant pour les obtenir et les retourner.
1. Le fournisseur le plus récent demande au magasin de fournisseur le numéro de version des matériaux de chiffrement utilisés pour chiffrer l'élément. Il transmet la description du matériau réel depuis l'[attribut de description du matériau](DDBEC-legacy-concepts.md#legacy-material-description) de l'élément.
1. Le magasin de fournisseur obtient le numéro de version du CMP en charge du chiffrement auprès du champ `amzn-ddb-meta-id` de la description du matériau réel et le retourne au fournisseur le plus récent.
1. Le fournisseur le plus récent recherche dans son cache le numéro de version du CMP utilisé pour chiffrer et signer l'élément.
+ S'il trouve que la version correspondante du CMP se trouve dans son cache et que le CMP n'a pas dépassé la [valeur time-to-live (TTL)](#most-recent-provider-ttl), le fournisseur le plus récent utilise le CMP pour générer du matériel de déchiffrement. Puis, il retourne les matériaux de déchiffrement au chiffreur d'élément. Cette opération ne requiert pas d'appel au magasin de fournisseur ou à un autre fournisseur CMP.
+ Si la version correspondante du CMP ne se trouve pas dans son cache, ou si le cache AWS KMS key a dépassé sa valeur TTL, le fournisseur le plus récent demande un CMP à son magasin de fournisseurs. Il envoie le nom de matériau et le numéro de version du CMP de chiffrement dans la demande.
1. Le magasin de fournisseur recherche dans le stockage permanent le fournisseur CMP en utilisant le nom du fournisseur le plus récent comme clé de partition et le numéro de version comme clé de tri.
+ Si le nom et le numéro de version ne sont pas dans le stockage permanent, le magasin de fournisseur lève une exception. Si le magasin de fournisseur a été utilisé pour générer le CMP, celui-ci doit être stocké dans son stockage permanent, à moins qu'il ne soit intentionnellement supprimé.
+ Si le CMP avec le nom et le numéro de version correspondants se trouve dans le stockage permanent du magasin de fournisseur, celui-ci retourne le CMP spécifié au fournisseur le plus récent.
Si le magasin du fournisseur est un MetaStore, il obtient le CMP chiffré à partir de sa table DynamoDB. Puis, il utilise les matériaux de chiffrement de son fournisseur CMP interne pour déchiffrer le CMP chiffré avant de retourner le fournisseur CMP au fournisseur le plus récent. Si le CMP interne est un [fournisseur KMS direct](direct-kms-provider.md), cette étape inclut un appel de [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (AWS KMS).
1. Le fournisseur le plus récent met en cache mémoire le fournisseur CMP.
1. Le fournisseur le plus récent utilise le fournisseur CMP pour générer les matériaux de déchiffrement. Puis, il retourne les matériaux de déchiffrement au chiffreur d'élément.
## Mises à jour du fournisseur le plus récent
Le symbole du fournisseur le plus récent est remplacé par `MostRecentProvider``CachingMostRecentProvider`.
**Note**
Le `MostRecentProvider` symbole, qui représente le fournisseur le plus récent, est obsolète dans la version 1.15 du client de chiffrement DynamoDB pour Java et dans la version 1.3 du client de chiffrement DynamoDB pour Python et supprimé des versions 2.0.0 du client de chiffrement DynamoDB dans les deux implémentations linguistiques. Utilisez plutôt le`CachingMostRecentProvider`.
`CachingMostRecentProvider`implémente les modifications suivantes :
+ Supprime `CachingMostRecentProvider` périodiquement les documents cryptographiques de la mémoire lorsque leur durée en mémoire dépasse la valeur configurée [time-to-live (TTL).](#most-recent-provider-ttl)
Ils `MostRecentProvider` peuvent stocker du matériel cryptographique en mémoire pendant toute la durée de vie du processus. Par conséquent, le fournisseur le plus récent n'est peut-être pas au courant des modifications d'autorisation. Il peut utiliser des clés de chiffrement une fois que les autorisations de l'appelant à les utiliser ont été révoquées.
Si vous ne pouvez pas effectuer la mise à jour vers cette nouvelle version, vous pouvez obtenir un effet similaire en appelant régulièrement la `clear()` méthode dans le cache. Cette méthode vide manuellement le contenu du cache et oblige le fournisseur le plus récent à demander un nouveau CMP et de nouveaux matériaux cryptographiques.
+ `CachingMostRecentProvider`Il inclut également un paramètre de taille de cache qui vous permet de mieux contrôler le cache.
Pour effectuer la mise à jour vers le`CachingMostRecentProvider`, vous devez modifier le nom du symbole dans votre code. À tous les autres égards, le `CachingMostRecentProvider` est entièrement rétrocompatible avec le`MostRecentProvider`. Il n'est pas nécessaire de chiffrer à nouveau les éléments du tableau.
Cependant, cela `CachingMostRecentProvider` génère davantage d'appels vers l'infrastructure clé sous-jacente. Il appelle le magasin du fournisseur au moins une fois par intervalle time-to-live (TTL). Les applications avec de nombreuses applications actives CMPs (en raison de rotations fréquentes) ou les applications avec de grands flottes sont les plus susceptibles d'être sensibles à ce changement.
Avant de publier votre code mis à jour, testez-le minutieusement pour vous assurer que les appels les plus fréquents n'altèrent pas votre application ou n'entraînent pas de ralentissement de la part des services dont dépend votre fournisseur, tels que AWS Key Management Service (AWS KMS) ou Amazon DynamoDB. Pour atténuer les problèmes de performances, ajustez la taille du cache et celle time-to-live du en `CachingMostRecentProvider` fonction des caractéristiques de performance que vous observez. Pour de plus amples informations, consultez [Définition d'une time-to-live valeur](#most-recent-provider-ttl).
# Fournisseur de matériaux statique
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Le *fournisseur de matériaux statiques* (Static CMP) est un [fournisseur de matériaux cryptographiques](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) très simple destiné aux tests, aux proof-of-concept démonstrations et à la compatibilité existante.
Pour utiliser le fournisseur CMP statique afin de chiffrer un élément de table, vous fournissez une clé de chiffrement symétrique [AES (Advanced Encryption Standard)](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) et une clé ou paire de clés de signature. Vous devez fournir les mêmes clés pour déchiffrer l'élément chiffré. Le fournisseur CMP statique n'assure aucune opération de chiffrement. Au lieu de cela, il transmet inchangées les clés de chiffrement que vous fournissez au chiffreur d'élément. Le chiffreur d'élément chiffre les éléments directement sous la clé de chiffrement. Puis, il utilise directement la clé de signature pour les signer.
Comme le fournisseur CMP statique ne génère pas de matériau de chiffrement unique, tous les éléments de table que vous traitez sont chiffrés avec la même clé de chiffrement et signés par la même clé de signature. Lorsque vous utilisez la même clé pour chiffrer les valeurs d'attribut de nombreux éléments, ou que vous utilisez la même clé ou paire de clés pour signer tous les éléments, vous risquez de dépasser les limites de chiffrement des clés.
**Note**
Le [fournisseur statique asymétrique](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/AsymmetricStaticProvider.html) de la bibliothèque Java n'est pas un fournisseur statique. Il fournit juste d'autres constructeurs au [fournisseur CMP encapsulé](wrapped-provider.md). Il est sûr pour une utilisation en production, mais vous devez utiliser directement le CMP encapsulé chaque fois que possible.
Le CMP statique est l'un des nombreux [fournisseurs de matériel cryptographique](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs) pris en charge par le client de chiffrement DynamoDB. Pour plus d'informations sur l'autre CMPs, voir[Fournisseur de matériel cryptographique](crypto-materials-providers.md).
**Pour obtenir un exemple de code, consultez :**
+ Java: [SymmetricEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/SymmetricEncryptedItem.java)
**Topics**
+ [Comment l'utiliser](#static-cmp-how-to-use)
+ [Comment ça marche](#static-cmp-how-it-works)
## Comment l'utiliser
Pour créer un fournisseur statique, fournissez une clé ou paire de clés de chiffrement, et une clé ou paire de clés de signature. Vous devez fournir le matériau de clé pour chiffrer et déchiffrer les éléments de table.
------
#### [ Java ]
```
// To encrypt
SecretKey cek = ...; // Encryption key
SecretKey macKey = ...; // Signing key
EncryptionMaterialsProvider provider = new SymmetricStaticProvider(cek, macKey);
// To decrypt
SecretKey cek = ...; // Encryption key
SecretKey macKey = ...; // Verification key
EncryptionMaterialsProvider provider = new SymmetricStaticProvider(cek, macKey);
```
------
#### [ Python ]
```
# You can provide encryption materials, decryption materials, or both
encrypt_keys = EncryptionMaterials(
encryption_key = ...,
signing_key = ...
)
decrypt_keys = DecryptionMaterials(
decryption_key = ...,
verification_key = ...
)
static_cmp = StaticCryptographicMaterialsProvider(
encryption_materials=encrypt_keys
decryption_materials=decrypt_keys
)
```
------
## Comment ça marche
Le fournisseur statique transmet les clés de chiffrement et de signature que vous fournissez au chiffreur d'élément, où elles sont utilisées directement pour chiffrer et signer vos éléments de table. À moins que vous ne fournissiez différentes clés pour chaque élément, les mêmes clés sont utilisées pour chaque élément.
![\[Entrée, traitement et sortie du fournisseur de matériaux statiques dans le client de chiffrement DynamoDB\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/staticCMP.png)
### Obtention des matériaux de chiffrement
Cette section décrit en détail les entrées, les sorties et le traitement du fournisseur CMP statique quand il reçoit une demande de matériaux de chiffrement.
**Entrée** (depuis l'application)
+ Une clé de chiffrement — Il doit s'agir d'une clé symétrique, telle qu'une clé AES ([Advanced Encryption Standard](https://tools.ietf.org/html/rfc3394.html)).
+ Une clé de signature : il peut s'agir d'une clé symétrique ou d'une paire de clés asymétrique.
**Entrée** (depuis le chiffreur d'élément)
+ [Contexte de chiffrement DynamoDB](concepts.md#encryption-context)
**Sortie** (vers le chiffreur d'élément)
+ Clé de chiffrement transmise comme entrée.
+ Clé de signature transmise comme entrée.
+ Description de matériau réel : [description de matériau demandé](DDBEC-legacy-concepts.md#legacy-material-description), le cas échéant, inchangé.
### Obtention des matériaux de déchiffrement
Cette section décrit en détail les entrées, les sorties et le traitement du fournisseur CMP statique quand il reçoit une demande de matériaux de déchiffrement.
Même s'il comporte des méthodes distinctes pour l'obtention des matériaux de chiffrement et celle des matériaux de déchiffrement, le comportement est le même.
**Entrée** (depuis l'application)
+ Une clé de chiffrement — Il doit s'agir d'une clé symétrique, telle qu'une clé AES ([Advanced Encryption Standard](https://tools.ietf.org/html/rfc3394.html)).
+ Une clé de signature : il peut s'agir d'une clé symétrique ou d'une paire de clés asymétrique.
**Entrée** (depuis le chiffreur d'élément)
+ Contexte de [chiffrement DynamoDB (non utilisé)](concepts.md#encryption-context)
**Sortie** (vers le chiffreur d'élément)
+ Clé de chiffrement transmise comme entrée.
+ Clé de signature transmise comme entrée.
# Langages de programmation disponibles pour le client de chiffrement Amazon DynamoDB
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Le client de chiffrement Amazon DynamoDB est disponible pour les langages de programmation suivants. Les bibliothèques spécifiques au langage varient, mais les implémentations qui en résultent sont interopérables. Par exemple, vous pouvez chiffrer (et signer) un élément avec le client Java et le déchiffrer avec le client Python.
Pour plus d'informations, consultez la rubrique correspondante.
**Topics**
+ [Java](java.md)
+ [Python](python.md)
# Client de chiffrement Amazon DynamoDB pour Java
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Cette rubrique explique comment installer et utiliser le client de chiffrement Amazon DynamoDB pour Java. [Pour plus de détails sur la programmation avec le client de chiffrement DynamoDB, consultez [les exemples Java, les](java-examples.md) exemples du référentiel GitHub et [le](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) Javadoc pour aws-dynamodb-encryption-java le client de chiffrement DynamoDB.](https://aws.github.io/aws-dynamodb-encryption-java/)
**Note**
Versions 1. *x.* *x* du client de chiffrement DynamoDB pour Java sont [end-of-support en phase à](what-is-database-encryption-sdk.md#support) compter de juillet 2022. Passez à une version plus récente dès que possible.
**Topics**
+ [Conditions préalables](#java-prerequisites)
+ [Installation](#java-installation)
+ [Utilisation du client de chiffrement DynamoDB pour Java](java-using.md)
+ [Exemples Java](java-examples.md)
## Conditions préalables
Avant d'installer le client de chiffrement Amazon DynamoDB pour Java, assurez-vous de remplir les conditions préalables suivantes.
**Environnement de développement Java**
Vous aurez besoin de Java 8 ou version ultérieure. Sur le site web d'Oracle, consultez la page [Téléchargements Java SE](https://www.oracle.com/java/technologies/downloads/), puis téléchargez et installez le kit Java SE Development (JDK).
Si vous utilisez le kit JDK Oracle, vous devez également télécharger et installer les [fichiers Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK pour Java**
Le client de chiffrement DynamoDB nécessite le module DynamoDB même si votre application n'interagit pas avec DynamoDB. AWS SDK pour Java Vous pouvez installer la totalité du kit SDK ou le seul module. Si vous utilisez Maven, ajoutez `aws-java-sdk-dynamodb` à votre fichier `pom.xml`.
Pour plus d'informations sur l'installation et la configuration du AWS SDK pour Java, consultez [AWS SDK pour Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/getting-started.html).
## Installation
Vous pouvez installer le client de chiffrement Amazon DynamoDB pour Java de la manière suivante.
**Manuellement**
Pour installer le client de chiffrement Amazon DynamoDB pour Java, clonez ou téléchargez le référentiel. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**Utilisation d'Apache Maven**
Le client de chiffrement Amazon DynamoDB pour Java est disponible [via Apache](https://maven.apache.org/) Maven avec la définition de dépendance suivante.
```
com.amazonaws
aws-dynamodb-encryption-java
version-number
```
Après avoir installé le SDK, commencez par consulter l'exemple de code présenté dans ce guide et le Javadoc du client de [chiffrement DynamoDB activé](https://aws.github.io/aws-dynamodb-encryption-java/). GitHub
# Utilisation du client de chiffrement DynamoDB pour Java
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Cette rubrique décrit certaines fonctionnalités du client de chiffrement DynamoDB en Java qui ne sont peut-être pas disponibles dans d'autres implémentations de langage de programmation.
[Pour plus de détails sur la programmation avec le client de chiffrement DynamoDB, consultez [les exemples Java, les](java-examples.md) exemples ci-dessous et [le](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) Javadoc pour `aws-dynamodb-encryption-java repository` GitHub le client de chiffrement DynamoDB.](https://aws.github.io/aws-dynamodb-encryption-java/)
**Topics**
+ [Chiffreurs d'éléments](#attribute-encryptor)
+ [Configuration du comportement d'enregistrement](#save-behavior)
+ [Actions d'attribut en Java](#attribute-actions-java)
+ [Remplacer les noms des tables](#override-table-name)
## Crypteurs d'objets : AttributeEncryptor et Dynamo DBEncryptor
[Le client de chiffrement DynamoDB en Java possède [deux chiffreurs d'éléments](DDBEC-legacy-concepts.md#item-encryptor) : le Dynamo de niveau inférieur et le. DBEncryptor [AttributeEncryptor](#attribute-encryptor)](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
`AttributeEncryptor`Il s'agit d'une classe d'assistance qui vous aide à utiliser le [Dynamo DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) `DynamoDB Encryptor` dans le AWS SDK pour Java client de chiffrement DynamoDB. Lorsque vous utilisez le `AttributeEncryptor` avec le `DynamoDBMapper`, il chiffre et signe vos éléments de manière transparente lorsque vous les enregistrez. Il vérifie et déchiffre également vos éléments de manière transparente lorsque vous les chargez.
## Configuration du comportement d'enregistrement
Vous pouvez utiliser le `AttributeEncryptor` et `DynamoDBMapper` pour ajouter ou remplacer des éléments de tableau par des attributs signés uniquement ou chiffrés et signés. Pour ces tâches, nous vous recommandons de le configurer pour utiliser le comportement d'enregistrement `PUT`, comme illustré dans l'exemple suivant. Sinon, il est possible que vous ne puissiez pas déchiffrer vos données.
```
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Si vous utilisez le comportement d'enregistrement par défaut, qui met à jour uniquement les attributs modélisés dans l'élément de table, les attributs non modélisés ne sont pas inclus dans la signature et ne sont pas modifiés par les écritures de table. Par conséquent, lors de lectures ultérieures de tous les attributs, la signature ne sera pas validée, car elle n'inclut pas d'attributs non modélisés.
Vous pouvez également utiliser le comportement de sauvegarde `CLOBBER`. Comportement d'enregistrement est identique au comportement d'enregistrement `PUT`, si ce n'est qu'il désactive le verrouillage optimiste et remplace l'élément dans la table.
Pour éviter les erreurs de signature, le client de chiffrement DynamoDB lance une exception d'exécution si un est utilisé avec `AttributeEncryptor` un qui n'est pas configuré avec `DynamoDBMapper` un comportement d'enregistrement de ou. `CLOBBER` `PUT`
Pour voir ce code utilisé dans un exemple, consultez [Utilisation de la Dynamo DBMapper](java-examples.md#java-example-dynamodb-mapper) l'exemple [AwsKmsEncryptedObject.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java) dans le `aws-dynamodb-encryption-java` référentiel dans GitHub.
## Actions d'attribut en Java
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) déterminent les valeurs d'attribut chiffrées et signées, qui sont uniquement signées et qui sont ignorées. La méthode que vous utilisez pour spécifier les actions attributaires varie selon que vous utilisez le Dynamo `DynamoDBMapper` et `AttributeEncryptor` ou le [Dynamo DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) de niveau inférieur.
**Important**
Après avoir utilisé vos actions d’attribut pour chiffrer vos éléments de table, l’ajouter ou la suppression d’attributs de votre modèle de données peut provoquer une erreur de validation de signature qui vous empêche de déchiffrer vos données. Pour obtenir une explication détaillée, consultez [Modification de votre modèle de données](data-model.md).
### Actions attributaires pour le Dynamo DBMapper
Quand vous utilisez les `DynamoDBMapper` et `AttributeEncryptor`, vous utilisez les annotations pour spécifier les actions d'attribut. Le client de chiffrement DynamoDB utilise les annotations d'attribut [DynamoDB standard qui définissent le type d'attribut](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.html) afin de déterminer comment protéger un attribut. Par défaut, tous les attributs sont chiffrés et signés à l'exception des clés primaires, qui sont signées, mais pas chiffrées.
**Note**
Ne chiffrez pas la valeur des attributs avec l'[annotation @Dynamo DBVersion Attribute](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html), bien que vous puissiez (et devriez) les signer. Sinon, les conditions qui utilisent sa valeur auront des effets inattendus.
```
// Attributes are encrypted and signed
@DynamoDBAttribute(attributeName="Description")
// Partition keys are signed but not encrypted
@DynamoDBHashKey(attributeName="Title")
// Sort keys are signed but not encrypted
@DynamoDBRangeKey(attributeName="Author")
```
Pour spécifier des exceptions, utilisez les annotations de chiffrement définies dans le client de chiffrement DynamoDB pour Java. Si vous les spécifiez au niveau classe, elles deviennent la valeur par défaut pour la classe.
```
// Sign only
@DoNotEncrypt
// Do nothing; not encrypted or signed
@DoNotTouch
```
Par exemple, ces annotations signent mais ne chiffrent pas l'attribut `PublicationYear`, et ni ne chiffrent ou ne signent la valeur d'attribut `ISBN`.
```
// Sign only (override the default)
@DoNotEncrypt
@DynamoDBAttribute(attributeName="PublicationYear")
// Do nothing (override the default)
@DoNotTouch
@DynamoDBAttribute(attributeName="ISBN")
```
### Actions attributaires pour le Dynamo DBEncryptor
Pour spécifier des actions d'attribut lorsque vous utilisez DBEncryptor directement le [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html), créez un `HashMap` objet dans lequel les paires nom-valeur représentent les noms d'attributs et les actions spécifiées.
Les valeurs valides des actions d'attribut sont définies dans le type énuméré `EncryptionFlags`. Vous pouvez utiliser `ENCRYPT` et `SIGN` conjointement, utiliser `SIGN` seul, ou omettre les deux. Toutefois, si vous l'utilisez `ENCRYPT` seul, le client de chiffrement DynamoDB génère une erreur. Vous ne pouvez pas chiffrer un attribut que vous ne signez pas.
```
ENCRYPT
SIGN
```
**Avertissement**
Ne chiffrez pas les attributs de la clé primaire. Ils doivent rester en texte brut pour que DynamoDB puisse trouver l'élément sans exécuter une analyse complète du tableau.
Si vous spécifiez une clé primaire dans le contexte de chiffrement, puis que vous la spécifiez `ENCRYPT` dans l'action d'attribut pour l'un ou l'autre des attributs de clé primaire, le client de chiffrement DynamoDB émet une exception.
Par exemple, le code Java suivant crée un code `actions` HashMap qui chiffre et signe tous les attributs de l'`record`élément. Les exceptions sont les attributs de clé de partition et de clé de tri, qui sont signés mais non chiffrés, et l'attribut `test`, qui n'est ni signé ni chiffré.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // no break; falls through to next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Don't encrypt or sign
break;
default:
// Encrypt and sign everything else
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Puis, quand vous appelez la méthode [encryptRecord](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html#encryptRecord-java.util.Map-java.util.Map-com.amazonaws.services.dynamodbv2.datamodeling.encryption.EncryptionContext-) de `DynamoDBEncryptor`, spécifiez la map comme valeur du paramètre `attributeFlags`. Par exemple, cet appel d'`encryptRecord` utilise la map `actions`.
```
// Encrypt the plaintext record
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
## Remplacer les noms des tables
Dans le client de chiffrement DynamoDB, le nom de la table DynamoDB est un élément du contexte de chiffrement [DynamoDB transmis aux méthodes de chiffrement et de déchiffrement](concepts.md#encryption-context). Lorsque vous chiffrez ou signez des éléments de table, le contexte de chiffrement DynamoDB, y compris le nom de la table, est lié cryptographiquement au texte chiffré. Si le contexte de chiffrement DynamoDB transmis à la méthode de déchiffrement ne correspond pas au contexte de chiffrement DynamoDB transmis à la méthode de chiffrement, l'opération de déchiffrement échoue.
Il arrive parfois que le nom d'une table change, par exemple lorsque vous sauvegardez une table ou que vous effectuez une [point-in-time restauration](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html). Lorsque vous déchiffrez ou vérifiez la signature de ces éléments, vous devez transmettre le même contexte de chiffrement DynamoDB que celui utilisé pour chiffrer et signer les éléments, y compris le nom de table d'origine. Le nom de la table actuelle n'est pas nécessaire.
Lorsque vous utilisez le`DynamoDBEncryptor`, vous assemblez le contexte de chiffrement DynamoDB manuellement. Toutefois, si vous utilisez le`DynamoDBMapper`, `AttributeEncryptor` crée le contexte de chiffrement DynamoDB pour vous, y compris le nom de la table actuelle. Pour indiquer à `AttributeEncryptor` de créer un contexte de chiffrement avec un nom de table différent, utilisez le `EncryptionContextOverrideOperator`.
Par exemple, le code suivant crée des instances du fournisseur de matériaux cryptographiques (CMP) et du `DynamoDBEncryptor`. Ensuite, il appelle la méthode `setEncryptionContextOverrideOperator` de `DynamoDBEncryptor`. Il utilise l'opérateur `overrideEncryptionContextTableName`, qui remplace un nom de table. Lorsqu'il est configuré de cette façon, il `AttributeEncryptor` crée un contexte de chiffrement DynamoDB qui `newTableName` inclut à la place de. `oldTableName` Pour un exemple complet, consultez [EncryptionContextOverridesWithDynamoDBMapper.java.](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/EncryptionContextOverridesWithDynamoDBMapper.java)
```
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
encryptor.setEncryptionContextOverrideOperator(EncryptionContextOperators.overrideEncryptionContextTableName(
oldTableName, newTableName));
```
Lorsque vous appelez la méthode de chargement de `DynamoDBMapper`, qui déchiffre et vérifie l'élément, vous spécifiez le nom de la table d'origine.
```
mapper.load(itemClass, DynamoDBMapperConfig.builder()
.withTableNameOverride(DynamoDBMapperConfig.TableNameOverride.withTableNameReplacement(oldTableName))
.build());
```
Vous pouvez également utiliser l'opérateur `overrideEncryptionContextTableNameUsingMap`, qui remplace plusieurs noms de table.
Les opérateurs de remplacement de nom de table sont généralement utilisés lors du déchiffrement des données et de la vérification des signatures. Vous pouvez toutefois les utiliser pour attribuer une valeur différente au nom de la table dans le contexte de chiffrement DynamoDB lors du chiffrement et de la signature.
N'utilisez pas les opérateurs de remplacement de nom de table si vous utilisez le `DynamoDBEncryptor`. Créez plutôt un contexte de chiffrement avec le nom de la table d'origine et soumettez-le à la méthode de déchiffrement.
# Exemple de code pour le client de chiffrement DynamoDB pour Java
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Les exemples suivants montrent comment utiliser le client de chiffrement DynamoDB pour Java afin de protéger les éléments de table DynamoDB dans votre application. Vous pouvez trouver d'autres exemples (et apporter les vôtres) dans le répertoire des [exemples](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) du [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/)référentiel sur GitHub.
**Topics**
+ [Utilisation de la Dynamo DBEncryptor](#java-example-ddb-encryptor)
+ [Utilisation de la Dynamo DBMapper](#java-example-dynamodb-mapper)
## Utilisation de la Dynamo DBEncryptor
Cet exemple montre comment utiliser le [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) de niveau inférieur DBEncryptor avec le fournisseur [Direct KMS](direct-kms-provider.md). Le fournisseur Direct KMS génère et protège son matériel cryptographique sous un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS) que vous spécifiez.
Vous pouvez utiliser n'importe quel [fournisseur de matériel cryptographique](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatible avec le`DynamoDBEncryptor`, et vous pouvez utiliser le fournisseur Direct KMS avec le `DynamoDBMapper` et. [AttributeEncryptor](java-using.md#attribute-encryptor)
**Voir l'exemple de code complet** : [AwsKmsEncryptedItem.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)
Étape 1 : Créer le fournisseur KMS direct
Créez une instance du AWS KMS client avec la région spécifiée. Utilisez ensuite l'instance client pour créer une instance du fournisseur Direct KMS selon vos préférences AWS KMS key.
Cet exemple utilise l'Amazon Resource Name (ARN) pour identifier le AWS KMS key, mais vous pouvez utiliser [n'importe quel identifiant de clé valide](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn).
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Étape 2 : Créer un élément
Cet exemple définit un `record` HashMap qui représente un exemple d'élément de table.
```
final String partitionKeyName = "partition_attribute";
final String sortKeyName = "sort_attribute";
final Map record = new HashMap<>();
record.put(partitionKeyName, new AttributeValue().withS("value1"));
record.put(sortKeyName, new AttributeValue().withN("55"));
record.put("example", new AttributeValue().withS("data"));
record.put("numbers", new AttributeValue().withN("99"));
record.put("binary", new AttributeValue().withB(ByteBuffer.wrap(new byte[]{0x00, 0x01, 0x02})));
record.put("test", new AttributeValue().withS("test-value"));
```
Étape 3 : Création d'une dynamo DBEncryptor
Créez une instance de `DynamoDBEncryptor` avec le fournisseur KMS direct.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Étape 4 : Création d'un contexte de chiffrement DynamoDB
Le contexte de [chiffrement DynamoDB](concepts.md#encryption-context) contient des informations sur la structure de la table et sur la manière dont elle est chiffrée et signée. Si vous utilisez `DynamoDBMapper`, `AttributeEncryptor` crée automatiquement le contexte de chiffrement.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Étape 5 : Créer l'objet actions d'attribut
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) déterminent quels attributs de l'élément sont chiffrés et signés, lesquels sont uniquement signés et lesquels ne sont ni chiffrés ni signés.
En Java, pour spécifier des actions d'attribut, vous créez des paires HashMap de nom d'attribut et de `EncryptionFlags` valeur.
Par exemple, le code Java suivant crée un `actions` HashMap qui chiffre et signe tous les attributs de l'`record`élément, à l'exception des attributs de clé de partition et de clé de tri, qui sont signés, mais non chiffrés, et de l'`test`attribut, qui n'est ni signé ni chiffré.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // fall through to the next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Neither encrypted nor signed
break;
default:
// Encrypt and sign all other attributes
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Étape 6 : Chiffrer et signer l'élément
Pour chiffrer et signer l'élément de table, appelez la méthode `encryptRecord` sur l'instance de `DynamoDBEncryptor`. Spécifiez l'élément de table (`record`), les actions d'attribut (`actions`) et le contexte de chiffrement (`encryptionContext`).
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Étape 7 : Placer l'élément dans la table DynamoDB
Enfin, placez l'élément chiffré et signé dans la table DynamoDB.
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem(tableName, encrypted_record);
```
## Utilisation de la Dynamo DBMapper
[L'exemple suivant montre comment utiliser la classe d'assistance du mappeur DynamoDB avec le fournisseur Direct KMS.](direct-kms-provider.md) Le fournisseur Direct KMS génère et protège son matériel cryptographique sous un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS) que vous spécifiez.
Vous pouvez utiliser tout [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) compatible avec `DynamoDBMapper`, et vous pouvez utiliser le fournisseur KMS direct avec le `DynamoDBEncryptor` de bas niveau.
**Voir l'exemple de code complet** : [AwsKmsEncryptedObject.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java)
Étape 1 : Créer le fournisseur KMS direct
Créez une instance du AWS KMS client avec la région spécifiée. Utilisez ensuite l'instance client pour créer une instance du fournisseur Direct KMS selon vos préférences AWS KMS key.
Cet exemple utilise l'Amazon Resource Name (ARN) pour identifier le AWS KMS key, mais vous pouvez utiliser [n'importe quel identifiant de clé valide](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id).
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Étape 2 : Création du chiffreur DynamoDB et de Dynamo DBMapper
Utilisez le fournisseur Direct KMS que vous avez créé à l'étape précédente pour créer une instance de [DynamoDB Encryptor](java-using.md#attribute-encryptor). Vous devez instancier le chiffreur DynamoDB de niveau inférieur pour utiliser le mappeur DynamoDB.
Créez ensuite une instance de votre base de données DynamoDB et une configuration de mappeur, puis utilisez-les pour créer une instance du mappeur DynamoDB.
Lorsque vous utilisez `DynamoDBMapper` pour ajouter ou modifier des éléments signés (ou chiffrés et signés), configurez-le pour qu'il [utilise un comportement d'enregistrement](java-using.md#save-behavior), par exemple `PUT`, qui inclut tous les attributs, comme illustré dans l'exemple suivant. Sinon, il est possible que vous ne puissiez pas déchiffrer vos données.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp)
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Étape 3 : définition de votre table DynamoDB
Définissez ensuite votre table DynamoDB. Utilisez des annotations pour spécifier les [actions d'attribut](java-using.md#attribute-actions-java). Cet exemple crée une table DynamoDB et une classe qui `ExampleTable` représente les éléments `DataPoJo` de la table.
Dans cet exemple de table, les attributs de la clé primaire seront signés, mais pas chiffrés. Cela s'applique à l'attribut `partition_attribute`, qui est annoté avec `@DynamoDBHashKey`, et l'attribut `sort_attribute`, qui est annoté avec `@DynamoDBRangeKey`.
Les attributs qui sont annotés avec `@DynamoDBAttribute`, par exemple `some numbers`, seront chiffrés et signés. Les exceptions sont les attributs qui utilisent les annotations de chiffrement `@DoNotEncrypt` (signer uniquement) ou `@DoNotTouch` (ne pas chiffrer ni signer) définies par le client de chiffrement DynamoDB. Par exemple, étant donné que l'attribut `leave me` comporte une annotation `@DoNotTouch`, il ne sera ni chiffré ni signé.
```
@DynamoDBTable(tableName = "ExampleTable")
public static final class DataPoJo {
private String partitionAttribute;
private int sortAttribute;
private String example;
private long someNumbers;
private byte[] someBinary;
private String leaveMe;
@DynamoDBHashKey(attributeName = "partition_attribute")
public String getPartitionAttribute() {
return partitionAttribute;
}
public void setPartitionAttribute(String partitionAttribute) {
this.partitionAttribute = partitionAttribute;
}
@DynamoDBRangeKey(attributeName = "sort_attribute")
public int getSortAttribute() {
return sortAttribute;
}
public void setSortAttribute(int sortAttribute) {
this.sortAttribute = sortAttribute;
}
@DynamoDBAttribute(attributeName = "example")
public String getExample() {
return example;
}
public void setExample(String example) {
this.example = example;
}
@DynamoDBAttribute(attributeName = "some numbers")
public long getSomeNumbers() {
return someNumbers;
}
public void setSomeNumbers(long someNumbers) {
this.someNumbers = someNumbers;
}
@DynamoDBAttribute(attributeName = "and some binary")
public byte[] getSomeBinary() {
return someBinary;
}
public void setSomeBinary(byte[] someBinary) {
this.someBinary = someBinary;
}
@DynamoDBAttribute(attributeName = "leave me")
@DoNotTouch
public String getLeaveMe() {
return leaveMe;
}
public void setLeaveMe(String leaveMe) {
this.leaveMe = leaveMe;
}
@Override
public String toString() {
return "DataPoJo [partitionAttribute=" + partitionAttribute + ", sortAttribute="
+ sortAttribute + ", example=" + example + ", someNumbers=" + someNumbers
+ ", someBinary=" + Arrays.toString(someBinary) + ", leaveMe=" + leaveMe + "]";
}
}
```
Étape 4 : Chiffrer et enregistrer un élément de table
Désormais, lorsque vous créez un élément de table et que vous utilisez le mappeur DynamoDB pour l'enregistrer, l'élément est automatiquement chiffré et signé avant d'être ajouté à la table.
Cet exemple définit un élément de table appelé `record`. Avant qu'il soit enregistré dans la table, ses attributs sont chiffrées et signés selon les annotations de la classe `DataPoJo`. Dans le cas présent, tous les attributs à l'exception de `PartitionAttribute`, `SortAttribute` et `LeaveMe` sont chiffrés et signés. `PartitionAttribute` et `SortAttributes` sont seulement signés. L'attribut `LeaveMe` n'est ni chiffré ni signé.
Pour chiffrer et signer l'élément `record`, puis l'ajouter à `ExampleTable`, appelez la méthode `save` de la classe `DynamoDBMapper`. Votre mappeur DynamoDB étant configuré pour utiliser `PUT` le comportement d'enregistrement, l'élément remplace tout élément possédant les mêmes clés primaires, au lieu de le mettre à jour. Cela garantit que les signatures correspondent et que vous pouvez déchiffrer l'élément lorsque vous le récupérez de la table.
```
DataPoJo record = new DataPoJo();
record.setPartitionAttribute("is this");
record.setSortAttribute(55);
record.setExample("data");
record.setSomeNumbers(99);
record.setSomeBinary(new byte[]{0x00, 0x01, 0x02});
record.setLeaveMe("alone");
mapper.save(record);
```
# Client de chiffrement DynamoDB pour Python
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Cette rubrique explique comment installer et utiliser le client de chiffrement DynamoDB pour Python. Vous pouvez trouver le code dans le [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)référentiel sur GitHub, y compris un [exemple de code](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) complet et testé pour vous aider à démarrer.
**Note**
Versions 1. *x.* *x* et 2. *x.* *x* du client de chiffrement DynamoDB pour Python sont [end-of-support en phase à](what-is-database-encryption-sdk.md#support) compter de juillet 2022. Passez à une version plus récente dès que possible.
**Topics**
+ [Conditions préalables](#python-prerequisites)
+ [Installation](#python-installation)
+ [Utilisation du client de chiffrement DynamoDB pour Python](python-using.md)
+ [Exemples Python](python-examples.md)
## Conditions préalables
Avant d'installer le client de chiffrement Amazon DynamoDB pour Python, assurez-vous de remplir les conditions préalables suivantes.
**Version prise en charge de Python**
Python 3.8 ou version ultérieure est requis par le client de chiffrement Amazon DynamoDB pour les versions 3.3.0 et ultérieures de Python. Pour télécharger Python, consultez [Téléchargements Python](https://www.python.org/downloads/).
Les versions antérieures du client de chiffrement Amazon DynamoDB pour Python prennent en charge Python 2.7, Python 3.4 et versions ultérieures, mais nous vous recommandons d'utiliser la dernière version du client de chiffrement DynamoDB.
**Outil d'installation pip pour Python**
Python 3.6 et versions ultérieures incluent **pip**, bien que vous souhaitiez peut-être le mettre à niveau. Pour plus d'informations sur la mise à niveau ou l'installation de pip, consultez [Installation](https://pip.pypa.io/en/latest/installation/) dans la documentation **pip**.
## Installation
Utilisez **pip** pour installer le client de chiffrement Amazon DynamoDB pour Python, comme indiqué dans les exemples suivants.
**Pour installer la dernière version**
```
pip install dynamodb-encryption-sdk
```
Pour plus d'informations sur l'utilisation de **pip** pour installer et mettre à niveau les packages, consultez [Installing Packages](https://packaging.python.org/tutorials/installing-packages/).
Le client de chiffrement DynamoDB nécessite la bibliothèque de chiffrement [sur toutes les plateformes](https://cryptography.io/en/latest/). Toutes les versions de **pip** installent et créent la bibliothèque de **chiffrement** sous Windows. **pip** 8.1 et les versions ultérieures installent et créent la bibliothèque de **chiffrement** sous Linux. Si vous utilisez une version antérieure de **pip** et que votre environnement Linux ne possède pas les outils nécessaires pour générer la bibliothèque de **chiffrement**, vous devez les installer. Pour plus d'informations, consultez [Création du chiffrement sous Linux](https://cryptography.io/en/latest/installation/#building-cryptography-on-linux).
Vous pouvez obtenir la dernière version de développement du client de chiffrement DynamoDB à partir du [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)référentiel. GitHub
Après avoir installé le client de chiffrement DynamoDB, commencez par consulter l'exemple de code Python présenté dans ce guide.
# Utilisation du client de chiffrement DynamoDB pour Python
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Cette rubrique décrit certaines fonctionnalités du client de chiffrement DynamoDB pour Python qui ne sont peut-être pas disponibles dans d'autres implémentations de langage de programmation. Ces fonctionnalités sont conçues pour faciliter l'utilisation du client de chiffrement DynamoDB de la manière la plus sécurisée qui soit. À moins que vous n'ayez un scénario inhabituel, nous vous recommandons de les utiliser.
Pour plus de détails sur la programmation avec le client de chiffrement DynamoDB, consultez les exemples [Python](python-examples.md) de ce guide, [les exemples du](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) référentiel et aws-dynamodb-encryption-python la documentation GitHub [Python](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/) du client de chiffrement DynamoDB.
**Topics**
+ [Classes d'annotations clientes](#python-helpers)
+ [TableInfo classe](#table-info)
+ [Actions d'attribut en Python](#python-attribute-actions)
## Classes d'annotations clientes
Le client de chiffrement DynamoDB pour Python inclut plusieurs classes d'assistance client qui reflètent les classes Boto 3 pour DynamoDB. Ces classes d'assistance sont conçues pour faciliter l'ajout de chiffrement et de signature à votre application DynamoDB existante et pour éviter les problèmes les plus courants, comme suit :
+ Empêchez-vous de chiffrer la clé primaire de votre élément, soit en ajoutant une action de remplacement pour la clé primaire à l'[AttributeActions](#python-attribute-actions)objet, soit en lançant une exception si votre `AttributeActions` objet demande explicitement au client de chiffrer la clé primaire. Si l'action par défaut de votre objet `AttributeActions` est `DO_NOTHING`, les classes d'annotations clientes utilisent cette action pour la clé primaire. Sinon, elles utilisent `SIGN_ONLY`.
+ Créez un [TableInfo objet](#python-helpers) et renseignez le contexte de [chiffrement DynamoDB](concepts.md#encryption-context) en fonction d'un appel à DynamoDB. Cela permet de garantir que votre contexte de chiffrement DynamoDB est précis et que le client peut identifier la clé primaire.
+ Support des méthodes, telles que `put_item` et`get_item`, qui chiffrent et déchiffrent de manière transparente les éléments de votre table lorsque vous écrivez ou lisez dans une table DynamoDB. Seule la méthode `update_item` n'est pas prise en charge.
Vous pouvez utiliser les classes d'annotations clientes au lieu d'interagir directement avec le [chiffreur d'élément](DDBEC-legacy-concepts.md#item-encryptor) de bas niveau. Utilisez ces classes à moins que vous n'ayez besoin de définir des options avancées dans le chiffreur d'élément.
Les classes d'annotations clientes incluent les éléments suivants :
+ [EncryptedTable](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/table.html#module-dynamodb_encryption_sdk.encrypted.table)pour les applications qui utilisent la ressource [Table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#table) dans DynamoDB pour traiter une table à la fois.
+ [EncryptedResource](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/resource.html)pour les applications qui utilisent la classe [Service Resource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#service-resource) dans DynamoDB pour le traitement par lots.
+ [EncryptedClient](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/client.html)pour les applications qui utilisent le [client de niveau inférieur dans DynamoDB](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#client).
Pour utiliser les classes d'assistance client, l'appelant doit être autorisé à appeler l'opération DynamoDB sur la table cible [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html).
## TableInfo classe
La [TableInfo](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/tools/structures.html#dynamodb_encryption_sdk.structures.TableInfo)classe est une classe auxiliaire qui représente une table DynamoDB, avec des champs pour sa clé primaire et ses index secondaires. Elle vous permet d'obtenir des informations précises et en temps réel sur la table.
Si vous utilisez une [classe d'annotations clientes](#python-helpers), elle crée et utilise un objet `TableInfo` pour vous. Sinon, vous pouvez en créer un explicitement. Pour obtenir un exemple, consultez [Utilisation du chiffreur d'élément](python-examples.md#python-example-item-encryptor).
Lorsque vous appelez la `refresh_indexed_attributes` méthode sur un `TableInfo` objet, elle renseigne les valeurs des propriétés de l'objet en appelant l'opération DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). L'interrogation de la table est beaucoup plus fiable que le codage en dur des noms d'index. La `TableInfo` classe inclut également une `encryption_context_values` propriété qui fournit les valeurs requises pour le contexte de [chiffrement DynamoDB](concepts.md#encryption-context).
Pour utiliser la `refresh_indexed_attributes` méthode, l'appelant doit être autorisé à appeler l'opération [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB sur la table cible.
## Actions d'attribut en Python
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) informent le chiffreur d'élément des actions à exécuter sur chaque attribut de l'élément. Pour spécifier les actions d'attribut en Python, créez un objet `AttributeActions` avec une action par défaut et les exceptions éventuelles pour des attributs particuliers. Les valeurs valides sont définies dans le type énuméré `CryptoAction`.
**Important**
Après avoir utilisé vos actions d’attribut pour chiffrer vos éléments de table, l’ajouter ou la suppression d’attributs de votre modèle de données peut provoquer une erreur de validation de signature qui vous empêche de déchiffrer vos données. Pour obtenir une explication détaillée, consultez [Modification de votre modèle de données](data-model.md).
```
DO_NOTHING = 0
SIGN_ONLY = 1
ENCRYPT_AND_SIGN = 2
```
Par exemple, l'objet `AttributeActions` établit `ENCRYPT_AND_SIGN` comme valeur par défaut pour tous les attributs, et spécifie les exceptions pour les attributs `ISBN` et `PublicationYear`.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'ISBN': CryptoAction.DO_NOTHING,
'PublicationYear': CryptoAction.SIGN_ONLY
}
)
```
Si vous utilisez une [classe d'annotations clientes](#python-helpers), vous n'avez pas besoin de spécifier une action d'attribut pour les attributs de clé primaire. Les classes d'annotations clients vous empêchent de chiffrer votre clé primaire.
Si vous n'utilisez pas une classe d'annotations clientes et que l'action par défaut est `ENCRYPT_AND_SIGN`, vous devez spécifier une action pour la clé primaire. L'action recommandée pour les clés primaires est `SIGN_ONLY`. À des fins de simplification, utilisez la méthode `set_index_keys`, qui utilise SIGN\$1ONLY pour les clés primaires ou DO\$1NOTHING quand il s'agit de l'action par défaut.
**Avertissement**
Ne chiffrez pas les attributs de la clé primaire. Ils doivent rester en texte brut pour que DynamoDB puisse trouver l'élément sans exécuter une analyse complète du tableau.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
)
actions.set_index_keys(*table_info.protected_index_keys())
```
# Exemple de code pour le client de chiffrement DynamoDB pour Python
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Les exemples suivants montrent comment utiliser le client de chiffrement DynamoDB pour Python afin de protéger les données DynamoDB dans votre application. Vous pouvez trouver d'autres exemples (et apporter les vôtres) dans le répertoire des [exemples](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) du [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)référentiel sur GitHub.
**Topics**
+ [Utiliser la classe d'assistance EncryptedTable client](#python-example-table)
+ [Utilisation du chiffreur d'élément](#python-example-item-encryptor)
## Utiliser la classe d'assistance EncryptedTable client
L'exemple suivant montre comment utiliser le [fournisseur KMS direct](direct-kms-provider.md) avec la `EncryptedTable` [classe d'annotations cliente](python-using.md#python-helpers). Cet exemple utilise le même [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) que l'exemple [Utilisation du chiffreur d'élément](#python-example-item-encryptor) qui suit. Cependant, il utilise la classe `EncryptedTable` au lieu d'interagir directement avec le [chiffreur d'élément](DDBEC-legacy-concepts.md#item-encryptor) de bas niveau.
En comparant ces exemples, vous pouvez voir le travail que la classe d'annotations cliente effectue à votre place. Cela implique de créer le contexte de [chiffrement DynamoDB](concepts.md#encryption-context) et de s'assurer que les attributs de clé primaire sont toujours signés, mais jamais chiffrés. Pour créer le contexte de chiffrement et découvrir la clé primaire, les classes d'assistance client appellent l'opération DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Pour exécuter ce code, vous devez avoir l'autorisation d'appeler cette opération.
**Consultez l'exemple de code complet** : [aws\$1kms\$1encrypted\$1table.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py)
Étape 1 : Créer la table
Commencez par créer une instance d'une table DynamoDB standard avec le nom de la table.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Étape 2 : Créer un fournisseur CMP
Créez une instance du [fournisseur CMP](crypto-materials-providers.md) que vous avez sélectionné.
Cet exemple utilise le [fournisseur KMS direct](direct-kms-provider.md), mais vous pouvez utiliser n'importe quel fournisseur CMP compatible. Pour créer un fournisseur KMS direct, spécifiez un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys). Cet exemple utilise le Amazon Resource Name (ARN) du AWS KMS key, mais vous pouvez utiliser n'importe quel identifiant de clé valide.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Étape 3 : Créer l'objet actions d'attribut
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) informent le chiffreur d'élément des actions à exécuter sur chaque attribut de l'élément. L'objet `AttributeActions` de l'exemple chiffre et signe tous les éléments à l'exception de l'attribut `test`, qui est ignoré.
Ne spécifiez pas d'actions d'attribut pour les attributs de clé primaire quand vous utilisez une classe d'annotations cliente. La classe `EncryptedTable` signe, mais ne chiffre jamais, les attributs de clé primaire.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
```
Étape 4 : Créer la table chiffrée
Créez la table chiffrée à l'aide de la table standard, du fournisseur KMS direct et des actions d'attribut. Cette étape termine la configuration.
```
encrypted_table = EncryptedTable(
table=table,
materials_provider=kms_cmp,
attribute_actions=actions
)
```
Étape 5 : Placer l'élément en texte brut dans la table
Lorsque vous appelez la `put_item` méthode sur le`encrypted_table`, les éléments de votre table sont chiffrés, signés et ajoutés de manière transparente à votre table DynamoDB.
Tout d'abord, définissez l'élément de table.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_attribute': 55
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Puis, insérez-le dans la table.
```
encrypted_table.put_item(Item=plaintext_item)
```
Pour obtenir l'élément de la table DynamoDB sous sa forme cryptée, appelez `get_item` la méthode sur l'objet. `table` Pour obtenir l'élément chiffré, appelez la méthode `get_item` sur l'objet `encrypted_table`.
## Utilisation du chiffreur d'élément
Cet exemple montre comment interagir directement avec le chiffreur d'[éléments dans le client de chiffrement DynamoDB lors du chiffrement d'éléments de table, au lieu d'utiliser les classes d'[assistance du client qui interagissent avec le](python-using.md#python-helpers) crypteur](DDBEC-legacy-concepts.md#item-encryptor) d'éléments à votre place.
Lorsque vous utilisez cette technique, vous créez le contexte de chiffrement DynamoDB et l'objet `CryptoConfig` de configuration () manuellement. Vous cryptez également les éléments lors d'un appel et vous les placez dans votre table DynamoDB lors d'un appel distinct. Cela vous permet de personnaliser vos `put_item` appels et d'utiliser le client de chiffrement DynamoDB pour chiffrer et signer les données structurées qui ne sont jamais envoyées à DynamoDB.
Cet exemple utilise le [fournisseur KMS direct](direct-kms-provider.md), mais vous pouvez utiliser n'importe quel fournisseur CMP compatible.
**Voir l'exemple de code complet** : [aws\$1kms\$1encrypted\$1item.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_item.py)
Étape 1 : Créer la table
Commencez par créer une instance d'une ressource de table DynamoDB standard avec le nom de la table.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Étape 2 : Créer un fournisseur CMP
Créez une instance du [fournisseur CMP](crypto-materials-providers.md) que vous avez sélectionné.
Cet exemple utilise le [fournisseur KMS direct](direct-kms-provider.md), mais vous pouvez utiliser n'importe quel fournisseur CMP compatible. Pour créer un fournisseur KMS direct, spécifiez un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys). Cet exemple utilise le Amazon Resource Name (ARN) du AWS KMS key, mais vous pouvez utiliser n'importe quel identifiant de clé valide.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Étape 3 : Utiliser la classe TableInfo d'assistance
Pour obtenir des informations sur la table à partir de DynamoDB, créez une instance de [TableInfo](python-using.md#python-helpers)la classe d'assistance. Lorsque vous travaillez directement avec le chiffreur d'élément, vous devez créer une instance `TableInfo` et appeler ses méthodes. Les [classes d'annotation clientes](python-using.md#python-helpers) le font pour vous.
La `refresh_indexed_attributes` méthode `TableInfo` utilise l'opération [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB pour obtenir des informations précises et en temps réel sur la table. Elles incluent la clé primaire et ses index secondaires locaux et globaux. L'appelant doit avoir l'autorisation d'appeler `DescribeTable`.
```
table_info = TableInfo(name=table_name)
table_info.refresh_indexed_attributes(table.meta.client)
```
Étape 4 : Création du contexte de chiffrement DynamoDB
Le contexte de [chiffrement DynamoDB](concepts.md#encryption-context) contient des informations sur la structure de la table et sur la manière dont elle est chiffrée et signée. Cet exemple crée un contexte de chiffrement DynamoDB de manière explicite, car il interagit avec le chiffreur d'éléments. Les [classes d'assistance client](python-using.md#python-helpers) créent le contexte de chiffrement DynamoDB pour vous.
Pour obtenir la clé de partition et la clé de tri, vous pouvez utiliser les propriétés de la classe d'[TableInfo](python-using.md#python-helpers)assistance.
```
index_key = {
'partition_attribute': 'value1',
'sort_attribute': 55
}
encryption_context = EncryptionContext(
table_name=table_name,
partition_key_name=table_info.primary_index.partition,
sort_key_name=table_info.primary_index.sort,
attributes=dict_to_ddb(index_key)
)
```
Étape 5 : Créer l'objet actions d'attribut
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) informent le chiffreur d'élément des actions à exécuter sur chaque attribut de l'élément. L'objet `AttributeActions` de l'exemple chiffre et signe tous les éléments à l'exception des attributs de clé primaire, qui sont signés, mais pas chiffrés, et de l'attribut `test`, qui est ignoré.
Lorsque vous interagissez directement avec le chiffreur d'élément et que votre action par défaut est `ENCRYPT_AND_SIGN`, vous devez spécifier une autre action pour la clé primaire. Vous pouvez utiliser la méthode `set_index_keys`, qui utilise `SIGN_ONLY` pour la clé primaire, ou `DO_NOTHING` s'il s'agit de l'action par défaut.
Pour spécifier la clé primaire, cet exemple utilise les clés d'index de l'[TableInfo](python-using.md#python-helpers)objet, qui sont renseignées par un appel à DynamoDB. Cette technique est plus sûre que le codage en dur des noms de clé primaire.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
actions.set_index_keys(*table_info.protected_index_keys())
```
Étape 6 : Créer la configuration pour l'élément
Pour configurer le client de chiffrement DynamoDB, utilisez les objets que vous venez de créer dans [CryptoConfig](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/config.html)une configuration pour l'élément de table. Les classes d'assistance client créent le CryptoConfig pour vous.
```
crypto_config = CryptoConfig(
materials_provider=kms_cmp,
encryption_context=encryption_context,
attribute_actions=actions
)
```
Étape 7 : Chiffrer l'élément
Cette étape chiffre et signe l'élément, mais ne le place pas dans la table DynamoDB.
Lorsque vous utilisez une classe d'assistance client, vos éléments sont chiffrés et signés de manière transparente, puis ajoutés à votre table DynamoDB lorsque vous appelez la méthode de la `put_item` classe d'assistance. Lorsque vous utilisez le chiffreur d'élément directement, les actions de chiffrage et de placement sont indépendantes.
Tout d'abord, créez un élément en texte brut.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_key': 55,
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Puis, chiffrez-le et signez-le. La méthode `encrypt_python_item` requiert l'objet de configuration `CryptoConfig`.
```
encrypted_item = encrypt_python_item(plaintext_item, crypto_config)
```
Étape 8 : Placer l'élément dans la table
Cette étape place l'élément chiffré et signé dans la table DynamoDB.
```
table.put_item(Item=encrypted_item)
```
Pour afficher l'élément chiffré, appelez la méthode `get_item` sur l'objet original `table`, et non sur l'objet `encrypted_table`. Elle obtient l'élément de la table DynamoDB sans le vérifier et le déchiffrer.
```
encrypted_item = table.get_item(Key=partition_key)['Item']
```
L'illustration suivante présente une partie d'un exemple d'élément de table chiffré et signé.
Les valeurs des attributs chiffrés sont des données binaires. Les noms et valeurs des attributs de clé primaire (`partition_attribute` et `sort_attribute`) et l'attribut `test` demeurent en texte brut. La sortie affiche aussi l'attribut qui contient la signature (`*amzn-ddb-map-sig*`) et l'[attribut de description des matériaux](DDBEC-legacy-concepts.md#legacy-material-description) (`*amzn-ddb-map-desc*`).
![\[Extrait d'un élément de table chiffré et signé\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/encrypted-item-closeup.png)
# Modification de votre modèle de données
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Chaque fois que vous chiffrez ou déchiffrez un élément, vous devez fournir des [actions attributaires](DDBEC-legacy-concepts.md#legacy-attribute-actions) qui indiquent au client de chiffrement DynamoDB les attributs à chiffrer et à signer, les attributs à signer (mais pas à chiffrer) et ceux à ignorer. Les actions d'attribut ne sont pas enregistrées dans l'élément chiffré et le client de chiffrement DynamoDB ne met pas automatiquement à jour vos actions d'attribut.
**Important**
Le client de chiffrement DynamoDB ne prend pas en charge le chiffrement des données de table DynamoDB existantes non chiffrées.
Chaque fois que vous modifiez votre modèle de données, c'est-à-dire lorsque vous ajoutez ou supprimez des attributs de vos éléments de table, vous risquez une erreur. Si les actions d'attribut que vous spécifiez ne rendent pas compte de tous les attributs de l'élément, l'élément peut ne pas être chiffré et signé comme vous l'escomptiez. Surtout, si les actions d'attribut que vous fournissez lors du déchiffrement d'un élément diffèrent des actions d'attribut que vous avez fournies lors du chiffrement de l'élément, la vérification de la signature peut échouer.
Par exemple, si les actions d'attribut utilisées pour chiffrer l'élément lui disent de signer l'attribut `test`, la signature de l'élément comportera l'attribut `test`. Cependant, si les actions d'attribut utilisées pour déchiffrer l'élément ne tiennent pas compte de l'attribut `test`, la vérification échouera parce que le client essaiera de vérifier une signature qui n'inclut pas l'attribut `test`.
Cela pose un problème particulier lorsque plusieurs applications lisent et écrivent les mêmes éléments DynamoDB, car le client de chiffrement DynamoDB doit calculer la même signature pour les éléments de toutes les applications. C'est également un problème pour toute application distribuée car les modifications dans les actions d'attribut doivent se propager à tous les hôtes. Même si un hôte accède à vos tables DynamoDB dans le cadre d'un seul processus, la mise en place d'un processus basé sur les meilleures pratiques permettra d'éviter les erreurs si le projet devient plus complexe.
Pour éviter les erreurs de validation de signature qui vous empêchent de lire les éléments de votre tableau, suivez les instructions suivantes.
+ [Ajout d'un attribut](#add-attribute) : si le nouvel attribut modifie vos actions d'attribut, déployez entièrement la modification d'action d'attribut avant d'inclure le nouvel attribut dans un élément.
+ [Suppression d'un attribut](#remove-attribute) : si vous arrêtez d'utiliser un attribut dans vos articles, ne modifiez pas vos actions d'attribut.
+ Modification de l'action : une fois que vous avez utilisé une configuration d'actions attributaires pour chiffrer les éléments de votre tableau, vous ne pouvez pas modifier en toute sécurité l'action par défaut ou l'action d'un attribut existant sans rechiffrer chaque élément de votre tableau.
Les erreurs de validation de signature peuvent être extrêmement difficiles à résoudre, de sorte que la meilleure approche consiste à les prévenir.
**Topics**
+ [Ajout d'un attribut](#add-attribute)
+ [Suppression d'un attribut](#remove-attribute)
## Ajout d'un attribut
Lorsque vous ajouterez un nouvel attribut à des éléments de table, vous devrez peut-être modifier vos actions attributaires. Pour éviter les erreurs de validation de signature, nous vous recommandons d'implémenter cette modification en deux étapes. Vérifiez que la première étape est terminée avant de commencer la deuxième étape.
1. Modifiez les actions d'attribut dans toutes les applications qui lisent ou écrivent dans la table. Déployez ces modifications et confirmez que la mise à jour a été propagée à tous les hôtes de destination.
1. Écrire des valeurs dans le nouvel attribut dans vos éléments de table.
Cette approche en deux étapes garantit que toutes les applications et les hôtes ont les mêmes actions d'attribut et calculera la même signature, avant toute rencontre avec le nouvel attribut. Ceci est important même lorsque l'action de l'attribut est *Ne rien faire* (ne pas chiffrer ou signer), car la valeur par défaut de certains chiffreurs est de chiffrer et de signer.
Les exemples suivants montrent le code de la première étape de ce processus. Ils ajoutent un nouvel attribut d'élément `link`, qui stocke un lien vers un autre élément de table. Étant donné que ce lien doit rester en texte brut, l'exemple lui attribue l'action sign-only. Après avoir entièrement déployé cette modification, puis vérifié que toutes les applications et tous les hôtes possèdent les nouvelles actions attributaires, vous pouvez commencer à utiliser l'attribut `link` dans vos éléments de table.
------
#### [ Java DynamoDB Mapper ]
Lors de l'utilisation de `DynamoDB Mapper` et `AttributeEncryptor`, par défaut, tous les attributs sont chiffrés et signés à l'exception des clés primaires, qui sont signées mais pas chiffrées. Pour spécifier une action de signature uniquement, utilisez l'annotation `@DoNotEncrypt`.
Cet exemple utilise l'annotation `@DoNotEncrypt` du nouvel attribut `link`.
```
@DynamoDBTable(tableName = "ExampleTable")
public static final class DataPoJo {
private String partitionAttribute;
private int sortAttribute;
private String link;
@DynamoDBHashKey(attributeName = "partition_attribute")
public String getPartitionAttribute() {
return partitionAttribute;
}
public void setPartitionAttribute(String partitionAttribute) {
this.partitionAttribute = partitionAttribute;
}
@DynamoDBRangeKey(attributeName = "sort_attribute")
public int getSortAttribute() {
return sortAttribute;
}
public void setSortAttribute(int sortAttribute) {
this.sortAttribute = sortAttribute;
}
@DynamoDBAttribute(attributeName = "link")
@DoNotEncrypt
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = link;
}
@Override
public String toString() {
return "DataPoJo [partitionAttribute=" + partitionAttribute + ",
sortAttribute=" + sortAttribute + ",
link=" + link + "]";
}
}
```
------
#### [ Java DynamoDB encryptor ]
Dans le chiffreur DynamoDB de niveau inférieur, vous devez définir des actions pour chaque attribut. Cet exemple utilise une instruction switch où la valeur par défaut est `encryptAndSign` et des exceptions sont spécifiées pour la clé de partition, la clé de tri et le nouvel attribut `link`. Dans cet exemple, si le code d'attribut de lien n'était pas entièrement déployé avant son utilisation, l'attribut de lien serait chiffré et signé par certaines applications, mais seulement signé par d'autres.
```
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName:
// fall through to the next case
case sortKeyName:
// partition and sort keys must be signed, but not encrypted
actions.put(attributeName, signOnly);
break;
case "link":
// only signed
actions.put(attributeName, signOnly);
break;
default:
// Encrypt and sign all other attributes
actions.put(attributeName, encryptAndSign);
break;
}
}
```
------
#### [ Python ]
Dans le client de chiffrement DynamoDB pour Python, vous pouvez définir une action par défaut pour tous les attributs, puis spécifier des exceptions.
Si vous utilisez une [classe d'annotations clientes](python-using.md#python-helpers), vous n'avez pas besoin de spécifier une action d'attribut pour les attributs de clé primaire. Les classes d'annotations clients vous empêchent de chiffrer votre clé primaire. Toutefois, si vous n'utilisez pas de classes d'annotations clientes, vous devez définir l'action SIGN\$1ONLY sur votre clé de partition et la clé de tri. Si vous chiffrez accidentellement votre partition ou votre clé de tri, vous ne pourrez pas récupérer vos données sans une analyse complète de la table.
Cet exemple spécifie une exception pour le nouvel attribut `link`, qui obtient l'action `SIGN_ONLY`.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'example': CryptoAction.DO_NOTHING,
'link': CryptoAction.SIGN_ONLY
}
)
```
------
## Suppression d'un attribut
Si vous n'avez plus besoin d'un attribut dans les éléments chiffrés avec le client de chiffrement DynamoDB, vous pouvez arrêter de l'utiliser. Toutefois, ne supprimez pas ou ne modifiez pas l'action de cet attribut. Si vous le faites, puis que vous rencontrez un élément avec cet attribut, la signature calculée pour l'élément ne correspondra pas à la signature d'origine et la validation de la signature échouera.
Bien que vous soyez tenté de supprimer toutes les traces de l'attribut de votre code, ajoutez un commentaire indiquant que l'élément n'est plus utilisé au lieu de le supprimer. Même si vous effectuez une analyse complète de table pour supprimer toutes les instances de l'attribut, un élément chiffré avec cet attribut peut être mis en cache ou en cours de traitement quelque part dans votre configuration.
# Résolution des problèmes liés à votre application cliente de chiffrement DynamoDB
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Cette section décrit les problèmes que vous pouvez rencontrer lors de l'utilisation du client de chiffrement DynamoDB et propose des suggestions pour les résoudre.
Pour fournir des commentaires sur le client de chiffrement DynamoDB, signalez un problème dans [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/)le référentiel or. [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/) GitHub
Pour émettre des commentaires sur cette documentation, utilisez le lien des commentaires sur n'importe quelle page.
**Topics**
+ [Accès refusé](#kms-permissions)
+ [Échec de la vérification de la signature](#change-data-model)
+ [Problèmes liés aux anciennes versions des tables globales](#fix-global-tables)
+ [Mauvaise performance du fournisseur le plus récent](#mrp-ttl-delay)
## Accès refusé
**Problème** : votre application se voit refuser l'accès à une ressource dont elle a besoin.
**Suggestion** : en savoir plus sur les autorisations requises et les ajouter au contexte de sécurité dans lequel votre application s'exécute.
**Détails**
Pour exécuter une application qui utilise la bibliothèque d'un client de chiffrement DynamoDB, l'appelant doit être autorisé à utiliser ses composants. Sinon, l'accès aux éléments requis lui est refusé.
+ Le client de chiffrement DynamoDB ne nécessite pas de compte Amazon Web Services AWS() et ne dépend d'aucun service. AWS Toutefois, si votre application l'utilise AWS, vous avez besoin [d'un Compte AWS](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) et d'[utilisateurs autorisés](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) à utiliser le compte.
+ Le client de chiffrement DynamoDB n'a pas besoin d'Amazon DynamoDB. Toutefois, si l'application qui utilise le client crée des tables DynamoDB, place des éléments dans une table ou extrait des éléments d'une table, l'appelant doit être autorisé à utiliser les opérations DynamoDB requises dans votre. Compte AWS Pour plus de détails, consultez les [rubriques relatives au contrôle d'accès](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-overview.html) dans le guide du *développeur Amazon DynamoDB*.
+ Si votre application utilise une [classe d'assistance client](python-using.md#python-helpers) dans le client de chiffrement DynamoDB pour Python, l'appelant doit être autorisé à appeler l'opération DynamoDB. [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)
+ Le client de chiffrement DynamoDB n'a pas AWS Key Management Service besoin de ().AWS KMS Toutefois, si votre application utilise un [fournisseur de matériel KMS direct](direct-kms-provider.md), ou si elle utilise un [fournisseur le plus récent](most-recent-provider.md) avec un magasin de fournisseurs qui l'utilise AWS KMS, l'appelant doit être autorisé à utiliser les opérations AWS KMS [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)et à [déchiffrer](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html).
## Échec de la vérification de la signature
**Problème** : un élément ne peut pas être déchiffré en raison de l'échec de la vérification de la signature. L'élément peut aussi ne pas avoir été chiffré et signé comme vous l'escomptez.
**Suggestion** : vérifiez que les actions d'attribut que vous fournissez représentent tous les attributs de l'élément. Lors du déchiffrement d'un élément, veillez à fournir les actions d'attribut qui correspondent aux actions utilisées pour chiffrer l'élément.
**Détails**
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) que vous fournissez indiquent au client de chiffrement DynamoDB les attributs à chiffrer et à signer, les attributs à signer (mais pas à chiffrer) et ceux à ignorer.
Si les actions d'attribut que vous spécifiez ne rendent pas compte de tous les attributs de l'élément, l'élément peut ne pas être chiffré et signé comme vous l'escomptiez. Si les actions d'attribut que vous fournissez lors du déchiffrement d'un élément diffèrent des actions d'attribut que vous avez fournies lors du chiffrement de l'élément, la vérification de la signature peut échouer. Il s'agit d'un problème particulier pour les applications distribuées dans lesquelles les nouvelles actions d'attribut peuvent ne pas avoir été propagées sur tous les hôtes.
Les erreurs de validation de signature sont difficiles à résoudre. Pour vous aider à les prévenir, prenez des précautions supplémentaires lorsque vous modifiez votre modèle de données. Pour en savoir plus, consultez [Modification de votre modèle de données](data-model.md).
## Problèmes liés aux anciennes versions des tables globales
**Problème** : les éléments d'une ancienne version de la table globale Amazon DynamoDB ne peuvent pas être déchiffrés car la vérification des signatures échoue.
**Suggestion** : définissez des actions d'attribut afin que les champs de réplication réservés ne soient ni chiffrés ni signés.
**Détails**
Vous pouvez utiliser le client de chiffrement DynamoDB avec les tables globales [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html). Nous vous recommandons d'utiliser des tables globales avec une [clé KMS multirégionale et de répliquer la clé](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) KMS dans tous les Régions AWS endroits où la table globale est répliquée.
À partir de la [version 2019.11.21](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html) des tables globales, vous pouvez utiliser des tables globales avec le client de chiffrement DynamoDB sans configuration particulière. Toutefois, si vous utilisez des tables globales [version 2017.11.29](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html), vous devez vous assurer que les champs de réplication réservés ne sont ni chiffrés ni signés.
[Si vous utilisez la version 2017.11.29 des tables globales, vous devez définir les actions d'attribut pour les attributs suivants `DO_NOTHING` en [Java ou en `@DoNotTouch` Python](java-using.md#attribute-actions-java).](python-using.md#python-attribute-actions)
+ `aws:rep:deleting`
+ `aws:rep:updatetime`
+ `aws:rep:updateregion`
Si vous utilisez une autre version des tables globales, aucune action n'est requise.
## Mauvaise performance du fournisseur le plus récent
**Problème** : votre application est moins réactive, en particulier après la mise à jour vers une version plus récente du client de chiffrement DynamoDB.
**Suggestion** : ajustez la time-to-live valeur et la taille du cache.
**Détails**
Le fournisseur le plus récent est conçu pour améliorer les performances des applications qui utilisent le client de chiffrement DynamoDB en autorisant une réutilisation limitée du matériel cryptographique. Lorsque vous configurez le fournisseur le plus récent pour votre application, vous devez trouver un équilibre entre l'amélioration des performances et les problèmes de sécurité liés à la mise en cache et à la réutilisation.
Dans les nouvelles versions du client de chiffrement DynamoDB, la valeur (TTL) détermine time-to-live la durée pendant laquelle les fournisseurs de matériel cryptographique mis en cache () peuvent être utilisés. CMPs Le TTL détermine également la fréquence à laquelle le fournisseur le plus récent vérifie la présence d'une nouvelle version du CMP.
Si votre TTL est trop long, votre application peut enfreindre vos règles commerciales ou vos normes de sécurité. Si votre TTL est trop court, des appels fréquents au magasin du fournisseur peuvent entraîner le ralentissement des demandes provenant de votre application et d'autres applications partageant votre compte de service. Pour résoudre ce problème, ajustez le TTL et la taille du cache à une valeur correspondant à vos objectifs de latence et de disponibilité et conforme à vos normes de sécurité. Pour en savoir plus, consultez [Définition d'une time-to-live valeur](most-recent-provider.md#most-recent-provider-ttl).