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.
# 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)