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 Encryption SDK langages de programmation
AWS Encryption SDK Il est disponible pour les langages de programmation suivants. Toutes les implémentations de langage 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. En outre, lors du chiffrement et du déchiffrement, vous devez utiliser des porte-clés compatibles, ou des clés principales et des fournisseurs de clés principales. Pour en savoir plus, consultez [Compatibilité du porte-clés](choose-keyring.md#keyring-compatibility).
**Topics**
+ [C](c-language.md)
+ [.NET](dot-net.md)
+ [Go](go.md)
+ [Java](java.md)
+ [JavaScript](javascript.md)
+ [Python](python.md)
+ [Rust](rust.md)
+ [Interface de ligne de commande](crypto-cli.md)
# Kit SDK de chiffrement AWS pour C
Elle Kit SDK de chiffrement AWS pour C fournit une bibliothèque de chiffrement côté client pour les développeurs qui écrivent des applications en C. Elle sert également de base aux implémentations du AWS Encryption SDK dans les langages de programmation de niveau supérieur.
Comme toutes les implémentations du AWS Encryption SDK, il Kit SDK de chiffrement AWS pour C offre des fonctionnalités avancées de protection des données. Il s'agit notamment du [chiffrement d'enveloppe](concepts.md#envelope-encryption), de données authentifiées supplémentaires (données AAD) et de [suites d'algorithmes](concepts.md#crypto-algorithm) de clés symétriques sécurisées, authentifiées, comme les clés AES-GCM 256 bits avec dérivation de clés et signature.
Toutes les implémentations spécifiques au langage AWS Encryption SDK sont totalement interopérables. Par exemple, vous pouvez chiffrer des données avec le Kit SDK de chiffrement AWS pour C et les déchiffrer avec [n'importe quelle implémentation de langage prise en charge](programming-languages.md), y compris la [AWS CLI](crypto-cli.md) de chiffrement.
Kit SDK de chiffrement AWS pour C Cela nécessite AWS SDK pour C\$1\$1 d'interagir avec AWS Key Management Service (AWS KMS). Vous ne devez l'utiliser que si vous utilisez le [AWS KMS porte-clés](use-kms-keyring.md) en option. Cependant, aucun autre AWS service n'est requis AWS KMS . AWS Encryption SDK
**En savoir plus**
+ Pour plus de détails sur la programmation avec le Kit SDK de chiffrement AWS pour C, consultez les [exemples en C](c-examples.md), les [exemples](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) du [aws-encryption-sdk-c référentiel](https://github.com/aws/aws-encryption-sdk-c/) et la [documentation de l'Kit SDK de chiffrement AWS pour C API](https://aws.github.io/aws-encryption-sdk-c/html/). GitHub
+ Pour savoir comment utiliser le pour chiffrer des données afin de les Kit SDK de chiffrement AWS pour C déchiffrer en plusieurs exemplaires Régions AWS, consultez la section [Comment déchiffrer des textes chiffrés dans plusieurs régions à l'aide du code AWS Encryption SDK en C du blog sur la sécurité](https://aws.amazon.com/blogs/security/how-to-decrypt-ciphertexts-multiple-regions-aws-encryption-sdk-in-c/). AWS
**Topics**
+ [Installation](c-language-installation.md)
+ [Utilisation du kit SDK C](c-language-using.md)
+ [Exemples](c-examples.md)
# Installation du Kit SDK de chiffrement AWS pour C
Installez la dernière version de Kit SDK de chiffrement AWS pour C.
**Note**
Toutes les versions Kit SDK de chiffrement AWS pour C antérieures à la version 2.0.0 sont en [end-of-supportphase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle).
Vous pouvez effectuer la mise à jour en toute sécurité à partir de la version 2.0. *x* et versions ultérieures vers la dernière version du Kit SDK de chiffrement AWS pour C sans aucune modification du code ou des données. Cependant, de [nouvelles fonctionnalités de sécurité](about-versions.md#version-2) ont été introduites dans la version 2.0. *x* ne sont pas rétrocompatibles. Pour effectuer une mise à jour à partir de versions antérieures à 1.7. *x* vers la version 2.0. *x* et versions ultérieures, vous devez d'abord effectuer la mise à jour vers la dernière version 1. version *x* du Kit SDK de chiffrement AWS pour C. Pour en savoir plus, consultez [Migration de votre AWS Encryption SDK](migration.md).
Vous trouverez des instructions détaillées pour l'installation et la création du Kit SDK de chiffrement AWS pour C dans le [fichier README](https://github.com/aws/aws-encryption-sdk-c/#readme) du [aws-encryption-sdk-c](https://github.com/aws/aws-encryption-sdk-c/)référentiel. Il inclut des instructions pour créer sur les plateformes Amazon Linux, Ubuntu, macOS et Windows.
Avant de commencer, décidez si vous souhaitez utiliser des [AWS KMS porte-clés](use-kms-keyring.md) dans le AWS Encryption SDK. Si vous utilisez un AWS KMS porte-clés, vous devez installer le AWS SDK pour C\$1\$1. Le AWS SDK est nécessaire pour interagir avec [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS). Lorsque vous utilisez des AWS KMS trousseaux de AWS Encryption SDK clés, ils génèrent et protègent les clés de chiffrement qui protègent vos données. AWS KMS
Vous n'avez pas besoin de l'installer AWS SDK pour C\$1\$1 si vous utilisez un autre type de trousseau de clés, tel qu'un trousseau de clés AES brut, un trousseau de clés RSA brut ou un trousseau de clés multiple qui n'inclut pas de trousseau de clés. AWS KMS Toutefois, lorsque vous utilisez un type de trousseau de clés brut, vous devez générer et protéger vos propres clés d'encapsulation brutes.
Si vous rencontrez des difficultés avec votre installation, [signalez le problème dans le `aws-encryption-sdk-c` référentiel ou utilisez l'un](https://github.com/aws/aws-encryption-sdk-c/issues) des liens de commentaires sur cette page.
# En utilisant le Kit SDK de chiffrement AWS pour C
Cette rubrique décrit certaines des fonctionnalités Kit SDK de chiffrement AWS pour C qui ne sont pas prises en charge dans d'autres implémentations de langages de programmation.
Les exemples présentés dans cette section montrent comment utiliser [la version 2.0. ](about-versions.md)*x* et versions ultérieures du Kit SDK de chiffrement AWS pour C. Pour les exemples utilisant des versions antérieures, recherchez votre version dans la liste des [versions](https://github.com/aws/aws-encryption-sdk-c/releases) du [aws-encryption-sdk-c référentiel](https://github.com/aws/aws-encryption-sdk-c/) sur GitHub.
Pour plus de détails sur la programmation avec le Kit SDK de chiffrement AWS pour C, consultez les [exemples en C](c-examples.md), les [exemples](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) du [aws-encryption-sdk-c référentiel](https://github.com/aws/aws-encryption-sdk-c/) et la [documentation de l'Kit SDK de chiffrement AWS pour C API](https://aws.github.io/aws-encryption-sdk-c/html/). GitHub
Voir aussi : [Porte-clés](choose-keyring.md)
**Topics**
+ [Modèles de chiffrement et de déchiffrement des données](#c-language-using-pattern)
+ [Comptage des références](#c-language-using-release)
## Modèles de chiffrement et de déchiffrement des données
Lorsque vous utilisez le Kit SDK de chiffrement AWS pour C, vous suivez un schéma similaire à celui-ci : créez un trousseau de [clés](concepts.md#keyring), créez un [CMM](concepts.md#crypt-materials-manager) qui utilise le trousseau de clés, créez une session qui utilise le CMM (et le trousseau de clés), puis traitez la session.
1. Chargez les chaînes d'erreur.
Appelez la `aws_cryptosdk_load_error_strings()` méthode dans votre code C ou C\$1\$1. Il charge des informations d'erreur très utiles pour le débogage.
Vous n'avez besoin de l'appeler qu'une seule fois, comme dans votre `main` méthode.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
2. Créez un porte-clés.
Configurez votre [porte-clés](concepts.md#keyring) avec les clés d'encapsulage que vous souhaitez utiliser pour chiffrer vos clés de données. Cet exemple utilise un [AWS KMS porte-clés avec un porte-clés](use-kms-keyring.md) AWS KMS key, mais vous pouvez utiliser n'importe quel type de porte-clés à sa place.
Pour identifier un élément AWS KMS key dans un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour C, spécifiez un [ARN clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) ou un [alias ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Dans un porte-clés de déchiffrement, vous devez utiliser un ARN de clé. Pour en savoir plus, consultez [Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id).
```
const char * KEY_ARN = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
struct aws_cryptosdk_keyring *kms_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(KEY_ARN);
```
3. Créez une session.
Dans le Kit SDK de chiffrement AWS pour C, vous utilisez une *session* pour chiffrer un seul message en texte brut ou déchiffrer un seul message chiffré, quelle que soit sa taille. La session conserve l'état du message tout au long de son traitement.
Configurez votre session avec un allocateur, un porte-clés et un mode : `AWS_CRYPTOSDK_ENCRYPT` ou `AWS_CRYPTOSDK_DECRYPT`. Si vous devez modifier le mode de la session, utilisez la méthode `aws_cryptosdk_session_reset`.
Lorsque vous créez une session avec un trousseau de clés, un gestionnaire de matériel cryptographique (CMM) par défaut est Kit SDK de chiffrement AWS pour C automatiquement créé pour vous. Vous n'avez pas besoin de créer, de maintenir ou de détruire cet objet.
Par exemple, la session suivante utilise l'allocateur et le porte-clés qui a été défini à l'étape 1. Lorsque vous chiffrez des données, le mode est `AWS_CRYPTOSDK_ENCRYPT`.
```
struct aws_cryptosdk_session * session = aws_cryptosdk_session_new_from_keyring_2(allocator, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);
```
4. Chiffrez ou déchiffrez les données.
Pour traiter les données de la session, utilisez la méthode `aws_cryptosdk_session_process`. Si le tampon d'entrée est suffisamment grand pour contenir l'intégralité du texte en clair et que le tampon de sortie est suffisamment grand pour contenir l'intégralité du texte chiffré, vous pouvez appeler. `aws_cryptosdk_session_process_full` Toutefois, si vous devez gérer des données en streaming, vous pouvez effectuer un appel `aws_cryptosdk_session_process` en boucle. Pour de plus amples informations, vous pouvez consulter l'exemple [file\$1streaming.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/file_streaming.cpp). `aws_cryptosdk_session_process_full`Il est introduit dans AWS Encryption SDK les versions 1.9. *x* et 2.2. *x.*
Lorsque la session est configurée pour chiffrer des données, les champs de texte brut décrivent les champs d'entrée et les champs du texte chiffré décrivent la sortie. Le champ `plaintext` contient le message que vous souhaitez chiffrer et le champ `ciphertext` obtient le [message chiffré](message-format.md) renvoyé par la méthode de chiffrement
```
/* Encrypting data */
aws_cryptosdk_session_process_full(session,
ciphertext,
ciphertext_buffer_size,
&ciphertext_length,
plaintext,
plaintext_length)
```
Lorsque la session est configurée pour déchiffrer des données, les champs de texte chiffré décrivent les champs d'entrée et les champs du texte brut décrivent la sortie. Le champ `ciphertext` contient le [message chiffré](message-format.md) renvoyé par la méthode de chiffrement, et le champ `plaintext` obtient le message en texte brut renvoyé par la méthode de déchiffrement.
Pour déchiffrer les données, appelez la méthode `aws_cryptosdk_session_process_full`.
```
/* Decrypting data */
aws_cryptosdk_session_process_full(session,
plaintext,
plaintext_buffer_size,
&plaintext_length,
ciphertext,
ciphertext_length)
```
## Comptage des références
Pour éviter les fuites de mémoire, assurez-vous de libérer vos références à tous les objets que vous créez lorsque vous en avez terminé avec eux. Dans le cas contraire, des fuites de mémoire se produisent. Le kit SDK fournit des méthodes pour faciliter cette tâche.
Chaque fois que vous créez un objet parent avec l'un des objets enfants suivants, l'objet parent obtient et conserve une référence à l'objet enfant, comme suit :
+ Un [porte-clés](concepts.md#keyring), tel que la création d'une session avec un porte-clés
+ Un [gestionnaire de matériaux cryptographiques](concepts.md#crypt-materials-manager) (CMM) par défaut, tel que la création d'une session ou un CMM personnalisé avec un CMM par défaut
+ Un [cache de clés de données](data-key-caching.md), tel que la création d'un CMM de mise en cache avec un porte-clés et un cache
Sauf si vous avez besoin d'une référence indépendante à l'objet enfant, vous pouvez libérer votre référence à l'objet enfant dès que vous créez l'objet parent. La référence restante à l'objet enfant est libérée lorsque l'objet parent est détruit. Ce modèle garantit que vous conservez la référence à chaque objet uniquement pendant le délai nécessaire et empêche les fuites de mémoire en raison de références non libérées.
Vous êtes uniquement responsable de la libération des références aux objets enfants que vous créez explicitement. Vous n'êtes pas responsable de la gestion des références aux objets créés par le SDK pour vous. Si le SDK crée un objet, tel que le CMM par défaut que la `aws_cryptosdk_caching_cmm_new_from_keyring` méthode ajoute à une session, le SDK gère la création et la destruction de l'objet et de ses références.
Dans l'exemple suivant, lorsque vous créez une session avec un [porte-clés](concepts.md#keyring), la session obtient une référence au porte-clés et conserve cette référence jusqu'à ce que la session soit détruite. Si vous n'avez pas besoin de conserver une référence supplémentaire au porte-clés, vous pouvez utiliser la méthode `aws_cryptosdk_keyring_release` pour libérer l'objet de porte-clés dès que la session est créée. Cette méthode diminue le nombre de références pour le porte-clés. La référence de la session au porte-clés est libérée lorsque vous appelez `aws_cryptosdk_session_destroy` pour détruire la session.
```
// The session gets a reference to the keyring.
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_ENCRYPT, keyring);
// After you create a session with a keyring, release the reference to the keyring object.
aws_cryptosdk_keyring_release(keyring);
```
Pour les tâches plus complexes, telles que la réutilisation d'un trousseau de clés pour plusieurs sessions ou la spécification d'une suite d'algorithmes dans un CMM, vous devrez peut-être conserver une référence indépendante à l'objet. Si c'est le cas, n'appelez pas les méthodes de publication immédiatement. Au lieu de cela, libérez vos références lorsque vous n'utilisez plus les objets, en plus de détruire la session.
Cette technique de comptage de références fonctionne également lorsque vous utilisez une alternative CMMs, telle que le CMM de mise en cache pour la mise en cache [des clés de données](data-key-caching.md). Lorsque vous créez un CMM de mise en cache à partir d'un cache et d'un trousseau de clés, le CMM de mise en cache obtient une référence aux deux objets. À moins que vous n'en ayez besoin pour une autre tâche, vous pouvez libérer vos références indépendantes au cache et au trousseau de clés dès que le CMM de mise en cache est créé. Ensuite, lorsque vous créez une session avec le CMM de mise en cache, vous pouvez libérer votre référence au CMM de mise en cache.
Notez que vous êtes uniquement responsable de la publication des références aux objets que vous créez explicitement. Les objets que les méthodes créent pour vous, tels que le CMM par défaut qui sous-tend le CMM de mise en cache, sont gérés par la méthode.
```
/ Create the caching CMM from a cache and a keyring.
struct aws_cryptosdk_cmm *caching_cmm = aws_cryptosdk_caching_cmm_new_from_keyring(allocator, cache, kms_keyring, NULL, 60, AWS_TIMESTAMP_SECS);
// Release your references to the cache and the keyring.
aws_cryptosdk_materials_cache_release(cache);
aws_cryptosdk_keyring_release(kms_keyring);
// Create a session with the caching CMM.
struct aws_cryptosdk_session *session = aws_cryptosdk_session_new_from_cmm_2(allocator, AWS_CRYPTOSDK_ENCRYPT, caching_cmm);
// Release your references to the caching CMM.
aws_cryptosdk_cmm_release(caching_cmm);
// ...
aws_cryptosdk_session_destroy(session);
```
# Kit SDK de chiffrement AWS pour C exemples
Les exemples suivants vous montrent comment utiliser le Kit SDK de chiffrement AWS pour C pour chiffrer et déchiffrer des données.
Les exemples présentés dans cette section montrent comment utiliser les versions 2.0. *x* et versions ultérieures du Kit SDK de chiffrement AWS pour C. Pour les exemples utilisant des versions antérieures, recherchez votre version dans la liste des [versions](https://github.com/aws/aws-encryption-sdk-c/releases) du [aws-encryption-sdk-c référentiel](https://github.com/aws/aws-encryption-sdk-c/) sur GitHub.
Lorsque vous installez et compilez le Kit SDK de chiffrement AWS pour C, le code source de ces exemples et d'autres exemples est inclus dans le `examples` sous-répertoire, puis compilé et intégré au `build` répertoire. Vous pouvez également les trouver dans le sous-répertoire des [exemples](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) du [aws-encryption-sdk-c](https://github.com/aws/aws-encryption-sdk-c/)référentiel sur GitHub.
**Topics**
+ [Chiffrement et déchiffrement de chaînes](#c-example-strings)
## Chiffrement et déchiffrement de chaînes
L'exemple suivant montre comment utiliser le Kit SDK de chiffrement AWS pour C pour chiffrer et déchiffrer une chaîne.
Cet exemple présente le [AWS KMS trousseau de clés](use-kms-keyring.md), un type de trousseau de clés qui utilise un AWS KMS key in [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/) pour générer et chiffrer des clés de données. L'exemple inclut du code écrit en C\$1\$1. Kit SDK de chiffrement AWS pour C Nécessite AWS SDK pour C\$1\$1 d'appeler AWS KMS lorsque vous utilisez un trousseau de AWS KMS clés. Si vous utilisez un trousseau de clés qui n'interagit pas avec AWS KMS, tel qu'un trousseau de clés AES brut, un trousseau de clés RSA brut ou un trousseau de clés multiple qui n'inclut pas de trousseau de clés, ce n'est pas obligatoire AWS KMS . AWS SDK pour C\$1\$1
Pour obtenir de l'aide sur la création d'un AWS KMS key, consultez la section [Création de clés](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) dans le *guide du AWS Key Management Service développeur*. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voir[Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id).
**Consultez l'exemple de code complet** : [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/string.cpp)
**Topics**
+ [Chiffrement d'une chaîne](#c-example-string-encrypt)
+ [Déchiffrement d'une chaîne](#c-example-string-decrypt)
### Chiffrement d'une chaîne
La première partie de cet exemple utilise un AWS KMS trousseau de clés avec un AWS KMS key pour chiffrer une chaîne en texte brut.
Étape 1. Chargez les chaînes d'erreur.
Appelez la `aws_cryptosdk_load_error_strings()` méthode dans votre code C ou C\$1\$1. Il charge des informations d'erreur très utiles pour le débogage.
Vous n'avez besoin de l'appeler qu'une seule fois, comme dans votre `main` méthode.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
Étape 2 : Construisez le porte-clés.
Créez un AWS KMS trousseau de clés pour le chiffrement. Dans cet exemple, le trousseau de clés est configuré avec un seul AWS KMS key, mais vous pouvez configurer un AWS KMS trousseau de clés avec plusieurs AWS KMS keys, y compris AWS KMS keys dans des comptes différents Régions AWS et différents.
Pour identifier un élément AWS KMS key dans un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour C, spécifiez un [ARN clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) ou un [alias ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Dans un porte-clés de déchiffrement, vous devez utiliser un ARN de clé. Pour en savoir plus, consultez [Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id).
[Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id)
Lorsque vous créez un jeu de clés comportant plusieurs clés AWS KMS keys, vous spécifiez le code AWS KMS key utilisé pour générer et chiffrer la clé de données en texte brut, ainsi qu'un tableau facultatif de clés supplémentaires AWS KMS keys qui chiffrent la même clé de données en texte brut. Dans ce cas, vous ne spécifiez que le générateur AWS KMS key.
Avant d'exécuter ce code, remplacez l'exemple d'ARN de clé par un ARN valide.
```
const char * key_arn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
struct aws_cryptosdk_keyring *kms_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
```
Étape 3 : Création d'une session.
Créez une session à l'aide de l'allocateur, d'un énumérateur de mode et du porte-clés.
Chaque session nécessite un mode : soit `AWS_CRYPTOSDK_ENCRYPT` pour chiffrer, soit `AWS_CRYPTOSDK_DECRYPT` pour déchiffrer. Pour modifier le mode d'une session existante, utilisez la méthode `aws_cryptosdk_session_reset`.
Après avoir créé une session avec le porte-clés, vous pouvez libérer votre référence au porte-clés à l'aide de la méthode fournie par le kit SDK. La session conserve une référence à l'objet de porte-clés pendant sa durée de vie. Les références aux objets de porte-clés et de session sont libérées lorsque vous détruisez la session. Cette technique de [comptage de référence](c-language-using.md#c-language-using-release) permet d'éviter les fuites de mémoire et d'empêcher la libération des objets pendant leur utilisation.
```
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);
/* When you add the keyring to the session, release the keyring object */
aws_cryptosdk_keyring_release(kms_keyring);
```
Étape 4 : Définition du contexte de chiffrement.
Un [contexte de chiffrement](concepts.md#encryption-context) est un ensemble de données authentifiées supplémentaires non secrètes et arbitraires. Lorsque vous fournissez un contexte de chiffrement sur Encrypt, le contexte de chiffrement lie AWS Encryption SDK cryptographiquement le contexte de chiffrement au texte chiffré afin que le même contexte de chiffrement soit requis pour déchiffrer les données. L'utilisation d'un contexte de chiffrement est facultative, mais nous vous le recommandons dans le cadre des bonnes pratiques.
Tout d'abord, créez une table de hachage qui inclut le contexte de chiffrement des chaînes.
```
/* Allocate a hash table for the encryption context */
int set_up_enc_ctx(struct aws_allocator *alloc, struct aws_hash_table *my_enc_ctx)
// Create encryption context strings
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_key1, "Example");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_value1, "String");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_key2, "Company");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_value2, "MyCryptoCorp");
// Put the key-value pairs in the hash table
aws_hash_table_put(my_enc_ctx, enc_ctx_key1, (void *)enc_ctx_value1, &was_created)
aws_hash_table_put(my_enc_ctx, enc_ctx_key2, (void *)enc_ctx_value2, &was_created)
```
Obtenez un pointeur réversible dans le contexte de chiffrement de la session. Ensuite, utilisez la fonction `aws_cryptosdk_enc_ctx_clone` pour copier le contexte de chiffrement dans la session. Conservez la copie dans `my_enc_ctx` afin de pouvoir valider la valeur après le déchiffrement des données.
Le contexte de chiffrement fait partie de la session. Il ne s'agit pas d'un paramètre transmis à la fonction du processus de session. Cela garantit que le même contexte de chiffrement est utilisé pour chaque segment d'un message, même si la fonction du processus de session est appelée plusieurs fois pour chiffrer l'intégralité du message.
```
struct aws_hash_table *session_enc_ctx = aws_cryptosdk_session_get_enc_ctx_ptr_mut(session);
aws_cryptosdk_enc_ctx_clone(alloc, session_enc_ctx, my_enc_ctx)
```
Étape 5 : Chiffrement de la chaîne.
Pour chiffrer la chaîne en texte brut, utilisez la méthode `aws_cryptosdk_session_process_full` avec la session dans le mode de chiffrement. Cette méthode, introduite dans AWS Encryption SDK les versions 1.9. *x* et 2.2. *x*, est conçu pour le chiffrement et le déchiffrement sans diffusion en continu. Pour gérer les données en streaming, appelez le `aws_cryptosdk_session_process` in a loop.
Lors du chiffrement, les champs de texte brut sont des champs d'entrée ; les champs de texte chiffré sont des champs de sortie. Une fois le traitement terminé, le champ `ciphertext_output` contient le [message chiffré](concepts.md#message), y compris le texte chiffré réel, des clés de données chiffrées et le contexte de chiffrement. Vous pouvez déchiffrer ce message crypté à l'aide de n'importe quel langage AWS Encryption SDK de programmation pris en charge.
```
/* Gets the length of the plaintext that the session processed */
size_t ciphertext_len_output;
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(session,
ciphertext_output,
ciphertext_buf_sz_output,
&ciphertext_len_output,
plaintext_input,
plaintext_len_input)) {
aws_cryptosdk_session_destroy(session);
return 8;
}
```
Étape 6 : Nettoyage de la session.
La dernière étape détruit la session, y compris les références au CMM et au trousseau de clés.
Si vous préférez, au lieu de détruire la session, vous pouvez la réutiliser avec le même jeu de clés et le même CMM pour déchiffrer la chaîne, ou pour chiffrer ou déchiffrer d'autres messages. Pour utiliser la session pour le déchiffrement, utilisez la méthode `aws_cryptosdk_session_reset` pour modifier le mode vers `AWS_CRYPTOSDK_DECRYPT`.
### Déchiffrement d'une chaîne
La deuxième partie de cet exemple consiste à déchiffrer un message chiffré qui contient le texte chiffré de la chaîne d'origine.
Étape 1 : Chargez les chaînes d'erreur.
Appelez la `aws_cryptosdk_load_error_strings()` méthode dans votre code C ou C\$1\$1. Il charge des informations d'erreur très utiles pour le débogage.
Vous n'avez besoin de l'appeler qu'une seule fois, comme dans votre `main` méthode.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
Étape 2 : Construisez le porte-clés.
Lorsque vous déchiffrez des données AWS KMS, vous transmettez le [message crypté renvoyé](concepts.md#message) par l'API de chiffrement. L'[API Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) ne prend pas d'entrée AWS KMS key AS. Il AWS KMS utilise plutôt le même code AWS KMS key pour déchiffrer le texte chiffré utilisé pour le chiffrer. Cependant, il vous AWS Encryption SDK permet de spécifier un AWS KMS trousseau de clés sans AWS KMS keys chiffrement ni déchiffrement.
Lors du déchiffrement, vous pouvez configurer un trousseau de clés contenant uniquement le code AWS KMS keys que vous souhaitez utiliser pour déchiffrer le message chiffré. Par exemple, vous souhaiterez peut-être créer un trousseau de clés contenant uniquement le AWS KMS key code utilisé par un rôle spécifique au sein de votre organisation. Ils n' AWS Encryption SDK utiliseront jamais un à AWS KMS key moins qu'il n'apparaisse dans le trousseau de clés de déchiffrement. Si le SDK ne parvient pas à déchiffrer les clés de données chiffrées AWS KMS keys à l'aide du trousseau de clés que vous fournissez, soit parce qu'aucun élément du jeu de AWS KMS keys clés n'a été utilisé pour chiffrer les clés de données, soit parce que l'appelant n'est pas autorisé à utiliser le trousseau de clés pour les déchiffrer, l' AWS KMS keys appel de déchiffrement échoue.
Lorsque vous spécifiez un AWS KMS key pour un trousseau de clés de déchiffrement, vous devez utiliser son [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) clé. ARNsLes [alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) ne sont autorisés que dans les trousseaux de clés de chiffrement. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voir[Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id).
Dans cet exemple, nous indiquons un trousseau de clés configuré avec le même que celui AWS KMS key utilisé pour chiffrer la chaîne. Avant d'exécuter ce code, remplacez l'exemple d'ARN de clé par un ARN valide.
```
const char * key_arn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
struct aws_cryptosdk_keyring *kms_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
```
Étape 3 : Création d'une session.
Créez une session à l'aide de l'allocateur et du porte-clés. Pour configurer la session pour le déchiffrement, configurez la session avec le mode `AWS_CRYPTOSDK_DECRYPT`.
Après avoir créé une session avec un porte-clés, vous pouvez libérer votre référence au porte-clés à l'aide de la méthode fournie par le kit SDK. La session conserve une référence à l'objet de porte-clés pendant sa durée de vie, et la session et le porte-clés sont tous les deux libérés lorsque vous détruisez la session. Cette technique de comptage de référence permet d'éviter les fuites de mémoire et d'empêcher la libération des objets pendant leur utilisation.
```
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
/* When you add the keyring to the session, release the keyring object */
aws_cryptosdk_keyring_release(kms_keyring);
```
Étape 4 : Déchiffrement de la chaîne.
Pour déchiffrer la chaîne, utilisez la méthode `aws_cryptosdk_session_process_full` avec la session qui est configurée pour le déchiffrement. Cette méthode, introduite dans AWS Encryption SDK les versions 1.9. *x* et 2.2. *x*, est conçu pour le chiffrement et le déchiffrement sans diffusion en continu. Pour gérer les données en streaming, appelez le `aws_cryptosdk_session_process` in a loop.
Lors du déchiffrement, les champs de texte chiffré sont des champs d'entrée et les champs de texte brut sont des champs de sortie. Le champ `ciphertext_input` contient le [message chiffré](message-format.md) renvoyé par la méthode de chiffrement. Une fois le traitement terminé, le champ `plaintext_output` contient la chaîne en texte brut (déchiffrée).
```
size_t plaintext_len_output;
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(session,
plaintext_output,
plaintext_buf_sz_output,
&plaintext_len_output,
ciphertext_input,
ciphertext_len_input)) {
aws_cryptosdk_session_destroy(session);
return 13;
}
```
Étape 5 : Vérification du contexte de chiffrement.
Assurez-vous que le contexte de chiffrement réel, celui qui a été utilisé pour déchiffrer le message, contient le contexte de chiffrement que vous avez fourni lors du chiffrement du message. Le contexte de chiffrement réel peut inclure des paires supplémentaires. En effet, [le gestionnaire de matériaux cryptographiques](concepts.md#crypt-materials-manager) (CMM) peut ajouter des paires au contexte de chiffrement fourni avant de chiffrer le message.
Dans le Kit SDK de chiffrement AWS pour C, vous n'êtes pas obligé de fournir un contexte de chiffrement lors du déchiffrement, car le contexte de chiffrement est inclus dans le message chiffré renvoyé par le SDK. Toutefois, avant qu'elle ne renvoie le message en texte brut, votre fonction de déchiffrement doit vérifier que toutes les paires du contexte de chiffrement fourni apparaissent dans le contexte de chiffrement qui a été utilisé pour déchiffrer le message.
Tout d'abord, obtenez un pointeur en lecture seule à la table de hachage de la session. Cette table de hachage contient le contexte de chiffrement qui a été utilisé pour déchiffrer le message.
```
const struct aws_hash_table *session_enc_ctx = aws_cryptosdk_session_get_enc_ctx_ptr(session);
```
Ensuite, parcourez le contexte de chiffrement dans la table de hachage `my_enc_ctx` que vous avez copiée lors du chiffrement. Vérifiez que chaque paire de la table de hachage `my_enc_ctx` qui a été utilisée pour chiffrer s'affiche dans la table de hachage `session_enc_ctx` qui a été utilisée pour déchiffrer. Si une clé est manquante ou si cette clé a une valeur différente, arrêtez le traitement et écrivez un message d'erreur.
```
for (struct aws_hash_iter iter = aws_hash_iter_begin(my_enc_ctx); !aws_hash_iter_done(&iter);
aws_hash_iter_next(&iter)) {
struct aws_hash_element *session_enc_ctx_kv_pair;
aws_hash_table_find(session_enc_ctx, iter.element.key, &session_enc_ctx_kv_pair)
if (!session_enc_ctx_kv_pair ||
!aws_string_eq(
(struct aws_string *)iter.element.value, (struct aws_string *)session_enc_ctx_kv_pair->value)) {
fprintf(stderr, "Wrong encryption context!\n");
abort();
}
}
```
Étape 6 : Nettoyage de la session.
Après avoir vérifié le contexte de chiffrement, vous pouvez détruire la session ou la réutiliser. Si vous devez reconfigurer la session, utilisez la `aws_cryptosdk_session_reset` méthode.
```
aws_cryptosdk_session_destroy(session);
```
# AWS Encryption SDK pour .NET
AWS Encryption SDK for .NET est une bibliothèque de chiffrement côté client 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.
**Note**
La version 4.0.0 de AWS Encryption SDK for .NET s'écarte de la spécification du AWS Encryption SDK message. Par conséquent, les messages chiffrés par la version 4.0.0 ne peuvent être déchiffrés que par la version 4.0.0 ou ultérieure pour .NET. AWS Encryption SDK Ils ne peuvent être déchiffrés par aucune autre implémentation de langage de programmation.
La version 4.0.1 de AWS Encryption SDK for .NET écrit des messages conformément à la spécification des AWS Encryption SDK messages et est interopérable avec d'autres implémentations de langages de programmation. Par défaut, la version 4.0.1 peut lire les messages chiffrés par la version 4.0.0. Toutefois, si vous ne souhaitez pas déchiffrer les messages chiffrés par la version 4.0.0, vous pouvez spécifier la [https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/NetV4_0_0Example.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/NetV4_0_0Example.cs)propriété pour empêcher le client de lire ces messages. Pour plus d'informations, consultez les [notes de mise à jour de la version 4.0.1](https://github.com/aws/aws-encryption-sdk/releases/tag/v4.0.1) dans le aws-encryption-sdk référentiel sur. GitHub
Le AWS Encryption SDK pour .NET se distingue de certaines des autres implémentations du langage de programmation de la AWS Encryption SDK manière suivante :
+ Aucune prise en charge de la mise en [cache des clés de données](data-key-caching.md)
**Note**
La version 4. *x* of the AWS Encryption SDK for .NET prend en charge le [keyring AWS KMS hiérarchique](use-hierarchical-keyring.md), une solution alternative de mise en cache des matériaux cryptographiques.
+ Pas de support pour le streaming de données
+ [Pas de journalisation ni de traces de pile](#dot-net-debugging) AWS Encryption SDK pour .NET
+ [Nécessite le AWS SDK pour .NET](#dot-net-install)
Le AWS Encryption SDK pour .NET inclut toutes les fonctionnalités de sécurité introduites dans les versions 2.0. *x* et versions ultérieures d'autres implémentations linguistiques du AWS Encryption SDK. Toutefois, si vous utilisez le AWS Encryption SDK pour .NET pour déchiffrer des données chiffrées par une version antérieure à la version 2.0. version *x*, autre implémentation linguistique du AWS Encryption SDK, vous devrez peut-être ajuster votre [politique d'engagement](concepts.md#commitment-policy). Pour en savoir plus, consultez [Comment définir votre politique d'engagement](migrate-commitment-policy.md#migrate-commitment-step1).
Le AWS Encryption SDK for .NET est un produit de AWS Encryption SDK in [Dafny](https://github.com/dafny-lang/dafny/blob/master/README.md), un langage de vérification formel dans lequel vous écrivez des spécifications, le code pour les implémenter et les preuves pour les tester. Le résultat est une bibliothèque qui implémente les fonctionnalités du AWS Encryption SDK dans un framework garantissant l'exactitude fonctionnelle.
**En savoir plus**
+ Pour des exemples montrant comment configurer des options dans le AWS Encryption SDK, telles que la spécification d'une suite d'algorithmes alternative, la limitation des clés de données chiffrées et l'utilisation de clés AWS KMS multirégionales, voir[Configuration du AWS Encryption SDK](configure.md).
+ Pour plus de détails sur la programmation avec le AWS Encryption SDK pour .NET, consultez le [https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/)répertoire du aws-encryption-sdk référentiel sur GitHub.
**Topics**
+ [Installation et génération](#dot-net-install)
+ [Débogage](#dot-net-debugging)
+ [Exemples](dot-net-examples.md)
## Installation du AWS Encryption SDK pour .NET
Le AWS Encryption SDK pour .NET est disponible sous forme de [https://www.nuget.org/packages/AWS.Cryptography.EncryptionSDK](https://www.nuget.org/packages/AWS.Cryptography.EncryptionSDK)package dans NuGet. Pour plus de détails sur l'installation et la génération du fichier AWS Encryption SDK pour .NET, consultez le fichier [README.md](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/#readme) dans le référentiel. `aws-encryption-sdk-net`
**Version 3.x**
Version 3. *x* of the AWS Encryption SDK for .NET prend en charge .NET Framework 4.5.2 à 4.8 uniquement sous Windows. Il prend en charge .NET Core 3.0\$1, .NET 5.0 et versions ultérieures sur tous les systèmes d'exploitation pris en charge.
**Version 4.x**
La version 4. *x* of the AWS Encryption SDK for .NET prend en charge .NET 6.0 et .NET Framework net48 et versions ultérieures. La version 4. *x* nécessite le AWS SDK pour .NET v3.
**Version 5.x**
La version 5. *x* of the AWS Encryption SDK for .NET prend en charge .NET 6.0 et .NET Framework net48 et versions ultérieures. La version 5. *x* nécessite la version 2. *x* de la Material Providers Library (MPL) et du AWS SDK pour .NET v4.
AWS Encryption SDK Pour .NET, les touches « SDK pour .NET même si vous n'utilisez pas AWS Key Management Service (AWS KMS) » sont requises. Il est installé avec le NuGet package. Toutefois, sauf si vous utilisez AWS KMS des clés, AWS Encryption SDK car .NET ne nécessite pas d' Compte AWS AWS informations d'identification ou d'interaction avec un AWS service. Pour obtenir de l'aide pour configurer un AWS compte si vous en avez besoin, consultez[En utilisant le AWS Encryption SDK avec AWS KMS](getting-started.md).
## Débogage du AWS Encryption SDK pour .NET
Le AWS Encryption SDK for .NET ne génère aucun journal. Les exceptions dans le AWS Encryption SDK fichier for .NET 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 le fichier .NET SDK pour .NET de celles qui se produisent dans le AWS Encryption SDK fichier .NET. Pour obtenir de l'aide SDK pour .NET concernant la journalisation, consultez [AWSLogging](https://docs.aws.amazon.com/sdk-for-net/v4/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**.)
# AWS Encryption SDK pour des exemples .NET
Les exemples suivants montrent les modèles de codage de base que vous utilisez lors de la programmation avec le AWS Encryption SDK pour .NET. Plus précisément, vous instanciez la bibliothèque AWS Encryption SDK et les fournisseurs de matériaux. Ensuite, avant d'appeler chaque méthode, vous instanciez un objet qui définit l'entrée de la méthode. Cela ressemble beaucoup au modèle de codage que vous utilisez dans le SDK pour .NET.
Pour des exemples montrant comment configurer des options dans le AWS Encryption SDK, telles que la spécification d'une suite d'algorithmes alternative, la limitation des clés de données chiffrées et l'utilisation de clés AWS KMS multirégionales, voir[Configuration du AWS Encryption SDK](configure.md).
Pour plus d'exemples de programmation avec le AWS Encryption SDK pour .NET, consultez les [exemples](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples) dans le `aws-encryption-sdk-net` répertoire du `aws-encryption-sdk` référentiel sur GitHub.
## Chiffrer des données dans le AWS Encryption SDK pour .NET
Cet exemple montre le schéma de base pour le chiffrement des données. Il chiffre un petit fichier avec des clés de données protégées par une clé AWS KMS d'encapsulation.
Étape 1 : Instancier la bibliothèque AWS Encryption SDK et la bibliothèque des fournisseurs de matériaux.
Commencez par instancier la bibliothèque AWS Encryption SDK et les fournisseurs de matériaux. Vous allez utiliser les méthodes décrites dans le AWS Encryption SDK pour chiffrer et déchiffrer les données. Vous allez utiliser les méthodes de la bibliothèque des fournisseurs de matériel pour créer les porte-clés qui spécifient les clés qui protègent vos données.
La façon dont vous instanciez la bibliothèque AWS Encryption SDK et la bibliothèque des fournisseurs de matériaux diffère selon les versions 3. *x* et 4. *x* du AWS Encryption SDK pour .NET. Toutes les étapes suivantes sont identiques pour les deux versions 3. *x* et 4. *x* du AWS Encryption SDK pour .NET.
```
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
```
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
```
Étape 2 : Créez un objet de saisie pour le trousseau de clés.
Chaque méthode qui crée un trousseau de clés possède une classe d'objet d'entrée correspondante. Par exemple, pour créer l'objet d'entrée pour la `CreateAwsKmsKeyring()` méthode, créez une instance de la `CreateAwsKmsKeyringInput` classe.
Même si l'entrée de ce trousseau de clés ne spécifie pas de [clé de générateur](use-kms-keyring.md#kms-keyring-encrypt), la clé KMS unique spécifiée par le `KmsKeyId` paramètre est la clé de générateur. Il génère et chiffre la clé de données qui chiffre les données.
Cet objet d'entrée nécessite un AWS KMS client pour Région AWS la clé KMS. Pour créer un AWS KMS client, instanciez la `AmazonKeyManagementServiceClient` classe dans le. SDK pour .NET L'appel du `AmazonKeyManagementServiceClient()` constructeur sans paramètres crée un client avec les valeurs par défaut.
Dans un AWS KMS trousseau de clés utilisé pour le chiffrement avec .NET, vous pouvez [identifier AWS Encryption SDK les clés KMS à l'aide de l'](use-kms-keyring.md#kms-keyring-id)ID de clé, de l'ARN de la clé, du nom de l'alias ou de l'ARN de l'alias. Dans un AWS KMS trousseau de clés utilisé pour le déchiffrement, vous devez utiliser un ARN de clé pour identifier chaque clé KMS. Si vous prévoyez de réutiliser votre jeu de clés de chiffrement pour le déchiffrer, utilisez un identifiant ARN pour toutes les clés KMS.
```
string keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
// Instantiate the keyring input object
var kmsKeyringInput = new CreateAwsKmsKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = keyArn
};
```
Étape 3 : Créez le porte-clés.
Pour créer le trousseau de clés, appelez la méthode du trousseau avec l'objet de saisie du trousseau de clés. Cet exemple utilise la `CreateAwsKmsKeyring()` méthode, qui n'utilise qu'une seule clé KMS.
```
var keyring = materialProviders.CreateAwsKmsKeyring(kmsKeyringInput);
```
Étape 4 : définir un contexte de chiffrement
Un [contexte de chiffrement](concepts.md#encryption-context) est un élément facultatif, mais fortement recommandé, des opérations cryptographiques dans le AWS Encryption SDK. Vous pouvez définir une ou plusieurs paires clé-valeur non secrètes.
Avec la version 4. *x* de AWS Encryption SDK pour .NET, vous pouvez exiger un contexte de chiffrement dans toutes les demandes de chiffrement avec le [contexte de chiffrement requis CMM](configure.md#config-required-encryption-context-cmm).
```
// Define the encryption context
var encryptionContext = new Dictionary()
{
{"purpose", "test"}
};
```
Étape 5 : Créez l'objet d'entrée pour le chiffrement.
Avant d'appeler la `Encrypt()` méthode, créez une instance de la `EncryptInput` classe.
```
string plaintext = File.ReadAllText("C:\\Documents\\CryptoTest\\TestFile.txt");
// Define the encrypt input
var encryptInput = new EncryptInput
{
Plaintext = plaintext,
Keyring = keyring,
EncryptionContext = encryptionContext
};
```
Étape 6 : Chiffrez le texte en clair.
Utilisez la `Encrypt()` méthode du AWS Encryption SDK pour chiffrer le texte en clair à l'aide du trousseau de clés que vous avez défini.
La `EncryptOutput` `Encrypt() ` méthode renvoie des méthodes pour obtenir le message crypté (`Ciphertext`), le contexte de chiffrement et la suite d'algorithmes.
```
var encryptOutput = encryptionSdk.Encrypt(encryptInput);
```
Étape 7 : Obtenez le message crypté.
La `Decrypt()` méthode décrite dans AWS Encryption SDK for .NET prend le `Ciphertext` membre de l'`EncryptOutput`instance.
Le `Ciphertext` membre de l'`EncryptOutput`objet est le [message chiffré](concepts.md#message), un objet portable qui inclut les données chiffrées, les clés de données chiffrées et les métadonnées, y compris le contexte de chiffrement. Vous pouvez stocker le message crypté en toute sécurité pendant une période prolongée ou le soumettre à la `Decrypt()` méthode pour récupérer le texte en clair.
```
var encryptedMessage = encryptOutput.Ciphertext;
```
## Déchiffrement en mode strict dans le fichier pour .NET AWS Encryption SDK
Les meilleures pratiques recommandent de spécifier les clés que vous utilisez pour déchiffrer les données, une option connue sous le nom de *mode strict*. AWS Encryption SDK Utilise uniquement les clés KMS que vous spécifiez dans votre trousseau de clés pour déchiffrer le texte chiffré. Les clés de votre jeu de clés de déchiffrement doivent inclure au moins l'une des clés qui ont chiffré les données.
Cet exemple montre le schéma de base du déchiffrement en mode strict avec le AWS Encryption SDK pour .NET.
Étape 1 : Instancier la bibliothèque AWS Encryption SDK et les fournisseurs de matériaux.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
```
Étape 2 : Créez l'objet de saisie pour votre trousseau de clés.
Pour définir les paramètres de la méthode keyring, créez un objet d'entrée. Chaque méthode de porte-clés de AWS Encryption SDK for .NET possède un objet d'entrée correspondant. Comme cet exemple utilise la `CreateAwsKmsKeyring()` méthode pour créer le trousseau de clés, il instancie la `CreateAwsKmsKeyringInput` classe pour l'entrée.
Dans un trousseau de clés de déchiffrement, vous devez utiliser un ARN de clé pour identifier les clés KMS.
```
string keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
// Instantiate the keyring input object
var kmsKeyringInput = new CreateAwsKmsKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = keyArn
};
```
Étape 3 : Créez le porte-clés.
Pour créer le trousseau de clés de déchiffrement, cet exemple utilise la `CreateAwsKmsKeyring()` méthode et l'objet d'entrée du trousseau de clés.
```
var keyring = materialProviders.CreateAwsKmsKeyring(kmsKeyringInput);
```
Étape 4 : Créez l'objet d'entrée à déchiffrer.
Pour créer l'objet d'entrée pour la `Decrypt()` méthode, instanciez la `DecryptInput` classe.
Le `Ciphertext` paramètre du `DecryptInput()` constructeur prend le `Ciphertext` membre de l'`EncryptOutput`objet renvoyé par la `Encrypt()` méthode. La `Ciphertext` propriété représente le [message chiffré](concepts.md#message), qui inclut les données chiffrées, les clés de données chiffrées et les métadonnées AWS Encryption SDK nécessaires pour déchiffrer le message.
Avec la version 4. *x* de AWS Encryption SDK pour .NET, vous pouvez utiliser le `EncryptionContext` paramètre facultatif pour spécifier votre contexte de chiffrement dans la `Decrypt()` méthode.
Utilisez le `EncryptionContext` paramètre pour vérifier que le contexte de chiffrement utilisé lors du chiffrement *est inclus* dans le contexte de chiffrement utilisé pour déchiffrer le texte chiffré. AWS Encryption SDK ajoute des paires au contexte de chiffrement, y compris la signature numérique si vous utilisez une suite d'algorithmes avec signature, telle que la suite d'algorithmes par défaut.
```
var encryptedMessage = encryptOutput.Ciphertext;
var decryptInput = new DecryptInput
{
Ciphertext = encryptedMessage,
Keyring = keyring,
EncryptionContext = encryptionContext // OPTIONAL
};
```
Étape 5 : Décrypter le texte chiffré
```
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
```
Étape 6 : Vérifiez le contexte de chiffrement — Version 3. *x*
La `Decrypt()` méthode de la version 3. *x* du AWS Encryption SDK pour .NET ne prend pas de contexte de chiffrement. Il obtient les valeurs du contexte de chiffrement à partir des métadonnées du message chiffré. Toutefois, avant de renvoyer ou d'utiliser le texte en clair, il est recommandé de vérifier que le contexte de chiffrement utilisé pour déchiffrer le texte chiffré inclut le contexte de chiffrement que vous avez fourni lors du chiffrement.
Vérifiez que le contexte de chiffrement utilisé pour chiffrer *est inclus* dans le contexte de chiffrement utilisé pour déchiffrer le texte chiffré. AWS Encryption SDK ajoute des paires au contexte de chiffrement, y compris la signature numérique si vous utilisez une suite d'algorithmes avec signature, telle que la suite d'algorithmes par défaut.
```
// Verify the encryption context
string contextKey = "purpose";
string contextValue = "test";
if (!decryptOutput.EncryptionContext.TryGetValue(contextKey, out var decryptContextValue)
|| !decryptContextValue.Equals(contextValue))
{
throw new Exception("Encryption context does not match expected values");
}
```
## Déchiffrement à l'aide d'un trousseau de découverte dans le for .NET AWS Encryption SDK
Plutôt que de spécifier les clés KMS pour le déchiffrement, vous pouvez fournir un jeu de *clés de AWS KMS découverte*, qui est un jeu de clés qui ne spécifie aucune clé KMS. Un trousseau de découverte permet de AWS Encryption SDK déchiffrer les données en utilisant la clé KMS qui les a chiffrées, à condition que l'appelant ait l'autorisation de déchiffrer la clé. Pour des raisons de bonnes pratiques, ajoutez un filtre de découverte qui limite les clés KMS pouvant être utilisées à celles Comptes AWS d'une partition spécifique.
Le jeu de clés AWS Encryption SDK pour .NET fournit un jeu de clés de découverte de base qui nécessite un AWS KMS client et un jeu de clés de découverte multiple qui nécessite que vous en spécifiiez un ou plusieurs. Régions AWS Le client et les régions limitent tous deux les clés KMS qui peuvent être utilisées pour déchiffrer le message chiffré. Les objets d'entrée pour les deux trousses de clés utilisent le filtre de découverte recommandé.
L'exemple suivant montre le modèle de déchiffrement des données à l'aide d'un trousseau de découverte et d'un AWS KMS filtre de découverte.
Étape 1 : Instancier la bibliothèque AWS Encryption SDK et la bibliothèque des fournisseurs de matériaux.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
```
Étape 2 : Créez l'objet de saisie pour le trousseau de clés.
Pour définir les paramètres de la méthode keyring, créez un objet d'entrée. Chaque méthode de porte-clés de AWS Encryption SDK for .NET possède un objet d'entrée correspondant. Comme cet exemple utilise la `CreateAwsKmsDiscoveryKeyring()` méthode pour créer le trousseau de clés, il instancie la `CreateAwsKmsDiscoveryKeyringInput` classe pour l'entrée.
```
List accounts = new List { "111122223333" };
var discoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
DiscoveryFilter = new DiscoveryFilter()
{
AccountIds = accounts,
Partition = "aws"
}
};
```
Étape 3 : Créez le porte-clés.
Pour créer le trousseau de clés de déchiffrement, cet exemple utilise la `CreateAwsKmsDiscoveryKeyring()` méthode et l'objet d'entrée du trousseau de clés.
```
var discoveryKeyring = materialProviders.CreateAwsKmsDiscoveryKeyring(discoveryKeyringInput);
```
Étape 4 : Créez l'objet d'entrée à déchiffrer.
Pour créer l'objet d'entrée pour la `Decrypt()` méthode, instanciez la `DecryptInput` classe. La valeur du `Ciphertext` paramètre est le `Ciphertext` membre de l'`EncryptOutput`objet renvoyé par la `Encrypt()` méthode.
Avec la version 4. *x* de AWS Encryption SDK pour .NET, vous pouvez utiliser le `EncryptionContext` paramètre facultatif pour spécifier votre contexte de chiffrement dans la `Decrypt()` méthode.
Utilisez le `EncryptionContext` paramètre pour vérifier que le contexte de chiffrement utilisé lors du chiffrement *est inclus* dans le contexte de chiffrement utilisé pour déchiffrer le texte chiffré. AWS Encryption SDK ajoute des paires au contexte de chiffrement, y compris la signature numérique si vous utilisez une suite d'algorithmes avec signature, telle que la suite d'algorithmes par défaut.
```
var ciphertext = encryptOutput.Ciphertext;
var decryptInput = new DecryptInput
{
Ciphertext = ciphertext,
Keyring = discoveryKeyring,
EncryptionContext = encryptionContext // OPTIONAL
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
```
Étape 5 : Vérifiez le contexte de chiffrement — Version 3. *x*
La `Decrypt()` méthode de la version 3. *x* of the AWS Encryption SDK for .NET ne prend pas en charge de contexte de chiffrement activé`Decrypt()`. Il obtient les valeurs du contexte de chiffrement à partir des métadonnées du message chiffré. Toutefois, avant de renvoyer ou d'utiliser le texte en clair, il est recommandé de vérifier que le contexte de chiffrement utilisé pour déchiffrer le texte chiffré inclut le contexte de chiffrement que vous avez fourni lors du chiffrement.
Vérifiez que le contexte de chiffrement utilisé lors du chiffrement *est inclus* dans le contexte de chiffrement utilisé pour déchiffrer le texte chiffré. AWS Encryption SDK ajoute des paires au contexte de chiffrement, y compris la signature numérique si vous utilisez une suite d'algorithmes avec signature, telle que la suite d'algorithmes par défaut.
```
// Verify the encryption context
string contextKey = "purpose";
string contextValue = "test";
if (!decryptOutput.EncryptionContext.TryGetValue(contextKey, out var decryptContextValue)
|| !decryptContextValue.Equals(contextValue))
{
throw new Exception("Encryption context does not match expected values");
}
```
# AWS Encryption SDK pour Go
Cette rubrique explique comment installer et utiliser AWS Encryption SDK for Go. Pour plus de détails sur la programmation avec le AWS Encryption SDK for Go, consultez le répertoire [go](https://github.com/aws/aws-encryption-sdk/tree/mainline/releases/go/encryption-sdk/) du aws-encryption-sdk dépôt on GitHub.
Le AWS Encryption SDK for Go se distingue de certaines des autres implémentations du langage de programmation des AWS Encryption SDK manières suivantes :
+ Aucune prise en charge de la [mise en cache des clés de données](data-key-caching.md). Cependant, AWS Encryption SDK for Go prend en charge le trousseau de [clés AWS KMS hiérarchique](use-hierarchical-keyring.md), une solution alternative de mise en cache des matériaux cryptographiques.
+ Pas de support pour le streaming de données
Le AWS Encryption SDK for Go inclut toutes les fonctionnalités de sécurité introduites dans les versions 2.0. *x* et versions ultérieures d'autres implémentations linguistiques du AWS Encryption SDK. Toutefois, si vous utilisez AWS Encryption SDK for Go pour déchiffrer des données chiffrées par une version antérieure à la version 2.0. version *x*, autre implémentation linguistique du AWS Encryption SDK, vous devrez peut-être ajuster votre [politique d'engagement](concepts.md#commitment-policy). Pour en savoir plus, consultez [Comment définir votre politique d'engagement](migrate-commitment-policy.md#migrate-commitment-step1).
The AWS Encryption SDK for Go est un produit d' AWS Encryption SDK in [Dafny](https://github.com/dafny-lang/dafny/blob/master/README.md), un langage de vérification formel dans lequel vous rédigez des spécifications, le code pour les implémenter et les preuves pour les tester. Le résultat est une bibliothèque qui implémente les fonctionnalités du AWS Encryption SDK dans un framework garantissant l'exactitude fonctionnelle.
**En savoir plus**
+ Pour des exemples montrant comment configurer des options dans le AWS Encryption SDK, telles que la spécification d'une suite d'algorithmes alternative, la limitation des clés de données chiffrées et l'utilisation de clés AWS KMS multirégionales, voir[Configuration du AWS Encryption SDK](configure.md).
+ Pour des exemples montrant comment configurer et utiliser AWS Encryption SDK for Go, consultez les [exemples Go](https://github.com/aws/aws-encryption-sdk/tree/mainline/releases/go/encryption-sdk/examples) dans le aws-encryption-sdk référentiel sur GitHub.
**Topics**
+ [Conditions préalables](#prerequisites-go)
+ [Installation](#go-installation)
## Conditions préalables
Avant d'installer AWS Encryption SDK for Go, assurez-vous de remplir les conditions préalables suivantes.
**Une version compatible de Go**
Go 1.23 ou version ultérieure est requis par AWS Encryption SDK for Go.
Pour plus d'informations sur le téléchargement et l'installation de Go, consultez la section [Installation de Go](https://go.dev/doc/install).
## Installation
Installez la dernière version de AWS Encryption SDK for Go. Pour plus de détails sur l'installation et la création de AWS Encryption SDK for Go, consultez le [fichier README.md](https://github.com/aws/aws-encryption-sdk/tree/mainline/releases/go/encryption-sdk/README.md) dans le répertoire go du aws-encryption-sdk référentiel on. GitHub
**Pour installer la dernière version**
+ Installez le AWS Encryption SDK for Go
```
go get github.com/aws/aws-encryption-sdk/releases/go/encryption-sdk@latest
```
+ Installation de la [bibliothèque de fournisseurs de matériel cryptographique](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL)
```
go get github.com/aws/aws-cryptographic-material-providers-library/releases/go/mpl
```
# Kit SDK de chiffrement AWS pour Java
Cette rubrique explique comment installer et utiliser le kit Kit SDK de chiffrement AWS pour Java. Pour plus de détails sur la programmation avec le Kit SDK de chiffrement AWS pour Java, consultez le [aws-encryption-sdk-java](https://github.com/aws/aws-encryption-sdk-java/)référentiel sur GitHub. Pour la documentation de l'API, consultez le [Javadoc](https://aws.github.io/aws-encryption-sdk-java/) pour le Kit SDK de chiffrement AWS pour Java.
**Topics**
+ [Conditions préalables](#java-prerequisites)
+ [Installation](#java-installation)
+ [Exemples](java-example-code.md)
## Conditions préalables
Avant d'installer le Kit SDK de chiffrement AWS 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).
**Bouncy Castle**
Kit SDK de chiffrement AWS pour Java Cela nécessite [Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/).
+ Kit SDK de chiffrement AWS pour Java les versions 1.6.1 et ultérieures utilisent Bouncy Castle pour sérialiser et désérialiser des objets cryptographiques. Vous pouvez utiliser Bouncy Castle ou [Bouncy Castle FIPS](https://www.bouncycastle.org/about/bouncy-castle-fips-faq/) pour répondre à cette exigence. **Pour obtenir de l'aide sur l'installation et la configuration de Bouncy Castle FIPS, consultez la [documentation BC FIPS](https://www.bouncycastle.org/documentation/), en particulier les **guides de l'utilisateur** et la politique de sécurité.** PDFs
+ Les versions antérieures Kit SDK de chiffrement AWS pour Java utilisent l'API de cryptographie de Bouncy Castle pour Java. Cette exigence n'est satisfaite que par les Bouncy Castle non FIPS.
Si vous n'avez pas Bouncy Castle, rendez-vous sur [Télécharger Bouncy Castle pour Java pour](https://bouncycastle.org/download/bouncy-castle-java/) télécharger le fichier fournisseur correspondant à votre JDK. [Vous pouvez également utiliser [Apache Maven](https://maven.apache.org/) pour obtenir l'artefact pour le fournisseur standard de Bouncy Castle ([bcprov-ext-jdk15on](https://mvnrepository.com/artifact/org.bouncycastle/bcprov-ext-jdk15on)) ou l'artefact pour Bouncy Castle FIPS (bc-fips).](https://mvnrepository.com/artifact/org.bouncycastle/bc-fips)
**AWS SDK pour Java**
Version 3. *x* l' Kit SDK de chiffrement AWS pour Java exige AWS SDK for Java 2.x, même si vous n'utilisez pas de AWS KMS porte-clés.
Version 2. *x* ou une version antérieure du Kit SDK de chiffrement AWS pour Java ne nécessite pas le AWS SDK pour Java. Cependant, AWS SDK pour Java il est nécessaire d'utiliser [AWS Key Management Service](https://aws.amazon.com/kms/)(AWS KMS) comme fournisseur de clé principale. À partir de la Kit SDK de chiffrement AWS pour Java version 2.4.0, il Kit SDK de chiffrement AWS pour Java prend en charge les versions 1.x et 2.x du. AWS SDK pour Java AWS Encryption SDK le code pour les versions AWS SDK pour Java 1.x et 2.x est interopérable. Par exemple, vous pouvez chiffrer des données avec un AWS Encryption SDK code compatible avec la version AWS SDK pour Java 1.x et les déchiffrer à l'aide d'un code compatible AWS SDK for Java 2.x (ou vice versa). Les versions antérieures à Kit SDK de chiffrement AWS pour Java 2.4.0 ne prennent en charge que la version AWS SDK pour Java 1.x. Pour plus d'informations sur la mise à jour de votre version du AWS Encryption SDK, consultez[Migration de votre AWS Encryption SDK](migration.md).
Lorsque vous mettez à jour votre Kit SDK de chiffrement AWS pour Java code de la AWS SDK pour Java version 1.x à AWS SDK for Java 2.x, remplacez les références à l'[`AWSKMS`interface](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/kms/package-summary.html) de la version AWS SDK pour Java 1.x par des références à l'[`KmsClient`interface](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kms/package-summary.html) de. AWS SDK for Java 2.x Kit SDK de chiffrement AWS pour Java Ne prend pas en charge l'[`KmsAsyncClient`interface](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kms/KmsAsyncClient.html). Mettez également à jour votre code pour utiliser les objets AWS KMS associés dans l'espace de `kmssdkv2` noms, plutôt que dans l'espace de `kms` noms.
Pour l'installer AWS SDK pour Java, utilisez 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 AWS KMS module dans la version AWS SDK pour Java 1.x, suivez les instructions pour [spécifier des modules particuliers](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-project-maven.html#modules-dependencies) et définissez la valeur sur`artifactId`. `aws-java-sdk-kms`
+ Pour créer une dépendance uniquement pour le AWS KMS module dans la version AWS SDK pour Java 2.x, suivez les instructions pour [spécifier des modules particuliers](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies). Réglez le `groupId` to `software.amazon.awssdk` et le `artifactId` to`kms`.
Pour plus de modifications, consultez la section [Quelles sont les différences entre la version AWS SDK pour Java 1.x et la version 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration-whats-different.html) dans le manuel du AWS SDK for Java 2.x développeur.
Les exemples de Java présentés dans le Guide du AWS Encryption SDK développeur utilisent le AWS SDK for Java 2.x.
## Installation
Installez la dernière version de Kit SDK de chiffrement AWS pour Java.
**Note**
Toutes les versions Kit SDK de chiffrement AWS pour Java antérieures à la version 2.0.0 sont en [end-of-supportphase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle).
Vous pouvez effectuer la mise à jour en toute sécurité à partir de la version 2.0. *x* et versions ultérieures vers la dernière version du Kit SDK de chiffrement AWS pour Java sans aucune modification du code ou des données. Cependant, de [nouvelles fonctionnalités de sécurité](about-versions.md#version-2) ont été introduites dans la version 2.0. *x* ne sont pas rétrocompatibles. Pour effectuer une mise à jour à partir de versions antérieures à 1.7. *x* vers la version 2.0. *x* et versions ultérieures, vous devez d'abord effectuer la mise à jour vers la dernière version 1. version *x* du AWS Encryption SDK. Pour en savoir plus, consultez [Migration de votre AWS Encryption SDK](migration.md).
Vous pouvez l'installer Kit SDK de chiffrement AWS pour Java de la manière suivante.
**Manuellement**
Pour installer le [aws-encryption-sdk-java](https://github.com/aws/aws-encryption-sdk-java/) GitHubréférentiel Kit SDK de chiffrement AWS pour Java, le cloner ou le télécharger.
**Utilisation d'Apache Maven**
Kit SDK de chiffrement AWS pour Java Il est disponible via [Apache Maven](https://maven.apache.org/) avec la définition de dépendance suivante.
```
com.amazonawsaws-encryption-sdk-java3.0.0
```
Après avoir installé le SDK, commencez par consulter l'[exemple de code Java présenté](java-example-code.md) dans ce guide et le [Javadoc](https://aws.github.io/aws-encryption-sdk-java/) activé. GitHub
# Kit SDK de chiffrement AWS pour Java exemples
Les exemples suivants vous montrent comment utiliser le Kit SDK de chiffrement AWS pour Java pour chiffrer et déchiffrer des données. Ces exemples montrent comment utiliser la version 3. *x* et versions ultérieures du Kit SDK de chiffrement AWS pour Java. Version 3. *x* de Kit SDK de chiffrement AWS pour Java nécessite le AWS SDK for Java 2.x. Version 3. *x* of the Kit SDK de chiffrement AWS pour Java remplace les [fournisseurs de clés principales](concepts.md#master-key-provider) par des [porte-clés](concepts.md#keyring). Pour les exemples utilisant des versions antérieures, recherchez votre version dans la liste des [versions](https://github.com/aws/aws-encryption-sdk-java/releases) du [aws-encryption-sdk-java](https://github.com/aws/aws-encryption-sdk-java/)référentiel sur GitHub.
**Topics**
+ [Chaînes](#java-example-strings)
+ [Flux d'octets](#java-example-streams)
+ [Flux d'octets avec plusieurs fournisseurs de clés principales](#java-example-multiple-providers)
## Chiffrement et déchiffrement de chaînes
L'exemple suivant montre comment utiliser la version 3. *x* de Kit SDK de chiffrement AWS pour Java pour chiffrer et déchiffrer des chaînes. Avant d'utiliser la chaîne, convertissez-la en un tableau d'octets.
Cet exemple utilise un [AWS KMS porte-clés.](use-kms-keyring.md) Lorsque vous chiffrez avec un AWS KMS trousseau de clés, vous pouvez utiliser un ID de clé, un ARN de clé, un nom d'alias ou un ARN d'alias pour identifier les clés KMS. Lors du déchiffrement, vous devez utiliser un ARN de clé pour identifier les clés KMS.
Lorsque vous appelez la méthode `encryptData()`, elle renvoie un [message chiffré](concepts.md#message) (`CryptoResult`) qui inclut le texte chiffré, les clés de données chiffrées et le contexte de chiffrement. Lorsque vous appelez `getResult` sur l'objet `CryptoResult`, il renvoie une version de chaîne codée en base 64 du [message chiffré](message-format.md) que vous pouvez transmettre à la méthode `decryptData()`.
De même, lorsque vous appelez`decryptData()`, l'`CryptoResult`objet renvoyé contient le message en texte brut et un AWS KMS key identifiant. Avant que votre application ne renvoie le texte en clair, vérifiez que l' AWS KMS key identifiant et le contexte de chiffrement du message chiffré correspondent à vos attentes.
```
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package com.amazonaws.crypto.keyrings;
import com.amazonaws.encryptionsdk.AwsCrypto;
import com.amazonaws.encryptionsdk.CommitmentPolicy;
import com.amazonaws.encryptionsdk.CryptoResult;
import software.amazon.cryptography.materialproviders.IKeyring;
import software.amazon.cryptography.materialproviders.MaterialProviders;
import software.amazon.cryptography.materialproviders.model.CreateAwsKmsMultiKeyringInput;
import software.amazon.cryptography.materialproviders.model.MaterialProvidersConfig;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
/**
* Encrypts and then decrypts data using an AWS KMS Keyring.
*
*
Arguments:
*
*
*
Key ARN: For help finding the Amazon Resource Name (ARN) of your AWS KMS customer master
* key (CMK), see 'Viewing Keys' at
* http://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html
*
*/
public class BasicEncryptionKeyringExample {
private static final byte[] EXAMPLE_DATA = "Hello World".getBytes(StandardCharsets.UTF_8);
public static void main(final String[] args) {
final String keyArn = args[0];
encryptAndDecryptWithKeyring(keyArn);
}
public static void encryptAndDecryptWithKeyring(final String keyArn) {
// 1. Instantiate the SDK
// This builds the AwsCrypto client with the RequireEncryptRequireDecrypt commitment policy,
// which means this client only encrypts using committing algorithm suites and enforces
// that the client will only decrypt encrypted messages that were created with a committing
// algorithm suite.
// This is the default commitment policy if you build the client with
// `AwsCrypto.builder().build()`
// or `AwsCrypto.standard()`.
final AwsCrypto crypto =
AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
// 2. Create the AWS KMS keyring.
// This example creates a multi keyring, which automatically creates the KMS client.
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMultiKeyringInput keyringInput =
CreateAwsKmsMultiKeyringInput.builder().generator(keyArn).build();
final IKeyring kmsKeyring = materialProviders.CreateAwsKmsMultiKeyring(keyringInput);
// 3. Create an encryption context
// We recommend using an encryption context whenever possible
// to protect integrity. This sample uses placeholder values.
// For more information see:
// blogs.aws.amazon.com/security/post/Tx2LZ6WBJJANTNW/How-to-Protect-the-Integrity-of-Your-Encrypted-Data-by-Using-AWS-Key-Management
final Map encryptionContext =
Collections.singletonMap("ExampleContextKey", "ExampleContextValue");
// 4. Encrypt the data
final CryptoResult encryptResult =
crypto.encryptData(kmsKeyring, EXAMPLE_DATA, encryptionContext);
final byte[] ciphertext = encryptResult.getResult();
// 5. Decrypt the data
final CryptoResult decryptResult =
crypto.decryptData(
kmsKeyring,
ciphertext,
// Verify that the encryption context in the result contains the
// encryption context supplied to the encryptData method
encryptionContext);
// 6. Verify that the decrypted plaintext matches the original plaintext
assert Arrays.equals(decryptResult.getResult(), EXAMPLE_DATA);
}
}
```
## Chiffrement et déchiffrement de flux d'octets
L'exemple suivant montre comment utiliser le AWS Encryption SDK pour chiffrer et déchiffrer des flux d'octets.
Cet exemple utilise un trousseau de [clés AES brut](use-raw-aes-keyring.md).
Lors du chiffrement, cet exemple utilise la `AwsCrypto.builder() .withEncryptionAlgorithm()` méthode pour spécifier une suite d'algorithmes sans [signatures numériques](concepts.md#digital-sigs). Lors du déchiffrement, pour garantir que le texte chiffré n'est pas signé, cet exemple utilise la méthode. `createUnsignedMessageDecryptingStream()` La `createUnsignedMessageDecryptingStream()` méthode échoue si elle rencontre un texte chiffré avec une signature numérique.
Si vous chiffrez avec la suite d'algorithmes par défaut, qui inclut les signatures numériques, utilisez plutôt `createDecryptingStream()` cette méthode, comme indiqué dans l'exemple suivant.
```
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package com.amazonaws.crypto.keyrings;
import com.amazonaws.encryptionsdk.AwsCrypto;
import com.amazonaws.encryptionsdk.CommitmentPolicy;
import com.amazonaws.encryptionsdk.CryptoAlgorithm;
import com.amazonaws.encryptionsdk.CryptoInputStream;
import com.amazonaws.encryptionsdk.jce.JceMasterKey;
import com.amazonaws.util.IOUtils;
import software.amazon.cryptography.materialproviders.IKeyring;
import software.amazon.cryptography.materialproviders.MaterialProviders;
import software.amazon.cryptography.materialproviders.model.AesWrappingAlg;
import software.amazon.cryptography.materialproviders.model.CreateRawAesKeyringInput;
import software.amazon.cryptography.materialproviders.model.MaterialProvidersConfig;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.security.SecureRandom;
import java.util.Collections;
import java.util.Map;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
/**
*
* Encrypts and then decrypts a file under a random key.
*
*
* Arguments:
*
*
Name of file containing plaintext data to encrypt
*
*
*
* This program demonstrates using a standard Java {@link SecretKey} object as a {@link IKeyring} to
* encrypt and decrypt streaming data.
*/
public class FileStreamingKeyringExample {
private static String srcFile;
public static void main(String[] args) throws IOException {
srcFile = args[0];
// In this example, we generate a random key. In practice,
// you would get a key from an existing store
SecretKey cryptoKey = retrieveEncryptionKey();
// Create a Raw Aes Keyring using the random key and an AES-GCM encryption algorithm
final MaterialProviders materialProviders = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateRawAesKeyringInput keyringInput = CreateRawAesKeyringInput.builder()
.wrappingKey(ByteBuffer.wrap(cryptoKey.getEncoded()))
.keyNamespace("Example")
.keyName("RandomKey")
.wrappingAlg(AesWrappingAlg.ALG_AES128_GCM_IV12_TAG16)
.build();
IKeyring keyring = materialProviders.CreateRawAesKeyring(keyringInput);
// Instantiate the SDK.
// This builds the AwsCrypto client with the RequireEncryptRequireDecrypt commitment policy,
// which means this client only encrypts using committing algorithm suites and enforces
// that the client will only decrypt encrypted messages that were created with a committing
// algorithm suite.
// This is the default commitment policy if you build the client with
// `AwsCrypto.builder().build()`
// or `AwsCrypto.standard()`.
// This example encrypts with an algorithm suite that doesn't include signing for faster decryption,
// since this use case assumes that the contexts that encrypt and decrypt are equally trusted.
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY)
.build();
// Create an encryption context to identify the ciphertext
Map context = Collections.singletonMap("Example", "FileStreaming");
// Because the file might be too large to load into memory, we stream the data, instead of
//loading it all at once.
FileInputStream in = new FileInputStream(srcFile);
CryptoInputStream encryptingStream = crypto.createEncryptingStream(keyring, in, context);
FileOutputStream out = new FileOutputStream(srcFile + ".encrypted");
IOUtils.copy(encryptingStream, out);
encryptingStream.close();
out.close();
// Decrypt the file. Verify the encryption context before returning the plaintext.
// Since the data was encrypted using an unsigned algorithm suite, use the recommended
// createUnsignedMessageDecryptingStream method, which only accepts unsigned messages.
in = new FileInputStream(srcFile + ".encrypted");
CryptoInputStream decryptingStream = crypto.createUnsignedMessageDecryptingStream(keyring, in);
// Does it contain the expected encryption context?
if (!"FileStreaming".equals(decryptingStream.getCryptoResult().getEncryptionContext().get("Example"))) {
throw new IllegalStateException("Bad encryption context");
}
// Write the plaintext data to disk.
out = new FileOutputStream(srcFile + ".decrypted");
IOUtils.copy(decryptingStream, out);
decryptingStream.close();
out.close();
}
/**
* In practice, this key would be saved in a secure location.
* For this demo, we generate a new random key for each operation.
*/
private static SecretKey retrieveEncryptionKey() {
SecureRandom rnd = new SecureRandom();
byte[] rawKey = new byte[16]; // 128 bits
rnd.nextBytes(rawKey);
return new SecretKeySpec(rawKey, "AES");
}
}
```
## Chiffrer et déchiffrer des flux d'octets à l'aide d'un jeu de clés multiples
L'exemple suivant montre comment utiliser le AWS Encryption SDK avec un [porte-clés multiple](use-multi-keyring.md). Lorsque vous utilisez un porte-clés multiple pour chiffrer des données, toutes les clés d'encapsulage de tous ses porte-clés sont capables de déchiffrer les données. Cet exemple utilise un [AWS KMS porte-clés et un porte-clés](use-kms-keyring.md) [RSA brut comme porte-clés](use-raw-rsa-keyring.md) enfants.
Cet exemple chiffre avec la [suite d'algorithmes par défaut](supported-algorithms.md), qui inclut une [signature numérique](concepts.md#digital-sigs). Lors du streaming, il AWS Encryption SDK publie du texte brut après des contrôles d'intégrité, mais avant que la signature numérique ne soit vérifiée. Pour éviter d'utiliser le texte en clair tant que la signature n'est pas vérifiée, cet exemple met le texte en clair en mémoire tampon et ne l'écrit sur le disque que lorsque le déchiffrement et la vérification sont terminés.
```
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package com.amazonaws.crypto.keyrings;
import com.amazonaws.encryptionsdk.AwsCrypto;
import com.amazonaws.encryptionsdk.CommitmentPolicy;
import com.amazonaws.encryptionsdk.CryptoOutputStream;
import com.amazonaws.util.IOUtils;
import software.amazon.cryptography.materialproviders.IKeyring;
import software.amazon.cryptography.materialproviders.MaterialProviders;
import software.amazon.cryptography.materialproviders.model.CreateAwsKmsMultiKeyringInput;
import software.amazon.cryptography.materialproviders.model.CreateMultiKeyringInput;
import software.amazon.cryptography.materialproviders.model.CreateRawRsaKeyringInput;
import software.amazon.cryptography.materialproviders.model.MaterialProvidersConfig;
import software.amazon.cryptography.materialproviders.model.PaddingScheme;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.security.GeneralSecurityException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.util.Collections;
/**
*
* Encrypts a file using both AWS KMS Key and an asymmetric key pair.
*
*
* Arguments:
*
*
Key ARN: For help finding the Amazon Resource Name (ARN) of your AWS KMS key,
* see 'Viewing Keys' at http://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html
*
*
Name of file containing plaintext data to encrypt
*
*
* You might use AWS Key Management Service (AWS KMS) for most encryption and decryption operations, but
* still want the option of decrypting your data offline independently of AWS KMS. This sample
* demonstrates one way to do this.
*
* The sample encrypts data under both an AWS KMS key and an "escrowed" RSA key pair
* so that either key alone can decrypt it. You might commonly use the AWS KMS key for decryption. However,
* at any time, you can use the private RSA key to decrypt the ciphertext independent of AWS KMS.
*
* This sample uses the RawRsaKeyring to generate a RSA public-private key pair
* and saves the key pair in memory. In practice, you would store the private key in a secure offline
* location, such as an offline HSM, and distribute the public key to your development team.
*/
public class EscrowedEncryptKeyringExample {
private static ByteBuffer publicEscrowKey;
private static ByteBuffer privateEscrowKey;
public static void main(final String[] args) throws Exception {
// This sample generates a new random key for each operation.
// In practice, you would distribute the public key and save the private key in secure
// storage.
generateEscrowKeyPair();
final String kmsArn = args[0];
final String fileName = args[1];
standardEncrypt(kmsArn, fileName);
standardDecrypt(kmsArn, fileName);
escrowDecrypt(fileName);
}
private static void standardEncrypt(final String kmsArn, final String fileName) throws Exception {
// Encrypt with the KMS key and the escrowed public key
// 1. Instantiate the SDK
// This builds the AwsCrypto client with the RequireEncryptRequireDecrypt commitment policy,
// which means this client only encrypts using committing algorithm suites and enforces
// that the client will only decrypt encrypted messages that were created with a committing
// algorithm suite.
// This is the default commitment policy if you build the client with
// `AwsCrypto.builder().build()`
// or `AwsCrypto.standard()`.
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
// 2. Create the AWS KMS keyring.
// This example creates a multi keyring, which automatically creates the KMS client.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMultiKeyringInput keyringInput = CreateAwsKmsMultiKeyringInput.builder()
.generator(kmsArn)
.build();
IKeyring kmsKeyring = matProv.CreateAwsKmsMultiKeyring(keyringInput);
// 3. Create the Raw Rsa Keyring with Public Key.
final CreateRawRsaKeyringInput encryptingKeyringInput = CreateRawRsaKeyringInput.builder()
.keyName("Escrow")
.keyNamespace("Escrow")
.paddingScheme(PaddingScheme.OAEP_SHA512_MGF1)
.publicKey(publicEscrowKey)
.build();
IKeyring rsaPublicKeyring = matProv.CreateRawRsaKeyring(encryptingKeyringInput);
// 4. Create the multi-keyring.
final CreateMultiKeyringInput createMultiKeyringInput = CreateMultiKeyringInput.builder()
.generator(kmsKeyring)
.childKeyrings(Collections.singletonList(rsaPublicKeyring))
.build();
IKeyring multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
// 5. Encrypt the file
// To simplify this code example, we omit the encryption context. Production code should always
// use an encryption context.
final FileInputStream in = new FileInputStream(fileName);
final FileOutputStream out = new FileOutputStream(fileName + ".encrypted");
final CryptoOutputStream encryptingStream = crypto.createEncryptingStream(multiKeyring, out);
IOUtils.copy(in, encryptingStream);
in.close();
encryptingStream.close();
}
private static void standardDecrypt(final String kmsArn, final String fileName) throws Exception {
// Decrypt with the AWS KMS key and the escrow public key.
// 1. Instantiate the SDK.
// This builds the AwsCrypto client with the RequireEncryptRequireDecrypt commitment policy,
// which means this client only encrypts using committing algorithm suites and enforces
// that the client will only decrypt encrypted messages that were created with a committing
// algorithm suite.
// This is the default commitment policy if you build the client with
// `AwsCrypto.builder().build()`
// or `AwsCrypto.standard()`.
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
// 2. Create the AWS KMS keyring.
// This example creates a multi keyring, which automatically creates the KMS client.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMultiKeyringInput keyringInput = CreateAwsKmsMultiKeyringInput.builder()
.generator(kmsArn)
.build();
IKeyring kmsKeyring = matProv.CreateAwsKmsMultiKeyring(keyringInput);
// 3. Create the Raw Rsa Keyring with Public Key.
final CreateRawRsaKeyringInput encryptingKeyringInput = CreateRawRsaKeyringInput.builder()
.keyName("Escrow")
.keyNamespace("Escrow")
.paddingScheme(PaddingScheme.OAEP_SHA512_MGF1)
.publicKey(publicEscrowKey)
.build();
IKeyring rsaPublicKeyring = matProv.CreateRawRsaKeyring(encryptingKeyringInput);
// 4. Create the multi-keyring.
final CreateMultiKeyringInput createMultiKeyringInput = CreateMultiKeyringInput.builder()
.generator(kmsKeyring)
.childKeyrings(Collections.singletonList(rsaPublicKeyring))
.build();
IKeyring multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
// 5. Decrypt the file
// To simplify this code example, we omit the encryption context. Production code should always
// use an encryption context.
final FileInputStream in = new FileInputStream(fileName + ".encrypted");
final FileOutputStream out = new FileOutputStream(fileName + ".decrypted");
// Since we are using a signing algorithm suite, we avoid streaming decryption directly to the output file,
// to ensure that the trailing signature is verified before writing any untrusted plaintext to disk.
final ByteArrayOutputStream plaintextBuffer = new ByteArrayOutputStream();
final CryptoOutputStream decryptingStream = crypto.createDecryptingStream(multiKeyring, plaintextBuffer);
IOUtils.copy(in, decryptingStream);
in.close();
decryptingStream.close();
final ByteArrayInputStream plaintextReader = new ByteArrayInputStream(plaintextBuffer.toByteArray());
IOUtils.copy(plaintextReader, out);
out.close();
}
private static void escrowDecrypt(final String fileName) throws Exception {
// You can decrypt the stream using only the private key.
// This method does not call AWS KMS.
// 1. Instantiate the SDK
final AwsCrypto crypto = AwsCrypto.standard();
// 2. Create the Raw Rsa Keyring with Private Key.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateRawRsaKeyringInput encryptingKeyringInput = CreateRawRsaKeyringInput.builder()
.keyName("Escrow")
.keyNamespace("Escrow")
.paddingScheme(PaddingScheme.OAEP_SHA512_MGF1)
.publicKey(publicEscrowKey)
.privateKey(privateEscrowKey)
.build();
IKeyring escrowPrivateKeyring = matProv.CreateRawRsaKeyring(encryptingKeyringInput);
// 3. Decrypt the file
// To simplify this code example, we omit the encryption context. Production code should always
// use an encryption context.
final FileInputStream in = new FileInputStream(fileName + ".encrypted");
final FileOutputStream out = new FileOutputStream(fileName + ".deescrowed");
final CryptoOutputStream decryptingStream = crypto.createDecryptingStream(escrowPrivateKeyring, out);
IOUtils.copy(in, decryptingStream);
in.close();
decryptingStream.close();
}
private static void generateEscrowKeyPair() throws GeneralSecurityException {
final KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA");
kg.initialize(4096); // Escrow keys should be very strong
final KeyPair keyPair = kg.generateKeyPair();
publicEscrowKey = RawRsaKeyringExample.getPEMPublicKey(keyPair.getPublic());
privateEscrowKey = RawRsaKeyringExample.getPEMPrivateKey(keyPair.getPrivate());
}
}
```
# Kit SDK de chiffrement AWS pour JavaScript
Kit SDK de chiffrement AWS pour JavaScript Il est conçu pour fournir une bibliothèque de chiffrement côté client aux développeurs qui écrivent des applications de navigateur Web JavaScript ou des applications de serveur Web dans Node.js.
Comme toutes les implémentations du AWS Encryption SDK, il Kit SDK de chiffrement AWS pour JavaScript offre des fonctionnalités avancées de protection des données. Il s'agit notamment du [chiffrement d'enveloppe](concepts.md#envelope-encryption), de données authentifiées supplémentaires (données AAD) et de [suites d'algorithmes](concepts.md#crypto-algorithm) de clés symétriques sécurisées, authentifiées, comme les clés AES-GCM 256 bits avec dérivation de clés et signature.
Toutes les implémentations spécifiques au langage AWS Encryption SDK sont conçues pour être interopérables, sous réserve des contraintes du langage. Pour plus de détails sur les contraintes linguistiques pour JavaScript, voir[Compatibilité du Kit SDK de chiffrement AWS pour JavaScript](javascript-compatibility.md).
**En savoir plus**
+ Pour plus de détails sur la programmation avec le Kit SDK de chiffrement AWS pour JavaScript, consultez le [aws-encryption-sdk-javascript](https://github.com/aws/aws-encryption-sdk-javascript/)référentiel sur GitHub.
+ Pour des exemples de programmation, consultez les [Kit SDK de chiffrement AWS pour JavaScript exemples](js-examples.md) modules [example-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/example-browser) et [example-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/example-node) du référentiel. [aws-encryption-sdk-javascript](https://github.com/aws/aws-encryption-sdk-javascript/)
+ Pour un exemple concret d'utilisation de Kit SDK de chiffrement AWS pour JavaScript pour chiffrer des données dans une application Web, consultez la section [Comment activer le chiffrement dans un navigateur avec le Kit SDK de chiffrement AWS pour JavaScript et Node.js dans le](https://aws.amazon.com/blogs/security/how-to-enable-encryption-browser-aws-encryption-sdk-javascript-node-js/) blog sur la AWS sécurité.
**Topics**
+ [Compatibilité](javascript-compatibility.md)
+ [Installation](javascript-installation.md)
+ [Modules](javascript-modules.md)
+ [Exemples](js-examples.md)
# Compatibilité du Kit SDK de chiffrement AWS pour JavaScript
Kit SDK de chiffrement AWS pour JavaScript Il est conçu pour être interopérable avec d'autres implémentations linguistiques du. AWS Encryption SDK Dans la plupart des cas, vous pouvez chiffrer les données avec le Kit SDK de chiffrement AWS pour JavaScript et les déchiffrer avec n'importe quelle autre implémentation de langage, y compris l'interface de [ligne de AWS Encryption SDK commande](crypto-cli.md). Et vous pouvez utiliser le Kit SDK de chiffrement AWS pour JavaScript pour déchiffrer les [messages chiffrés](concepts.md#message) produits par d'autres implémentations linguistiques du. AWS Encryption SDK
Toutefois, lorsque vous utilisez le Kit SDK de chiffrement AWS pour JavaScript, vous devez être conscient de certains problèmes de compatibilité liés à l'implémentation du JavaScript langage et aux navigateurs Web.
En outre, lorsque vous utilisez des implémentations linguistiques différentes, veillez à configurer des fournisseurs de clés principales, des clés principales et des trousseaux de clés compatibles. Pour en savoir plus, consultez [Compatibilité du porte-clés](choose-keyring.md#keyring-compatibility).
## Kit SDK de chiffrement AWS pour JavaScript compatibilité
La JavaScript mise en œuvre du AWS Encryption SDK diffère des autres implémentations de langage de la manière suivante :
+ L'opération de chiffrement du Kit SDK de chiffrement AWS pour JavaScript ne renvoie pas de texte chiffré non encadré. Cependant, ils Kit SDK de chiffrement AWS pour JavaScript déchiffreront le texte chiffré encadré et non cadré renvoyé par d'autres implémentations linguistiques du. AWS Encryption SDK
+ À partir de Node.js version 12.9.0, Node.js prend en charge les options d'encapsulage de clé RSA suivantes :
+ OAEP avec SHA1, SHA256, ou SHA384 SHA512
+ OAEP avec et avec SHA1 MGF1 SHA1
+ PKCS1v15
+ Avant la version 12.9.0, Node.js ne prend en charge que les options d'encapsulage de clé RSA suivantes :
+ OAEP avec et avec SHA1 MGF1 SHA1
+ PKCS1v15
## Compatibilité des navigateurs
Certains navigateurs web ne prennent pas en charge les opérations de chiffrement de base requises par Kit SDK de chiffrement AWS pour JavaScript . Vous pouvez compenser certaines opérations manquantes en configurant une solution de secours pour l' WebCrypto API implémentée par le navigateur.
**Limites du navigateur web**
Les limitations suivantes sont communes à tous les navigateurs web :
+ L' WebCrypto API ne prend pas en charge l'encapsulage des PKCS1v15 clés.
+ Les navigateurs ne prennent pas en charge les clés 192 bits.
**Opérations de chiffrement requises**
Kit SDK de chiffrement AWS pour JavaScript Nécessite les opérations suivantes dans les navigateurs Web. Si un navigateur ne prend pas en charge ces opérations, il est incompatible avec le kit Kit SDK de chiffrement AWS pour JavaScript.
+ Le navigateur doit inclure le kit `crypto.getRandomValues()`, qui est une méthode pour générer des valeurs cryptographiquement aléatoires. Pour plus d'informations sur les versions de navigateur Web prises en charge`crypto.getRandomValues()`, voir [Puis-je utiliser le chiffrement. getRandomValues() ?](https://caniuse.com/#feat=getrandomvalues) .
**Repli requis**
Kit SDK de chiffrement AWS pour JavaScript Nécessite les bibliothèques et opérations suivantes dans les navigateurs Web. Si vous prenez en charge un navigateur web qui ne répond pas à ces exigences, vous devez configurer une solution de secours. Dans le cas contraire, les tentatives d'utilisation du Kit SDK de chiffrement AWS pour JavaScript avec le navigateur échoueront.
+ L' WebCrypto API, qui effectue des opérations cryptographiques de base dans les applications Web, n'est pas disponible pour tous les navigateurs. Pour de plus amples informations sur les versions de navigateur web qui prennent en charge le chiffrement web, veuillez consulter [Puis-je utiliser le chiffrement web ?](https://caniuse.com/#feat=cryptography).
+ Les versions modernes du navigateur Web Safari ne prennent pas en charge le cryptage AES-GCM de zéro octet, ce qui est requis. AWS Encryption SDK Si le navigateur implémente l' WebCrypto API, mais ne peut pas utiliser AES-GCM pour chiffrer zéro octet, il Kit SDK de chiffrement AWS pour JavaScript utilise la bibliothèque de secours uniquement pour le chiffrement à zéro octet. Il utilise l' WebCrypto API pour toutes les autres opérations.
Pour configurer une solution de secours pour l'une ou l'autre limitation, ajoutez les instructions suivantes à votre code. Dans la fonction [configureFallback](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/web-crypto-backend/src/backend-factory.ts#L78), spécifiez une bibliothèque qui prend en charge les fonctions manquantes. L'exemple suivant utilise la bibliothèque de JavaScript cryptographie Microsoft Research (`msrcrypto`), mais vous pouvez la remplacer par une bibliothèque compatible. Pour un exemple complet, veuillez consulter [fallback.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/fallback.ts).
```
import { configureFallback } from '@aws-crypto/client-browser'
configureFallback(msrCrypto)
```
# Installation du Kit SDK de chiffrement AWS pour JavaScript
Kit SDK de chiffrement AWS pour JavaScript Il s'agit d'un ensemble de modules interdépendants. Plusieurs des modules ne sont que des collections de modules conçus pour fonctionner ensemble. Certains modules sont conçus pour fonctionner indépendamment. Quelques modules sont obligatoires pour toutes les implémentations ; d'autres ne sont obligatoires que pour des cas particuliers. Pour plus d'informations sur les modules du AWS Encryption SDK formulaire JavaScript, reportez-vous à la section [Modules du Kit SDK de chiffrement AWS pour JavaScript](javascript-modules.md) et au `README.md` fichier de chacun des modules du [aws-encryption-sdk-javascript](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules)référentiel sur GitHub.
**Note**
Toutes les versions Kit SDK de chiffrement AWS pour JavaScript antérieures à la version 2.0.0 sont en [end-of-supportphase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle).
Vous pouvez effectuer la mise à jour en toute sécurité à partir de la version 2.0. *x* et versions ultérieures vers la dernière version du Kit SDK de chiffrement AWS pour JavaScript sans aucune modification du code ou des données. Cependant, de [nouvelles fonctionnalités de sécurité](about-versions.md#version-2) ont été introduites dans la version 2.0. *x* ne sont pas rétrocompatibles. Pour effectuer une mise à jour à partir de versions antérieures à 1.7. *x* vers la version 2.0. *x* et versions ultérieures, vous devez d'abord effectuer la mise à jour vers la dernière version 1. version *x* du Kit SDK de chiffrement AWS pour JavaScript. Pour en savoir plus, consultez [Migration de votre AWS Encryption SDK](migration.md).
Pour installer les modules, utilisez le [gestionnaire de packages npm](https://www.npmjs.com/get-npm).
Par exemple, pour installer le `client-node` module, qui inclut tous les modules que vous devez programmer avec le fichier Kit SDK de chiffrement AWS pour JavaScript dans Node.js, utilisez la commande suivante.
```
npm install @aws-crypto/client-node
```
Pour installer le `client-browser` module, qui inclut tous les modules que vous devez utiliser pour programmer Kit SDK de chiffrement AWS pour JavaScript dans le navigateur, utilisez la commande suivante.
```
npm install @aws-crypto/client-browser
```
Pour des exemples pratiques d'utilisation du Kit SDK de chiffrement AWS pour JavaScript, consultez les exemples dans les `example-browser` modules `example-node` et du [aws-encryption-sdk-javascript](https://github.com/aws/aws-encryption-sdk-javascript/)référentiel sur GitHub.
# Modules du Kit SDK de chiffrement AWS pour JavaScript
Les modules qu'il Kit SDK de chiffrement AWS pour JavaScript contient facilitent l'installation du code dont vous avez besoin pour vos projets.
## Modules pour JavaScript Node.js
[client-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/client-node)
Inclut tous les modules dont vous avez besoin pour programmer avec Kit SDK de chiffrement AWS pour JavaScript le fichier Node.js.
[caching-materials-manager-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/caching-materials-manager-node)
Exporte les fonctions qui prennent en charge la fonctionnalité de [mise en cache des clés de données](data-key-caching.md) Kit SDK de chiffrement AWS pour JavaScript dans le fichier Node.js.
[decrypt-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/decrypt-node)
Exporte les fonctions qui déchiffrent et vérifient les messages chiffrés représentant les données et les flux de données. Inclus dans le module `client-node`.
[encrypt-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/encrypt-node)
Exporte des fonctions qui chiffrent et signent différents types de données. Inclus dans le module `client-node`.
[example-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/example-node)
Exporte des exemples pratiques de programmation à l'aide Kit SDK de chiffrement AWS pour JavaScript du fichier Node.js. Comprend des exemples de différents types de porte-clés et de différents types de données.
[hkdf-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/hkdf-node)
Exporte une [fonction de dérivation de clés (HKDF) basée sur HMAC](https://en.wikipedia.org/wiki/HKDF) que le fichier Node.js utilise Kit SDK de chiffrement AWS pour JavaScript en particulier pour des suites d'algorithmes. Kit SDK de chiffrement AWS pour JavaScript Dans le navigateur, la fonction HKDF native de l' WebCrypto API est utilisée.
[integration-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/integration-node)
Définit des tests qui vérifient que le fichier Kit SDK de chiffrement AWS pour JavaScript dans Node.js est compatible avec d'autres implémentations linguistiques du AWS Encryption SDK.
[kms-keyring-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/kms-keyring-node)
Exporte les fonctions qui prennent en charge les AWS KMS trousseaux de clés dans Node.js.
[raw-aes-keyring-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/raw-aes-keyring-node)
Exporte les fonctions qui prennent en charge les [porte-clés AES brut](use-raw-aes-keyring.md) dans Node.js.
[raw-rsa-keyring-node](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/raw-rsa-keyring-node)
Exporte les fonctions qui prennent en charge les [porte-clés RSA brut](use-raw-rsa-keyring.md) dans Node.js.
## Modules pour JavaScript navigateur
[client-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/client-browser)
Comprend tous les modules dont vous avez besoin pour programmer Kit SDK de chiffrement AWS pour JavaScript dans le navigateur.
[caching-materials-manager-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/caching-materials-manager-browser)
Exporte les fonctions qui prennent en charge la fonctionnalité de [mise en cache des clés de données](data-key-caching.md) JavaScript dans le navigateur.
[decrypt-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/decrypt-browser)
Exporte les fonctions qui déchiffrent et vérifient les messages chiffrés représentant les données et les flux de données.
[encrypt-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/encrypt-browser)
Exporte des fonctions qui chiffrent et signent différents types de données.
[example-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/example-browser)
Exemples pratiques de programmation avec le Kit SDK de chiffrement AWS pour JavaScript dans le navigateur. Comprend des exemples de différents types de porte-clés et de différents types de données.
[integration-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/integration-browser)
Définit des tests qui vérifient que le Kit SDK de chiffrement AWS pour Java script du navigateur est compatible avec les autres implémentations linguistiques du AWS Encryption SDK.
[kms-keyring-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/kms-keyring-browser)
Exporte les fonctions qui prennent en charge les [AWS KMS trousseaux](use-kms-keyring.md) de clés dans le navigateur.
[raw-aes-keyring-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/raw-aes-keyring-browser)
Exporte les fonctions qui prennent en charge les [porte-clés AES brut](use-raw-aes-keyring.md) dans le navigateur.
[raw-rsa-keyring-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/raw-rsa-keyring-browser)
Exporte les fonctions qui prennent en charge les [porte-clés RSA brut](use-raw-rsa-keyring.md) dans le navigateur.
## Modules pour toutes les implémentations
[cache-material](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/cache-material)
Prend en charge la fonction de [mise en cache des clés de données](data-key-caching.md). Fournit du code pour assembler les matériaux de chiffrement mis en cache avec chaque clé de données.
[kms-keyring](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/kms-keyring)
Exporte les fonctions qui prennent en charge les [porte-clés KMS](use-kms-keyring.md).
[material-management](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/material-management)
Implémente le [gestionnaire de matériaux de chiffrement](concepts.md#crypt-materials-manager) (CMM).
[raw-keyring](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/raw-keyring)
Exporte les fonctions requises pour les porte-clés AES et RSA brutes.
[serialize](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/serialize)
Exporte les fonctions que le kit SDK utilise pour sérialiser sa sortie.
[web-crypto-backend](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/web-crypto-backend)
Exporte les fonctions qui utilisent l' WebCrypto API Kit SDK de chiffrement AWS pour JavaScript dans le navigateur.
# Kit SDK de chiffrement AWS pour JavaScript exemples
Les exemples suivants montrent comment utiliser le kit Kit SDK de chiffrement AWS pour JavaScript afin de chiffrer et de déchiffrer des données.
Vous trouverez d'autres exemples d'utilisation des modules Kit SDK de chiffrement AWS pour JavaScript [example-node et example-browser](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/example-node) [du](https://github.com/aws/aws-encryption-sdk-javascript/tree/master/modules/example-browser) référentiel sur. [aws-encryption-sdk-javascript](https://github.com/aws/aws-encryption-sdk-javascript/) GitHub Ces exemples de modules ne sont pas installés lorsque vous installez les modules `client-browser` ou `client-node`.
**Voir les exemples de code complets** : Nœud : [kms\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_simple.ts), Navigateur : [kms\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/kms_simple.ts)
**Topics**
+ [Chiffrer des données à l'aide d'un trousseau de clés AWS KMS](#javascript-example-encrypt)
+ [Déchiffrer des données à l'aide d'un trousseau de clés AWS KMS](#javascript-example-decrypt)
## Chiffrer des données à l'aide d'un trousseau de clés AWS KMS
L'exemple suivant montre comment utiliser le Kit SDK de chiffrement AWS pour JavaScript pour chiffrer et déchiffrer une chaîne courte ou un tableau d'octets.
Cet exemple présente un [AWS KMS trousseau de clés](use-kms-keyring.md), un type de porte-clés qui utilise un AWS KMS key pour générer et chiffrer des clés de données. Pour obtenir de l'aide sur la création d'un AWS KMS key, consultez la section [Création de clés](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) dans le *guide du AWS Key Management Service développeur*. Pour obtenir de l'aide pour identifier le contenu AWS KMS keys d'un AWS KMS trousseau de clés, voir [Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id)
Étape 1 : Définissez la politique d'engagement.
À partir de la version 1.7. *x* de Kit SDK de chiffrement AWS pour JavaScript, vous pouvez définir la politique d'engagement lorsque vous appelez la nouvelle `buildClient` fonction qui instancie un AWS Encryption SDK client. La `buildClient` fonction prend une valeur énumérée qui représente votre politique d'engagement. Il renvoie des `decrypt` fonctionnalités mises à jour `encrypt` et qui appliquent votre politique d'engagement lorsque vous cryptez et déchiffrez.
Les exemples suivants utilisent la `buildClient` fonction pour spécifier la [politique d'engagement par défaut](migrate-commitment-policy.md),`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Vous pouvez également utiliser le `buildClient` pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter [Limiter les clés de données chiffrées](configure.md#config-limit-keys).
```
import {
KmsKeyringBrowser,
KMS,
getClient,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-browser'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
```
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
```
Étape 2 : Construisez le porte-clés.
Créez un AWS KMS trousseau de clés pour le chiffrement.
Lorsque vous chiffrez avec un AWS KMS trousseau de clés, vous devez spécifier une *clé génératrice*, c' AWS KMS key est-à-dire une clé utilisée pour générer la clé de données en texte brut et la chiffrer. Vous pouvez également spécifier zéro ou plusieurs *clés supplémentaires* qui chiffrent la même clé de données en texte brut. Le porte-clés renvoie la clé de données en texte brut et une copie cryptée de cette clé de données pour chacun AWS KMS key des éléments du trousseau, y compris la clé du générateur. Pour déchiffrer les données, vous devez déchiffrer l'une des clés de données chiffrées.
Pour spécifier un jeu AWS KMS keys de clés de chiffrement dans le Kit SDK de chiffrement AWS pour JavaScript, vous pouvez utiliser [n'importe quel identifiant de AWS KMS clé compatible](use-kms-keyring.md#kms-keyring-id). Cet exemple utilise une clé de générateur, identifiée par son [ARN d'alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-ARN), et une clé supplémentaire, identifiée par un [ARN de clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN).
Si vous prévoyez de réutiliser votre AWS KMS trousseau de clés pour le déchiffrer, vous devez utiliser une clé pour identifier le AWS KMS keys contenu du trousseau ARNs de clés.
Avant d'exécuter ce code, remplacez les exemples AWS KMS key d'identifiants par des identifiants valides. Vous devez disposer des [autorisations requises pour utiliser les AWS KMS keys](use-kms-keyring.md#kms-keyring-permissions) dans le porte-clés.
Commencez par fournir vos informations d'identification au navigateur. Les Kit SDK de chiffrement AWS pour JavaScript exemples utilisent le [webpack. DefinePlugin](https://webpack.js.org/plugins/define-plugin/), qui remplace les constantes d'identification par vos informations d'identification réelles. Mais vous pouvez utiliser n'importe quelle méthode pour fournir vos informations d'identification. Utilisez ensuite les informations d'identification pour créer un AWS KMS client.
```
declare const credentials: {accessKeyId: string, secretAccessKey:string, sessionToken:string }
const clientProvider = getClient(KMS, {
credentials: {
accessKeyId,
secretAccessKey,
sessionToken
}
})
```
Ensuite, spécifiez AWS KMS keys la clé du générateur et la clé supplémentaire. Créez ensuite un AWS KMS trousseau de clés à l'aide du AWS KMS client et du AWS KMS keys.
```
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:alias/EncryptDecrypt'
const keyIds = ['arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab']
const keyring = new KmsKeyringBrowser({ clientProvider, generatorKeyId, keyIds })
```
```
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:alias/EncryptDecrypt'
const keyIds = ['arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab']
const keyring = new KmsKeyringNode({ generatorKeyId, keyIds })
```
Étape 3 : définissez le contexte de chiffrement.
Un [contexte de chiffrement](concepts.md#encryption-context) est un ensemble de données authentifiées supplémentaires non secrètes et arbitraires. Lorsque vous fournissez un contexte de chiffrement sur Encrypt, le contexte de chiffrement lie AWS Encryption SDK cryptographiquement le contexte de chiffrement au texte chiffré afin que le même contexte de chiffrement soit requis pour déchiffrer les données. L'utilisation d'un contexte de chiffrement est facultative, mais nous vous le recommandons dans le cadre des bonnes pratiques.
Créez un objet simple qui inclut les paires de contexte de chiffrement. La clé et la valeur de chaque paire doivent être une chaîne.
```
const context = {
stage: 'demo',
purpose: 'simple demonstration app',
origin: 'us-west-2'
}
```
```
const context = {
stage: 'demo',
purpose: 'simple demonstration app',
origin: 'us-west-2'
}
```
Étape 4 : Chiffrez les données.
Pour chiffrer les données en texte brut, appelez la fonction `encrypt`. Transmettez le AWS KMS trousseau de clés, les données en texte brut et le contexte de chiffrement.
La fonction `encrypt` renvoie un [message chiffré](concepts.md#message) (`result`) qui contient les données chiffrées, les clés de données chiffrées et les métadonnées importantes, y compris le contexte de chiffrement et la signature.
Vous pouvez [déchiffrer ce message crypté](#javascript-example-decrypt) à l'aide de n'importe quel langage AWS Encryption SDK de programmation pris en charge.
```
const plaintext = new Uint8Array([1, 2, 3, 4, 5])
const { result } = await encrypt(keyring, plaintext, { encryptionContext: context })
```
```
const plaintext = 'asdf'
const { result } = await encrypt(keyring, plaintext, { encryptionContext: context })
```
## Déchiffrer des données à l'aide d'un trousseau de clés AWS KMS
Vous pouvez utiliser le Kit SDK de chiffrement AWS pour JavaScript pour déchiffrer le message crypté et récupérer les données d'origine.
Dans cet exemple, nous déchiffrons les données que nous avons chiffrées dans l'exemple [Chiffrer des données à l'aide d'un trousseau de clés AWS KMS](#javascript-example-encrypt).
Étape 1 : Définissez la politique d'engagement.
À partir de la version 1.7. *x* de Kit SDK de chiffrement AWS pour JavaScript, vous pouvez définir la politique d'engagement lorsque vous appelez la nouvelle `buildClient` fonction qui instancie un AWS Encryption SDK client. La `buildClient` fonction prend une valeur énumérée qui représente votre politique d'engagement. Il renvoie des `decrypt` fonctionnalités mises à jour `encrypt` et qui appliquent votre politique d'engagement lorsque vous cryptez et déchiffrez.
Les exemples suivants utilisent la `buildClient` fonction pour spécifier la [politique d'engagement par défaut](migrate-commitment-policy.md),`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Vous pouvez également utiliser le `buildClient` pour limiter le nombre de clés de données chiffrées dans un message chiffré. Pour de plus amples informations, veuillez consulter [Limiter les clés de données chiffrées](configure.md#config-limit-keys).
```
import {
KmsKeyringBrowser,
KMS,
getClient,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-browser'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
```
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
```
Étape 2 : Construisez le porte-clés.
Pour déchiffrer les données, transmettez le [message chiffré](concepts.md#message) (`result`) renvoyé par la fonction `encrypt`. Le message chiffré inclut les données chiffrées, les clés de données chiffrées et les métadonnées importantes, y compris le contexte de chiffrement et la signature.
Vous devez également spécifier un [AWS KMS trousseau de clés](use-kms-keyring.md) lors du déchiffrement. Vous pouvez utiliser le même porte-clés que celui utilisé pour chiffrer les données ou un autre porte-clés. Pour réussir, au moins l'un des AWS KMS key éléments du jeu de clés de déchiffrement doit être capable de déchiffrer l'une des clés de données chiffrées du message chiffré. Étant donné qu'aucune clé de données n'est générée, vous n'avez pas besoin de spécifier une clé de générateur dans un porte-clés de déchiffrement. Si vous le faites, la clé de générateur et les clés supplémentaires sont traitées de la même manière.
Pour spécifier un jeu AWS KMS key de clés de déchiffrement dans le Kit SDK de chiffrement AWS pour JavaScript, vous devez utiliser l'[ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) de la clé. Dans le cas contraire, le n' AWS KMS key est pas reconnu. Pour obtenir de l'aide pour identifier le contenu AWS KMS keys d'un AWS KMS trousseau de clés, voir [Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id)
Si vous utilisez le même trousseau de clés pour le chiffrement et le déchiffrement, utilisez la clé pour identifier celui qui se trouve dans le trousseau ARNs de clés. AWS KMS keys
Dans cet exemple, nous créons un jeu de clés qui inclut uniquement l'un des éléments du jeu AWS KMS keys de clés de chiffrement. Avant d'exécuter ce code, remplacez l'exemple d'ARN de clé par un ARN valide. Vous devez bénéficier de l'autorisation `kms:Decrypt` sur la AWS KMS key.
Commencez par fournir vos informations d'identification au navigateur. Les Kit SDK de chiffrement AWS pour JavaScript exemples utilisent le [webpack. DefinePlugin](https://webpack.js.org/plugins/define-plugin/), qui remplace les constantes d'identification par vos informations d'identification réelles. Mais vous pouvez utiliser n'importe quelle méthode pour fournir vos informations d'identification. Utilisez ensuite les informations d'identification pour créer un AWS KMS client.
```
declare const credentials: {accessKeyId: string, secretAccessKey:string, sessionToken:string }
const clientProvider = getClient(KMS, {
credentials: {
accessKeyId,
secretAccessKey,
sessionToken
}
})
```
Créez ensuite un AWS KMS trousseau de clés à l'aide du AWS KMS client. Cet exemple n'utilise que l'un des éléments AWS KMS keys du jeu de clés de chiffrement.
```
const keyIds = ['arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab']
const keyring = new KmsKeyringBrowser({ clientProvider, keyIds })
```
```
const keyIds = ['arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab']
const keyring = new KmsKeyringNode({ keyIds })
```
Étape 3 : décrypter les données
Appelez ensuite la fonction `decrypt`. Transmettez le porte-clés de déchiffrement que vous venez de créer (`keyring`) et le [message chiffré](concepts.md#message) renvoyé par la fonction `encrypt` (`result`). Il AWS Encryption SDK utilise le trousseau de clés pour déchiffrer l'une des clés de données cryptées. Il utilise ensuite la clé de données en texte brut pour déchiffrer les données.
Si l'appel réussit, le champ `plaintext` contient les données en texte brut (déchiffrées). Le champ `messageHeader` contient des métadonnées sur le processus de déchiffrement, y compris le contexte de chiffrement utilisé pour déchiffrer les données.
```
const { plaintext, messageHeader } = await decrypt(keyring, result)
```
```
const { plaintext, messageHeader } = await decrypt(keyring, result)
```
Étape 4 : Vérifiez le contexte de chiffrement.
Le [contexte de chiffrement](concepts.md#encryption-context) utilisé pour déchiffrer les données est inclus dans l'en-tête de message (`messageHeader`) renvoyé par la fonction `decrypt`. Avant que votre application renvoie les données en texte brut, vérifiez que le contexte de chiffrement que vous avez fourni lors du chiffrement est inclus dans le contexte de chiffrement utilisé lors du déchiffrement. Une incompatibilité peut indiquer que les données ont été altérées ou que vous n'avez pas déchiffré le bon texte chiffré.
Lors de la vérification du contexte de chiffrement, la correspondance exacte n'est pas obligatoire. Lorsque vous utilisez un algorithme de chiffrement avec signature, le [gestionnaire de matériaux de chiffrement](concepts.md#crypt-materials-manager) (CMM) ajoute la clé de signature publique au contexte de chiffrement avant de chiffrer le message. Cependant, toutes les paires de contexte de chiffrement que vous avez soumises doivent être incluses dans le contexte de chiffrement qui a été renvoyé.
Tout d'abord, récupérez le contexte de chiffrement à partir de l'en-tête du message. Vérifiez ensuite que chaque paire clé-valeur du contexte de chiffrement d'origine (`context`) correspond à une paire clé-valeur dans le contexte de chiffrement renvoyé (`encryptionContext`).
```
const { encryptionContext } = messageHeader
Object
.entries(context)
.forEach(([key, value]) => {
if (encryptionContext[key] !== value) throw new Error('Encryption Context does not match expected values')
})
```
```
const { encryptionContext } = messageHeader
Object
.entries(context)
.forEach(([key, value]) => {
if (encryptionContext[key] !== value) throw new Error('Encryption Context does not match expected values')
})
```
Si la vérification du contexte de chiffrement aboutit, vous pouvez renvoyer les données en texte brut.
# Kit SDK de chiffrement AWS pour Python
Cette rubrique explique comment installer et utiliser le kit Kit SDK de chiffrement AWS pour Python. Pour plus de détails sur la programmation avec le Kit SDK de chiffrement AWS pour Python, consultez le [aws-encryption-sdk-python](https://github.com/aws/aws-encryption-sdk-python/)référentiel sur GitHub. Pour la documentation de l'API, veuillez consulter [Lire les documents](https://aws-encryption-sdk-python.readthedocs.io/en/latest/).
**Topics**
+ [Conditions préalables](#python-prerequisites)
+ [Installation](#python-installation)
+ [Exemples](python-example-code.md)
## Conditions préalables
Avant d'installer le Kit SDK de chiffrement AWS 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 les Kit SDK de chiffrement AWS pour Python versions 3.2.0 et ultérieures.
La bibliothèque MPL ([AWS Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library)) est une dépendance facultative de celle Kit SDK de chiffrement AWS pour Python introduite dans la version 4. *x.* Si vous avez l'intention d'installer le MPL, vous devez utiliser Python 3.11 ou version ultérieure.
Les versions antérieures du logiciel AWS Encryption SDK prennent en charge Python 2.7, Python 3.4 et versions ultérieures, mais nous vous recommandons d'utiliser la dernière version du AWS Encryption SDK.
Pour télécharger Python, consultez [Téléchargements Python](https://www.python.org/downloads/).
**Outil d'installation pip pour Python**
`pip`est inclus dans Python 3.6 et versions ultérieures, mais vous souhaiterez peut-être le mettre à niveau. Pour plus d'informations sur la mise à niveau ou l'installation`pip`, consultez la section [Installation](https://pip.pypa.io/en/latest/installation/) dans la `pip` documentation.
## Installation
Installez la dernière version de Kit SDK de chiffrement AWS pour Python.
**Note**
Toutes les versions Kit SDK de chiffrement AWS pour Python antérieures à 3.0.0 sont en [end-of-supportphase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle).
Vous pouvez effectuer la mise à jour en toute sécurité à partir de la version 2.0. *x* et versions ultérieures vers la dernière version du AWS Encryption SDK sans aucune modification du code ou des données. Cependant, de [nouvelles fonctionnalités de sécurité](about-versions.md#version-2) ont été introduites dans la version 2.0. *x* ne sont pas rétrocompatibles. Pour effectuer une mise à jour à partir de versions antérieures à 1.7. *x* vers la version 2.0. *x* et versions ultérieures, vous devez d'abord effectuer la mise à jour vers la dernière version 1. version *x* du AWS Encryption SDK. Pour en savoir plus, consultez [Migration de votre AWS Encryption SDK](migration.md).
`pip`À utiliser pour installer le Kit SDK de chiffrement AWS pour Python, comme indiqué dans les exemples suivants.
**Pour installer la dernière version**
```
pip install "aws-encryption-sdk[MPL]"
```
Le `[MPL]` suffixe installe la bibliothèque MPL ([AWS Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library)). Le MPL contient des structures permettant de chiffrer et de déchiffrer vos données. Le MPL est une dépendance optionnelle pour la version Kit SDK de chiffrement AWS pour Python introduite dans la version 4. *x.* Nous vous recommandons vivement d'installer le MPL. Toutefois, si vous n'avez pas l'intention d'utiliser le MPL, vous pouvez omettre le `[MPL]` suffixe.
Pour plus d'informations sur l'utilisation de pip pour installer et mettre à niveau les packages, consultez [Installation des packages](https://packaging.python.org/tutorials/installing-packages/).
Kit SDK de chiffrement AWS pour Python Nécessite la [bibliothèque de cryptographie](https://cryptography.io/en/latest/) (pyca/cryptography) sur toutes les plateformes. Toutes les versions de installent et compilent `pip` automatiquement la `cryptography` bibliothèque sous Windows. `pip`8.1 et versions ultérieures s'installent et se compilent automatiquement sous `cryptography` Linux. Si vous utilisez une version antérieure de `pip` et que votre environnement Linux ne dispose pas des outils nécessaires pour créer la `cryptography` bibliothèque, vous devez les installer. Pour de plus amples informations, veuillez consulter [Building cryptography on Linux](https://cryptography.io/en/latest/installation.html#building-cryptography-on-linux).
Les versions 1.10.0 et 2.5.0 de la norme situent la Kit SDK de chiffrement AWS pour Python dépendance [cryptographique](https://cryptography.io/en/latest/) entre 2.5.0 et 3.3.2. Les autres versions Kit SDK de chiffrement AWS pour Python installent la dernière version de cryptographie. Si vous avez besoin d'une version de cryptographie ultérieure à la version 3.3.2, nous vous recommandons d'utiliser la dernière version majeure du. Kit SDK de chiffrement AWS pour Python
Pour obtenir la dernière version de développement du Kit SDK de chiffrement AWS pour Python, accédez au [aws-encryption-sdk-python](https://github.com/aws/aws-encryption-sdk-python/)référentiel dans GitHub.
Après avoir installé le Kit SDK de chiffrement AWS pour Python, commencez par consulter l'[exemple de code Python présenté](python-example-code.md) dans ce guide.
# Kit SDK de chiffrement AWS pour Python exemple de code
Les exemples suivants vous montrent comment utiliser le Kit SDK de chiffrement AWS pour Python pour chiffrer et déchiffrer des données.
Les exemples présentés dans cette section montrent comment utiliser la version 4. *x* du Kit SDK de chiffrement AWS pour Python avec la dépendance optionnelle de la [bibliothèque des fournisseurs de matériel cryptographique](https://github.com/aws/aws-cryptographic-material-providers-library) (`aws-cryptographic-material-providers`). Pour consulter des exemples utilisant des versions antérieures ou des installations sans la bibliothèque des fournisseurs de matériaux (MPL), recherchez votre version dans la liste des [versions](https://github.com/aws/aws-encryption-sdk-python/releases) du [aws-encryption-sdk-python](https://github.com/aws/aws-encryption-sdk-python/)référentiel sur GitHub.
Lorsque vous utilisez la version 4. *x* du Kit SDK de chiffrement AWS pour Python avec le MPL, il utilise des trousseaux de [clés pour chiffrer](choose-keyring.md) les [enveloppes.](concepts.md#envelope-encryption) AWS Encryption SDK Il fournit des porte-clés compatibles avec les fournisseurs de clés principales que vous utilisiez dans les versions précédentes. Pour de plus amples informations, veuillez consulter [Compatibilité du porte-clés](choose-keyring.md#keyring-compatibility). Pour des exemples de migration depuis des fournisseurs de clés principales vers des porte-clés, voir [Exemples de migration](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/migration) dans le `aws-encryption-sdk-python` référentiel sur ; GitHub
**Topics**
+ [Chaînes](#python-example-strings)
+ [Flux d'octets](#python-example-streams)
## Chiffrement et déchiffrement de chaînes
L'exemple suivant montre comment utiliser le AWS Encryption SDK pour chiffrer et déchiffrer des chaînes. Cet exemple utilise un [AWS KMS trousseau de clés](use-kms-keyring.md) avec une clé KMS de chiffrement symétrique.
Cet exemple instancie le AWS Encryption SDK client avec la [politique d'engagement par défaut](migrate-commitment-policy.md),. `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Pour de plus amples informations, veuillez consulter [Définition de votre politique d'engagement](migrate-commitment-policy.md).
```
# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
This example sets up the KMS Keyring
The AWS KMS keyring uses symmetric encryption KMS keys to generate, encrypt and
decrypt data keys. This example creates a KMS Keyring and then encrypts a custom input EXAMPLE_DATA
with an encryption context. This example also includes some sanity checks for demonstration:
1. Ciphertext and plaintext data are not the same
2. Encryption context is correct in the decrypted message header
3. Decrypted plaintext value matches EXAMPLE_DATA
These sanity checks are for demonstration in the example only. You do not need these in your code.
AWS KMS keyrings can be used independently or in a multi-keyring with other keyrings
of the same or a different type.
"""
import boto3
from aws_cryptographic_material_providers.mpl import AwsCryptographicMaterialProviders
from aws_cryptographic_material_providers.mpl.config import MaterialProvidersConfig
from aws_cryptographic_material_providers.mpl.models import CreateAwsKmsKeyringInput
from aws_cryptographic_material_providers.mpl.references import IKeyring
from typing import Dict # noqa pylint: disable=wrong-import-order
import aws_encryption_sdk
from aws_encryption_sdk import CommitmentPolicy
EXAMPLE_DATA: bytes = b"Hello World"
def encrypt_and_decrypt_with_keyring(
kms_key_id: str
):
"""Demonstrate an encrypt/decrypt cycle using an AWS KMS keyring.
Usage: encrypt_and_decrypt_with_keyring(kms_key_id)
:param kms_key_id: KMS Key identifier for the KMS key you want to use for encryption and
decryption of your data keys.
:type kms_key_id: string
"""
# 1. Instantiate the encryption SDK client.
# This builds the client with the REQUIRE_ENCRYPT_REQUIRE_DECRYPT commitment policy,
# which enforces that this client only encrypts using committing algorithm suites and enforces
# that this client will only decrypt encrypted messages that were created with a committing
# algorithm suite.
# This is the default commitment policy if you were to build the client as
# `client = aws_encryption_sdk.EncryptionSDKClient()`.
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# 2. Create a boto3 client for KMS.
kms_client = boto3.client('kms', region_name="us-west-2")
# 3. Optional: create encryption context.
# Remember that your encryption context is NOT SECRET.
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# 4. Create your keyring
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
kms_key_id=kms_key_id,
kms_client=kms_client
)
kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
input=keyring_input
)
# 5. Encrypt the data with the encryptionContext.
ciphertext, _ = client.encrypt(
source=EXAMPLE_DATA,
keyring=kms_keyring,
encryption_context=encryption_context
)
# 6. Demonstrate that the ciphertext and plaintext are different.
# (This is an example for demonstration; you do not need to do this in your own code.)
assert ciphertext != EXAMPLE_DATA, \
"Ciphertext and plaintext data are the same. Invalid encryption"
# 7. Decrypt your encrypted data using the same keyring you used on encrypt.
plaintext_bytes, _ = client.decrypt(
source=ciphertext,
keyring=kms_keyring,
# Provide the encryption context that was supplied to the encrypt method
encryption_context=encryption_context,
)
# 8. Demonstrate that the decrypted plaintext is identical to the original plaintext.
# (This is an example for demonstration; you do not need to do this in your own code.)
assert plaintext_bytes == EXAMPLE_DATA, \
"Decrypted plaintext should be identical to the original plaintext. Invalid decryption"
```
## Chiffrement et déchiffrement de flux d'octets
L'exemple suivant montre comment utiliser le AWS Encryption SDK pour chiffrer et déchiffrer des flux d'octets. Cet exemple utilise un trousseau de [clés AES brut](use-raw-aes-keyring.md).
Cet exemple instancie le AWS Encryption SDK client avec la [politique d'engagement par défaut](migrate-commitment-policy.md),. `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Pour de plus amples informations, veuillez consulter [Définition de votre politique d'engagement](migrate-commitment-policy.md).
```
# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
This example demonstrates file streaming for encryption and decryption.
File streaming is useful when the plaintext or ciphertext file/data is too large to load into
memory. Therefore, the AWS Encryption SDK allows users to stream the data, instead of loading it
all at once in memory. In this example, we demonstrate file streaming for encryption and decryption
using a Raw AES keyring. However, you can use any keyring with streaming.
This example creates a Raw AES Keyring and then encrypts an input stream from the file
`plaintext_filename` with an encryption context to an output (encrypted) file `ciphertext_filename`.
It then decrypts the ciphertext from `ciphertext_filename` to a new file `decrypted_filename`.
This example also includes some sanity checks for demonstration:
1. Ciphertext and plaintext data are not the same
2. Encryption context is correct in the decrypted message header
3. Decrypted plaintext value matches EXAMPLE_DATA
These sanity checks are for demonstration in the example only. You do not need these in your code.
See raw_aes_keyring_example.py in the same directory for another raw AES keyring example
in the AWS Encryption SDK for Python.
"""
import filecmp
import secrets
from aws_cryptographic_material_providers.mpl import AwsCryptographicMaterialProviders
from aws_cryptographic_material_providers.mpl.config import MaterialProvidersConfig
from aws_cryptographic_material_providers.mpl.models import AesWrappingAlg, CreateRawAesKeyringInput
from aws_cryptographic_material_providers.mpl.references import IKeyring
from typing import Dict # noqa pylint: disable=wrong-import-order
import aws_encryption_sdk
from aws_encryption_sdk import CommitmentPolicy
def encrypt_and_decrypt_with_keyring(
plaintext_filename: str,
ciphertext_filename: str,
decrypted_filename: str
):
"""Demonstrate a streaming encrypt/decrypt cycle.
Usage: encrypt_and_decrypt_with_keyring(plaintext_filename
ciphertext_filename
decrypted_filename)
:param plaintext_filename: filename of the plaintext data
:type plaintext_filename: string
:param ciphertext_filename: filename of the ciphertext data
:type ciphertext_filename: string
:param decrypted_filename: filename of the decrypted data
:type decrypted_filename: string
"""
# 1. Instantiate the encryption SDK client.
# This builds the client with the REQUIRE_ENCRYPT_REQUIRE_DECRYPT commitment policy,
# which enforces that this client only encrypts using committing algorithm suites and enforces
# that this client will only decrypt encrypted messages that were created with a committing
# algorithm suite.
# This is the default commitment policy if you were to build the client as
# `client = aws_encryption_sdk.EncryptionSDKClient()`.
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# 2. The key namespace and key name are defined by you.
# and are used by the Raw AES keyring to determine
# whether it should attempt to decrypt an encrypted data key.
key_name_space = "Some managed raw keys"
key_name = "My 256-bit AES wrapping key"
# 3. Optional: create encryption context.
# Remember that your encryption context is NOT SECRET.
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# 4. Generate a 256-bit AES key to use with your keyring.
# In practice, you should get this key from a secure key management system such as an HSM.
# Here, the input to secrets.token_bytes() = 32 bytes = 256 bits
static_key = secrets.token_bytes(32)
# 5. Create a Raw AES keyring
# We choose to use a raw AES keyring, but any keyring can be used with streaming.
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
keyring_input: CreateRawAesKeyringInput = CreateRawAesKeyringInput(
key_namespace=key_name_space,
key_name=key_name,
wrapping_key=static_key,
wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
)
raw_aes_keyring: IKeyring = mat_prov.create_raw_aes_keyring(
input=keyring_input
)
# 6. Encrypt the data stream with the encryptionContext
with open(plaintext_filename, 'rb') as pt_file, open(ciphertext_filename, 'wb') as ct_file:
with client.stream(
mode='e',
source=pt_file,
keyring=raw_aes_keyring,
encryption_context=encryption_context
) as encryptor:
for chunk in encryptor:
ct_file.write(chunk)
# 7. Demonstrate that the ciphertext and plaintext are different.
# (This is an example for demonstration; you do not need to do this in your own code.)
assert not filecmp.cmp(plaintext_filename, ciphertext_filename), \
"Ciphertext and plaintext data are the same. Invalid encryption"
# 8. Decrypt your encrypted data stream using the same keyring you used on encrypt.
with open(ciphertext_filename, 'rb') as ct_file, open(decrypted_filename, 'wb') as pt_file:
with client.stream(
mode='d',
source=ct_file,
keyring=raw_aes_keyring,
encryption_context=encryption_context
) as decryptor:
for chunk in decryptor:
pt_file.write(chunk)
# 10. Demonstrate that the decrypted plaintext is identical to the original plaintext.
# (This is an example for demonstration; you do not need to do this in your own code.)
assert filecmp.cmp(plaintext_filename, decrypted_filename), \
"Decrypted plaintext should be identical to the original plaintext. Invalid decryption"
```
# AWS Encryption SDK pour Rust
Cette rubrique explique comment installer et utiliser AWS Encryption SDK for Rust. Pour plus de détails sur la programmation avec AWS Encryption SDK for Rust, consultez le répertoire [Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/) du aws-encryption-sdk dépôt sur GitHub.
Le AWS Encryption SDK for Rust diffère de certaines des autres implémentations du langage de programmation de la AWS Encryption SDK manière suivante :
+ Aucune prise en charge de la [mise en cache des clés de données](data-key-caching.md). Cependant, AWS Encryption SDK for Rust prend en charge le [keyring AWS KMS hiérarchique](use-hierarchical-keyring.md), une solution alternative de mise en cache des matériaux cryptographiques.
+ Pas de support pour le streaming de données
Le AWS Encryption SDK for Rust inclut toutes les fonctionnalités de sécurité introduites dans les versions 2.0. *x* et versions ultérieures d'autres implémentations linguistiques du AWS Encryption SDK. Toutefois, si vous utilisez le AWS Encryption SDK for Rust pour déchiffrer des données chiffrées par une version antérieure à la version 2.0. version *x*, autre implémentation linguistique du AWS Encryption SDK, vous devrez peut-être ajuster votre [politique d'engagement](concepts.md#commitment-policy). Pour en savoir plus, consultez [Comment définir votre politique d'engagement](migrate-commitment-policy.md#migrate-commitment-step1).
The AWS Encryption SDK for Rust est un produit d' AWS Encryption SDK in [Dafny](https://github.com/dafny-lang/dafny/blob/master/README.md), un langage de vérification formel dans lequel vous écrivez des spécifications, le code pour les implémenter et les preuves pour les tester. Le résultat est une bibliothèque qui implémente les fonctionnalités du AWS Encryption SDK dans un framework garantissant l'exactitude fonctionnelle.
**En savoir plus**
+ Pour des exemples montrant comment configurer des options dans le AWS Encryption SDK, telles que la spécification d'une suite d'algorithmes alternative, la limitation des clés de données chiffrées et l'utilisation de clés AWS KMS multirégionales, voir[Configuration du AWS Encryption SDK](configure.md).
+ Pour des exemples montrant comment configurer et utiliser AWS Encryption SDK for Rust, consultez les [exemples de Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples) dans le aws-encryption-sdk référentiel sur GitHub.
**Topics**
+ [Conditions préalables](#prerequisites-rust)
+ [Installation](#rust-installation)
+ [Exemples](rust-examples.md)
## Conditions préalables
Avant d'installer le AWS Encryption SDK pour Rust, assurez-vous que vous avez les prérequis suivants.
**Installez Rust and Cargo**
Installez la version stable actuelle de [Rust](https://www.rust-lang.org/) à l'aide de [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
Le AWS Encryption SDK for Rust est disponible sous forme de [https://crates.io/crates/aws-esdk](https://crates.io/crates/aws-esdk)caisse sur Crates.io. Pour plus de détails sur l'installation et la compilation de AWS Encryption SDK for Rust, consultez le [fichier README.md](https://github.com/aws/aws-encryption-sdk/tree/mainline) dans le référentiel sur aws-encryption-sdk. GitHub
Vous pouvez installer le AWS Encryption SDK pour Rust de la manière suivante.
**Manuellement**
Pour installer le AWS Encryption SDK pour Rust, clonez ou téléchargez le [aws-encryption-sdk](https://github.com/aws/aws-encryption-sdk/tree/mainline) GitHub dépôt.
**Utilisation de Crates.io**
Exécutez la commande Cargo suivante dans le répertoire de votre projet :
```
cargo add aws-esdk
```
Ou ajoutez la ligne suivante à votre Cargo.toml :
```
aws-esdk = ""
```
# AWS Encryption SDK pour un exemple de code Rust
Les exemples suivants montrent les modèles de codage de base que vous utilisez lors de la programmation avec AWS Encryption SDK for Rust. Plus précisément, vous instanciez la bibliothèque AWS Encryption SDK et les fournisseurs de matériaux. Ensuite, avant d'appeler chaque méthode, vous instanciez l'objet qui définit l'entrée de la méthode.
Pour des exemples montrant comment configurer les options dans le AWS Encryption SDK, telles que la spécification d'une suite d'algorithmes alternative et la limitation des clés de données chiffrées, consultez les [exemples Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples/) dans le aws-encryption-sdk référentiel sur GitHub.
## Chiffrer et déchiffrer des données dans for Rust AWS Encryption SDK
Cet exemple montre le schéma de base pour le chiffrement et le déchiffrement des données. Il chiffre un petit fichier à l'aide de clés de données protégées par une clé AWS KMS d'encapsulation.
**Étape 1 : Instancier le. AWS Encryption SDK**
Vous allez utiliser les méthodes décrites dans le AWS Encryption SDK pour chiffrer et déchiffrer les données.
```
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
```
**Étape 2 : créer un AWS KMS client**
```
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
```
**Facultatif : créez votre contexte de chiffrement.**
```
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
```
**Étape 3 : Instancier la bibliothèque des fournisseurs de matériaux.**
Vous allez utiliser les méthodes de la bibliothèque des fournisseurs de matériel pour créer les porte-clés qui spécifient les clés qui protègent vos données.
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
```
**Étape 4 : Créez un AWS KMS porte-clés**
Pour créer le trousseau de clés, appelez la méthode du trousseau avec l'objet de saisie du trousseau de clés. Cet exemple utilise la `create_aws_kms_keyring()` méthode et spécifie une clé KMS.
```
let kms_keyring = mpl
.create_aws_kms_keyring()
.kms_key_id(kms_key_id)
.kms_client(kms_client)
.send()
.await?;
```
**Étape 5 : Chiffrez le texte en clair.**
```
let plaintext = example_data.as_bytes();
let encryption_response = esdk_client.encrypt()
.plaintext(plaintext)
.keyring(kms_keyring.clone())
.encryption_context(encryption_context.clone())
.send()
.await?;
let ciphertext = encryption_response
.ciphertext
.expect("Unable to unwrap ciphertext from encryption response");
```
**Étape 6 : Déchiffrez vos données cryptées en utilisant le même trousseau de clés que celui que vous avez utilisé sur Encrypt.**
```
let decryption_response = esdk_client.decrypt()
.ciphertext(ciphertext)
.keyring(kms_keyring)
// Provide the encryption context that was supplied to the encrypt method
.encryption_context(encryption_context)
.send()
.await?;
let decrypted_plaintext = decryption_response
.plaintext
.expect("Unable to unwrap plaintext from decryption response");
```
# AWS Encryption SDK interface de ligne de commande
L'interface de ligne de AWS Encryption SDK commande (CLI de AWS chiffrement) vous permet de chiffrer et AWS Encryption SDK de déchiffrer des données de manière interactive sur la ligne de commande et dans des scripts. Vous n'avez pas besoin d'être un expert en chiffrement ou en programmation.
**Note**
Les versions de la CLI de AWS chiffrement antérieures à la version 4.0.0 sont en [end-of-supportcours de phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle).
Vous pouvez effectuer la mise à jour en toute sécurité à partir de la version 2.1. *x* et versions ultérieures vers la dernière version de la CLI de AWS chiffrement sans aucune modification du code ou des données. Cependant, de [nouvelles fonctionnalités de sécurité](about-versions.md#version-2) ont été introduites dans la version 2.1. *x* ne sont pas rétrocompatibles. Pour effectuer une mise à jour à partir de la version 1.7. *x* ou version antérieure, vous devez d'abord effectuer la mise à jour vers la dernière version 1. version *x* de la CLI AWS de chiffrement. Pour en savoir plus, consultez [Migration de votre AWS Encryption SDK](migration.md).
Les nouvelles fonctionnalités de sécurité ont été initialement publiées dans les versions 1.7 de la CLI de AWS chiffrement. *x* et 2.0. *x.* Cependant, AWS Encryption CLI version 1.8. *x* remplace la version 1.7. *x* et CLI de AWS chiffrement 2.1. *x* remplace 2.0. *x.* Pour plus de détails, consultez l'[avis de sécurité](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) correspondant dans le [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)référentiel sur GitHub.
Comme toutes les implémentations du AWS Encryption SDK, la CLI de AWS chiffrement offre des fonctionnalités avancées de protection des données. [Il s'agit notamment du [chiffrement des enveloppes](https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/how-it-works.html#envelope-encryption), des données authentifiées supplémentaires (AAD) et des [suites d'algorithmes](https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/supported-algorithms.html) de clés sécurisés, authentifiés et symétriques, tels que l'AES-GCM 256 bits avec dérivation de clés, engagement des clés et signature.](concepts.md#key-commitment)
La CLI de AWS chiffrement est basée sur Linux, macOS [Kit SDK de chiffrement AWS pour Python](python.md)et Windows et est prise en charge sur Linux. Vous pouvez exécuter des commandes et des scripts pour chiffrer et déchiffrer vos données dans le shell de votre choix sous Linux ou macOS, dans une fenêtre d'invite de commande (cmd.exe) sous Windows et dans une PowerShell console sur n'importe quel système.
Toutes les implémentations spécifiques au langage AWS Encryption SDK, y compris la AWS CLI de chiffrement, sont interopérables. Par exemple, vous pouvez chiffrer des données à l'aide de la CLI de chiffrement [Kit SDK de chiffrement AWS pour Java](java.md)et les déchiffrer à l'aide de la AWS CLI de chiffrement.
Cette rubrique présente la CLI de AWS chiffrement, explique comment l'installer et l'utiliser, et fournit plusieurs exemples pour vous aider à démarrer. Pour un démarrage rapide, consultez [Comment chiffrer et déchiffrer vos données à l'aide de la AWS CLI de chiffrement dans le](https://aws.amazon.com/blogs/security/how-to-encrypt-and-decrypt-your-data-with-the-aws-encryption-cli/) blog sur la AWS sécurité. Pour des informations plus détaillées, consultez [Read The Docs](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/) et rejoignez-nous pour développer la CLI de AWS chiffrement dans le [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)référentiel sur GitHub.
**Performance**
La CLI de AWS chiffrement est basée sur le Kit SDK de chiffrement AWS pour Python. Chaque fois que vous exécutez l'interface de ligne de commande, vous démarrez une nouvelle instance du moteur d'exécution Python. Pour améliorer les performances, dans la mesure du possible, utilisez une seule commande au lieu d'une série de commandes indépendantes. Par exemple, exécutez une commande qui traite les fichiers d'un répertoire récursivement au lieu d'exécuter des commandes séparées pour chaque fichier.
**Topics**
+ [Installation de l’interface de ligne de commande (CLI)](crypto-cli-install.md)
+ [Utilisation de l'interface de ligne de commande](crypto-cli-how-to.md)
+ [Exemples](crypto-cli-examples.md)
+ [Référence des paramètres et de la syntaxe](crypto-cli-reference.md)
+ [Versions](crypto-cli-versions.md)
# Installation de l'interface AWS Encryption SDK de ligne de commande
Cette rubrique explique comment installer la CLI AWS de chiffrement. Pour des informations détaillées, consultez le [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)référentiel sur GitHub et [lisez les documents](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/).
**Topics**
+ [Installation des éléments prérequis](#crypto-cli-prerequisites)
+ [Installation de l’interface de ligne de commande (CLI)](#install-sdk-cli)
## Installation des éléments prérequis
La CLI de AWS chiffrement est basée sur le Kit SDK de chiffrement AWS pour Python. Pour installer la CLI de AWS chiffrement, vous avez besoin de Python et `pip` de l'outil de gestion de paquets Python. Python et `pip` sont disponibles sur toutes les plateformes prises en charge.
Installez les prérequis suivants avant d'installer la CLI de AWS chiffrement :
**Python**
Python 3.8 ou version ultérieure est requis par les versions 4.2.0 et ultérieures de la CLI de AWS chiffrement.
Les versions antérieures de la CLI de AWS chiffrement prennent en charge Python 2.7, 3.4 et versions ultérieures, mais nous vous recommandons d'utiliser la dernière version de la CLI de AWS chiffrement.
Python est inclus dans la plupart des installations Linux et macOS, mais vous devez passer à Python 3.6 ou version ultérieure. Nous vous recommandons d'utiliser la dernière version de Python. Sous Windows, vous devez installer Python ; il n'est pas installé par défaut. Pour télécharger et installer Python, consultez la section [Téléchargements de Python](https://www.python.org/downloads/).
Pour déterminer si Python est installé, dans la ligne de commande, tapez les informations suivantes.
```
python
```
Pour vérifier la version de Python, utilisez le paramètre `-V` (V majuscule).
```
python -V
```
Sous Windows, après avoir installé Python, ajoutez le chemin du `Python.exe` fichier à la valeur de la variable d'environnement **Path**.
Par défaut, Python est installé dans le répertoire de tous les utilisateurs ou dans un répertoire de profil utilisateur (`$home` ou `%userprofile%`) dans le sous-répertoire `AppData\Local\Programs\Python`. Pour trouver l'emplacement du fichier `Python.exe` sur votre système, consultez l'une des clés de registre suivante. Vous pouvez l'utiliser PowerShell pour effectuer une recherche dans le registre.
```
PS C:\> dir HKLM:\Software\Python\PythonCore\version\InstallPath
# -or-
PS C:\> dir HKCU:\Software\Python\PythonCore\version\InstallPath
```
**pip**
`pip` est le gestionnaire de packages Python. Pour installer la CLI de AWS chiffrement et ses dépendances, vous devez disposer de la `pip` version 8.1 ou ultérieure. Pour obtenir de l'aide pour installer ou mettre à niveau `pip`, veuillez consulter [Installation](https://pip.pypa.io/en/latest/installing/) dans la documentation de `pip`.
Sur les installations Linux, les versions `pip` antérieures à 8.1 ne peuvent pas créer la bibliothèque de **cryptographie** requise par la CLI de AWS chiffrement. Si vous choisissez de ne pas mettre à jour votre `pip` version, vous pouvez installer les outils de compilation séparément. Pour plus d'informations, consultez [Création du chiffrement sous Linux](https://cryptography.io/en/latest/installation.html#building-cryptography-on-linux).
**AWS Command Line Interface**
Le AWS Command Line Interface (AWS CLI) n'est obligatoire que si vous utilisez AWS KMS keys in AWS Key Management Service (AWS KMS) avec la CLI de AWS chiffrement. Si vous utilisez un autre [fournisseur de clé principale](concepts.md#master-key-provider), ce n' AWS CLI est pas obligatoire.
Pour l'utiliser AWS KMS keys avec la CLI de AWS chiffrement, vous devez [installer](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) et [configurer](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-quick-configuration) le AWS CLI. La configuration met les informations d'identification que vous utilisez pour vous authentifier à la AWS KMS disposition de la CLI de AWS chiffrement.
## Installation et mise à jour de la CLI AWS de chiffrement
Installez la dernière version de la CLI de AWS chiffrement. Lorsque vous installez `pip` la CLI de AWS chiffrement, elle installe automatiquement les bibliothèques dont elle a besoin, notamment la [Kit SDK de chiffrement AWS pour Python](python.md)[bibliothèque de cryptographie](https://cryptography.io/en/latest/) Python et le. [AWS SDK pour Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
**Note**
Les versions de la CLI de AWS chiffrement antérieures à la version 4.0.0 sont en [end-of-supportcours de phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle).
Vous pouvez effectuer la mise à jour en toute sécurité à partir de la version 2.1. *x* et versions ultérieures vers la dernière version de la CLI de AWS chiffrement sans aucune modification du code ou des données. Cependant, de [nouvelles fonctionnalités de sécurité](about-versions.md#version-2) ont été introduites dans la version 2.1. *x* ne sont pas rétrocompatibles. Pour effectuer une mise à jour à partir de la version 1.7. *x* ou version antérieure, vous devez d'abord effectuer la mise à jour vers la dernière version 1. version *x* de la CLI AWS de chiffrement. Pour en savoir plus, consultez [Migration de votre AWS Encryption SDK](migration.md).
Les nouvelles fonctionnalités de sécurité ont été initialement publiées dans les versions 1.7 de la CLI de AWS chiffrement. *x* et 2.0. *x.* Cependant, AWS Encryption CLI version 1.8. *x* remplace la version 1.7. *x* et CLI de AWS chiffrement 2.1. *x* remplace 2.0. *x.* Pour plus de détails, consultez l'[avis de sécurité](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) correspondant dans le [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)référentiel sur GitHub.
**Pour installer la dernière version de la CLI de AWS chiffrement**
```
pip install aws-encryption-sdk-cli
```
**Pour effectuer une mise à niveau vers la dernière version de la CLI de AWS chiffrement**
```
pip install --upgrade aws-encryption-sdk-cli
```
**Pour trouver les numéros de version de votre CLI de AWS chiffrement et AWS Encryption SDK**
```
aws-encryption-cli --version
```
Le résultat répertorie les numéros de version des deux bibliothèques.
```
aws-encryption-sdk-cli/2.1.0 aws-encryption-sdk/2.0.0
```
**Pour effectuer une mise à niveau vers la dernière version de la CLI de AWS chiffrement**
```
pip install --upgrade aws-encryption-sdk-cli
```
L'installation de la CLI de AWS chiffrement installe également la dernière version de AWS SDK pour Python (Boto3), si elle n'est pas déjà installée. Si Boto3 est installé, le programme d'installation vérifie la version de Boto3 et la met à jour si nécessaire.
**Pour trouver la version de Boto3 que vous avez installée**
```
pip show boto3
```
**Pour effectuer la mise à jour vers la dernière version de Boto3**
```
pip install --upgrade boto3
```
Pour installer la version de la CLI de AWS chiffrement actuellement en cours de développement, consultez le [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)référentiel sur GitHub.
Pour de plus amples informations sur l'utilisation de `pip` pour installer et mettre à niveau les packages Python, veuillez consulter la [documentation pip](https://pip.pypa.io/en/stable/quickstart/).
# Comment utiliser la CLI AWS de chiffrement
Cette rubrique explique comment utiliser les paramètres de la CLI AWS de chiffrement. Pour obtenir des exemples, consultez [Exemples de CLI AWS de chiffrement](crypto-cli-examples.md). Pour obtenir la documentation complète, consultez [Lisez les documents](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/). La syntaxe présentée dans ces exemples correspond à la version 2.1 de la CLI de AWS chiffrement. *x* et versions ultérieures.
**Note**
Les versions de la CLI de AWS chiffrement antérieures à la version 4.0.0 sont en [end-of-supportcours de phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle).
Vous pouvez effectuer la mise à jour en toute sécurité à partir de la version 2.1. *x* et versions ultérieures vers la dernière version de la CLI de AWS chiffrement sans aucune modification du code ou des données. Cependant, de [nouvelles fonctionnalités de sécurité](about-versions.md#version-2) ont été introduites dans la version 2.1. *x* ne sont pas rétrocompatibles. Pour effectuer une mise à jour à partir de la version 1.7. *x* ou version antérieure, vous devez d'abord effectuer la mise à jour vers la dernière version 1. version *x* de la CLI AWS de chiffrement. Pour en savoir plus, consultez [Migration de votre AWS Encryption SDK](migration.md).
Les nouvelles fonctionnalités de sécurité ont été initialement publiées dans les versions 1.7 de la CLI de AWS chiffrement. *x* et 2.0. *x.* Cependant, AWS Encryption CLI version 1.8. *x* remplace la version 1.7. *x* et CLI de AWS chiffrement 2.1. *x* remplace 2.0. *x.* Pour plus de détails, consultez l'[avis de sécurité](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) correspondant dans le [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)référentiel sur GitHub.
Pour un exemple montrant comment utiliser la fonctionnalité de sécurité qui limite les clés de données chiffrées, voir[Limiter les clés de données chiffrées](configure.md#config-limit-keys).
Pour un exemple illustrant l'utilisation des clés AWS KMS multirégionales, consultez[Utilisation de plusieurs régions AWS KMS keys](configure.md#config-mrks).
**Topics**
+ [Procédure pour chiffrer et déchiffrer des données](#crypto-cli-e-d-intro)
+ [Comment spécifier les clés d'emballage](#crypto-cli-master-key)
+ [Procédure pour fournir une entrée](#crypto-cli-input)
+ [Procédure pour spécifier l'emplacement de sortie](#crypto-cli-output)
+ [Procédure pour utiliser un contexte de chiffrement](#crypto-cli-encryption-context)
+ [Comment définir une politique d'engagement](#crypto-cli-commitment-policy)
+ [Procédure pour stocker les paramètres dans un fichier de configuration](#crypto-cli-config-file)
## Procédure pour chiffrer et déchiffrer des données
La CLI de AWS chiffrement utilise les fonctionnalités du AWS Encryption SDK pour faciliter le chiffrement et le déchiffrement sécurisés des données.
**Note**
Le `--master-keys` paramètre est obsolète dans la version 1.8. *x* de la CLI de AWS chiffrement et supprimé dans la version 2.1. *x.* Utilisez plutôt le paramètre `--wrapping-keys`. À partir de la version 2.1. *x*, le `--wrapping-keys` paramètre est obligatoire lors du chiffrement et du déchiffrement. Pour en savoir plus, consultez [AWS Encryption SDK Syntaxe et référence des paramètres de la CLI](crypto-cli-reference.md).
+ Lorsque vous chiffrez des données dans la CLI de AWS chiffrement, vous spécifiez vos données en texte brut et une [clé d'encapsulation](concepts.md#master-key) (ou *clé principale*), telle qu'un AWS KMS key in AWS Key Management Service (AWS KMS). Si vous utilisez un fournisseur de clé principale personnalisé, vous devez également le spécifier. Vous spécifiez également les emplacements de sortie pour le [message chiffré](concepts.md#message) et pour les métadonnées relatives à l'opération de chiffrement. Le [contexte de chiffrement](concepts.md#encryption-context) est facultatif, mais il est recommandé.
Dans la version 1.8. *x*, le `--commitment-policy` paramètre est obligatoire lorsque vous l'utilisez ; dans le `--wrapping-keys` cas contraire, il n'est pas valide. À partir de la version 2.1. *x*, le `--commitment-policy` paramètre est facultatif, mais recommandé.
```
aws-encryption-cli --encrypt --input myPlaintextData \
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab \
--output myEncryptedMessage \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt
```
La AWS CLI de chiffrement chiffre vos données sous une clé de données unique. Il chiffre ensuite la clé de données sous les clés d'encapsulation que vous spécifiez. Elle renvoie un [message chiffré](concepts.md#message) et des métadonnées sur l'opération. Le message chiffré contient vos données chiffrées (*texte chiffré*) et une copie chiffrée de la clé de données. Vous n'avez pas à vous soucier du stockage, de la gestion ou de la perte de la clé de données.
+ Lorsque vous déchiffrez des données, vous transmettez votre message, le contexte de chiffrement facultatif, et l'emplacement de la sortie en texte brut et des métadonnées. Vous spécifiez également les clés d'encapsulation que la CLI de AWS chiffrement peut utiliser pour déchiffrer le message, ou vous indiquez à la CLI de AWS chiffrement qu'elle peut utiliser toutes les clés d'encapsulation qui ont chiffré le message.
À partir de la version 1.8. *x*, le `--wrapping-keys` paramètre est facultatif lors du déchiffrement, mais recommandé. À partir de la version 2.1. *x*, le `--wrapping-keys` paramètre est obligatoire lors du chiffrement et du déchiffrement.
Lors du déchiffrement, vous pouvez utiliser l'attribut **key** du `--wrapping-keys` paramètre pour spécifier les clés d'encapsulation qui déchiffrent vos données. La spécification d'une clé AWS KMS d'encapsulation lors du déchiffrement est facultative, mais il s'agit d'une [bonne pratique](best-practices.md) qui vous empêche d'utiliser une clé que vous n'aviez pas l'intention d'utiliser. Si vous utilisez un fournisseur de clé principale personnalisé, vous devez spécifier le fournisseur et la clé d'encapsulation.
Si vous n'utilisez pas l'attribut **key**, vous devez définir l'attribut de [**découverte**](#discovery-cli-attribute) du `--wrapping-keys` paramètre sur`true`, ce qui permet à la CLI de AWS chiffrement de déchiffrer à l'aide de n'importe quelle clé d'encapsulation qui a chiffré le message.
Il est recommandé d'utiliser le `--max-encrypted-data-keys` paramètre pour éviter de déchiffrer un message mal formé avec un nombre excessif de clés de données chiffrées. Spécifiez le nombre attendu de clés de données chiffrées (une pour chaque clé d'encapsulation utilisée pour le chiffrement) ou un maximum raisonnable (5, par exemple). Pour en savoir plus, consultez [Limiter les clés de données chiffrées](configure.md#config-limit-keys).
Le `--buffer` paramètre renvoie du texte brut uniquement une fois que toutes les entrées ont été traitées, y compris la vérification de la signature numérique, le cas échéant.
Le `--decrypt-unsigned` paramètre déchiffre le texte chiffré et garantit que les messages ne sont pas signés avant le déchiffrement. Utilisez ce paramètre si vous avez utilisé le `--algorithm` paramètre et sélectionné une suite d'algorithmes sans signature numérique pour chiffrer les données. Si le texte chiffré est signé, le déchiffrement échoue.
Vous pouvez utiliser `--decrypt` ou `--decrypt-unsigned` pour le déchiffrement, mais pas les deux.
```
aws-encryption-cli --decrypt --input myEncryptedMessage \
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab \
--output myPlaintextData \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt
```
La CLI de AWS chiffrement utilise la clé d'encapsulation pour déchiffrer la clé de données contenue dans le message chiffré. Elle utilise ensuite la clé de données pour déchiffrer vos données. Elle renvoie vos données en texte brut et vos métadonnées sur l'opération.
## Comment spécifier les clés d'emballage
Lorsque vous chiffrez des données dans la CLI de AWS chiffrement, vous devez spécifier au moins une [clé d'encapsulation](concepts.md#master-key) (ou *clé principale*). Vous pouvez utiliser AWS KMS keys in AWS Key Management Service (AWS KMS), encapsuler des clés provenant d'un [fournisseur de clés principales](concepts.md#master-key-provider) personnalisé, ou les deux. Le fournisseur de clés principales personnalisé peut être n'importe quel fournisseur de clés principales Python compatible.
Pour spécifier les clés d'encapsulation dans les versions 1.8. *x* et versions ultérieures, utilisez le `--wrapping-keys` paramètre (`-w`). La valeur de ce paramètre est une collection d'[attributs](#cli-master-key-attributes) au `attribute=value` format. Les attributs que vous utilisez dépendent du fournisseur de clés principales et de la commande.
+ **AWS KMS**. Dans les commandes de chiffrement, vous devez spécifier un `--wrapping-keys` paramètre avec un attribut **clé**. À partir de la version 2.1. *x*, le `--wrapping-keys` paramètre est également requis dans les commandes de déchiffrement. Lors du déchiffrement, le `--wrapping-keys` paramètre doit avoir un attribut **clé** ou un attribut de **découverte dont la** valeur est `true` (mais pas les deux). Les autres attributs sont facultatifs.
+ **Fournisseur de clés principales personnalisé**. Vous devez spécifier un `--wrapping-keys` paramètre dans chaque commande. La valeur du paramètre doit avoir des attributs **key** et **provider**.
Vous pouvez inclure [plusieurs `--wrapping-keys` paramètres](#cli-many-cmks) et plusieurs attributs **clés** dans la même commande.
### Envelopper les attributs des paramètres clés
La valeur du paramètre `--wrapping-keys` comprend les attributs suivants et leurs valeurs. Un `--wrapping-keys` paramètre (ou `--master-keys` paramètre) est obligatoire dans toutes les commandes de chiffrement. À partir de la version 2.1. *x*, le `--wrapping-keys` paramètre est également requis lors du déchiffrement.
Si le nom d'un attribut ou la valeur d'un attribut inclut des espaces ou des caractères spéciaux, entourez le nom et la valeur de guillemets. Par exemple, `--wrapping-keys key=12345 "provider=my cool provider"`.
**Clé : Spécifiez une clé d'emballage**
Utilisez l'attribut **key** pour identifier une clé d'encapsulation. Lors du chiffrement, la valeur peut être n'importe quel identifiant de clé reconnu par le fournisseur de clé principale.
```
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab
```
Dans une commande de chiffrement, vous devez inclure au moins un attribut **clé** et une valeur. Pour chiffrer votre clé de données sous plusieurs clés d'encapsulation, utilisez [plusieurs attributs **clés**](#cli-many-cmks).
```
aws-encryption-cli --encrypt --wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab key=1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d
```
Dans les commandes de chiffrement utilisées AWS KMS keys, la valeur de la **clé** peut être l'ID de la clé, son ARN clé, un nom d'alias ou un ARN d'alias. Par exemple, cette commande de chiffrement utilise un ARN d'alias dans la valeur de l'attribut **key**. Pour plus de détails sur les identificateurs de clé d'un AWS KMS key, consultez la section [Identifiants de clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) dans le guide du *AWS Key Management Service développeur*.
```
aws-encryption-cli --encrypt --wrapping-keys key=arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias
```
Dans les commandes de déchiffrement qui utilisent un fournisseur de clés principales personnalisé, les attributs **key** et **provider** sont requis.
```
\\ Custom master key provider
aws-encryption-cli --decrypt --wrapping-keys provider='myProvider' key='100101'
```
Dans les commandes de déchiffrement qui utilisent AWS KMS, vous pouvez utiliser l'attribut **key** pour spécifier l'attribut AWS KMS keys à utiliser pour le déchiffrement, ou l'[attribut de **découverte**](#discovery-cli-attribute) avec une valeur de, qui permet à la AWS CLI de `true` chiffrement d'utiliser tout ce AWS KMS key qui a été utilisé pour chiffrer le message. Si vous spécifiez un AWS KMS key, il doit s'agir de l'une des clés d'encapsulation utilisées pour chiffrer le message.
Il est recommandé de spécifier la clé d'[AWS Encryption SDK encapsulage](best-practices.md). Cela garantit que vous utilisez ce que AWS KMS key vous avez l'intention d'utiliser.
Dans une commande de déchiffrement, la valeur de l'attribut **clé** doit être un [ARN clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN).
```
\\ AWS KMS key
aws-encryption-cli --decrypt --wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
**Découverte : utilisez-en n'importe AWS KMS key laquelle lors du déchiffrement**
S'il n'est pas nécessaire de AWS KMS keys limiter l'utilisation lors du déchiffrement, vous pouvez utiliser l'attribut de **découverte** avec une valeur de. `true` La valeur de `true` permet à la CLI de AWS chiffrement de déchiffrer le message à l'aide de tout AWS KMS key ce qui a chiffré le message. Si vous ne spécifiez aucun attribut de **découverte**, la découverte est `false` (par défaut). L'attribut de **découverte** n'est valide que dans les commandes de déchiffrement et uniquement lorsque le message a été chiffré avec AWS KMS keys.
L'attribut de **découverte** dont la valeur est égale à `true` est une alternative à l'utilisation de l'attribut **clé** pour spécifier AWS KMS keys. Lors du déchiffrement d'un message chiffré avec AWS KMS keys, chaque `--wrapping-keys` paramètre doit avoir un attribut **clé** ou un attribut de **découverte** avec une valeur égale à`true`, mais pas les deux.
Lorsque la découverte est vraie, il est recommandé d'utiliser les attributs **discovery-partition et **discovery-account**** pour limiter les attributs AWS KMS keys utilisés à ceux que vous spécifiez. Comptes AWS Dans l'exemple suivant, les attributs de **découverte** permettent à la CLI de AWS chiffrement d'utiliser n'importe AWS KMS key lequel des attributs spécifiés Comptes AWS.
```
aws-encryption-cli --decrypt --wrapping-keys \
discovery=true \
discovery-partition=aws \
discovery-account=111122223333 \
discovery-account=444455556666
```
**Fournisseur : Spécifiez le fournisseur de clé principale**
L'attribut **provider** identifie le [fournisseur de clés principales](concepts.md#master-key-provider). La valeur par défaut est `aws-kms`, qui représente AWS KMS. Si vous utilisez un autre fournisseur de clés principales, l'attribut **provider** est requis.
```
--wrapping-keys key=12345 provider=my_custom_provider
```
Pour plus d'informations sur l'utilisation de fournisseurs de clés (non AWS KMS) principales personnalisés, consultez la rubrique **Configuration avancée** dans le fichier [README](https://github.com/aws/aws-encryption-sdk-cli/blob/master/README.rst) du référentiel [AWS Encryption CLI](https://github.com/aws/aws-encryption-sdk-cli/).
**Région : Spécifiez un Région AWS**
Utilisez l'attribut **region** pour spécifier Région AWS le AWS KMS key. L'attribut est valide uniquement dans les commandes de chiffrement et uniquement lorsque le fournisseur de clés principales est AWS KMS.
```
--encrypt --wrapping-keys key=alias/primary-key region=us-east-2
```
AWS Les commandes CLI de chiffrement utilisent la Région AWS valeur spécifiée dans la valeur de l'attribut **clé** si elle inclut une région, telle qu'un ARN. Si la valeur **clé** spécifie a Région AWS, l'attribut de **région** est ignoré.
L'attribut **region** est prioritaire sur les autres spécifications relatives à la région. Si vous n'utilisez pas d'attribut de région, les commandes de la CLI de AWS chiffrement utilisent Région AWS celui spécifié dans votre [profil AWS CLI nommé](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles), le cas échéant, ou dans votre profil par défaut.
**Profil : Spécifier un profil nommé**
Utilisez l'attribut de **profil** pour spécifier un AWS CLI profil nommé[ de l'](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles). Les profils nommés peuvent inclure des informations d'identification et un Région AWS. Cet attribut est valide uniquement lorsque le fournisseur de clés principales est AWS KMS.
```
--wrapping-keys key=alias/primary-key profile=admin-1
```
Vous pouvez utiliser l'attribut **profile** pour spécifier d'autres informations d'identification dans les commandes de chiffrement et de déchiffrement. Dans une commande de chiffrement, la CLI de AWS chiffrement utilise le Région AWS profil indiqué uniquement lorsque la valeur de la **clé** n'inclut pas de région et qu'il n'existe aucun attribut de **région**. Dans une commande de déchiffrement, le profil Région AWS dans le nom est ignoré.
### Comment spécifier plusieurs clés d'encapsulation
Vous pouvez spécifier plusieurs clés d'encapsulation (ou *clés principales*) dans chaque commande.
Si vous spécifiez plusieurs clés d'encapsulation, la première clé d'encapsulation génère et chiffre la clé de données utilisée pour chiffrer vos données. Les autres clés d'encapsulation chiffrent la même clé de données. Le [message chiffré](concepts.md#message) qui en résulte contient les données chiffrées (« texte chiffré ») et un ensemble de clés de données chiffrées, une clé chiffrée par chaque clé d'encapsulation. N'importe quel encapsulage peut déchiffrer une clé de données chiffrée, puis déchiffrer les données.
Il existe deux manières de spécifier plusieurs clés d'encapsulation :
+ Incluez plusieurs attributs **clés** dans la valeur du `--wrapping-keys` paramètre.
```
$key_oregon=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$key_ohio=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef
--wrapping-keys key=$key_oregon key=$key_ohio
```
+ Inclure plusieurs paramètres `--wrapping-keys` dans la même commande. Utilisez cette syntaxe lorsque les valeurs d'attribut que vous spécifiez ne s'appliquent pas à toutes les clés d'encapsulage de la commande.
```
--wrapping-keys region=us-east-2 key=alias/test_key \
--wrapping-keys region=us-west-1 key=alias/test_key
```
L'attribut de **découverte** dont la valeur est égale à `true` permet à la CLI de AWS chiffrement d'utiliser tout AWS KMS key ce qui a chiffré le message. Si vous utilisez plusieurs `--wrapping-keys` paramètres dans la même commande, l'utilisation `discovery=true` de n'importe quel `--wrapping-keys` paramètre remplace efficacement les limites de l'attribut **clé** dans `--wrapping-keys` les autres paramètres.
Par exemple, dans la commande suivante, l'attribut **clé** du premier `--wrapping-keys` paramètre limite la CLI de AWS chiffrement aux valeurs spécifiées AWS KMS key. Cependant, l'attribut de **découverte** du deuxième `--wrapping-keys` paramètre permet à la CLI de AWS chiffrement d'utiliser n'importe AWS KMS key lequel des comptes spécifiés pour déchiffrer le message.
```
aws-encryption-cli --decrypt \
--wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab \
--wrapping-keys discovery=true \
discovery-partition=aws \
discovery-account=111122223333 \
discovery-account=444455556666
```
## Procédure pour fournir une entrée
L'opération de chiffrement dans la CLI de AWS chiffrement prend des données en texte brut en entrée et renvoie un message [crypté](concepts.md#message). L'opération de déchiffrement utilise un message chiffré comme entrée et renvoie des données en texte brut.
Le `--input` paramètre (`-i`), qui indique à la CLI de AWS chiffrement où trouver l'entrée, est obligatoire dans toutes les commandes de la CLI de AWS chiffrement.
Vous pouvez fournir une entrée des façons suivantes :
+ Utiliser un fichier.
```
--input myData.txt
```
+ Utiliser un modèle de nom de fichier.
```
--input testdir/*.xml
```
+ Utiliser un répertoire ou un modèle de nom de répertoire. Lorsque l'entrée est un répertoire, le paramètre `--recursive` (`-r`, `-R`) est obligatoire.
```
--input testdir --recursive
```
+ Dirigez l'entrée vers la commande (stdin). Utilisez une valeur de `-` pour le paramètre `--input`. (Le paramètre `--input` est toujours obligatoire.)
```
echo 'Hello World' | aws-encryption-cli --encrypt --input -
```
## Procédure pour spécifier l'emplacement de sortie
Le `--output` paramètre indique à la CLI de AWS chiffrement où écrire les résultats de l'opération de chiffrement ou de déchiffrement. Il est requis dans chaque commande de la CLI de AWS chiffrement. La CLI de AWS chiffrement crée un nouveau fichier de sortie pour chaque fichier d'entrée de l'opération.
Si un fichier de sortie existe déjà, par défaut, la CLI de AWS chiffrement affiche un avertissement, puis remplace le fichier. Pour empêcher le remplacement, utilisez le paramètre `--interactive`, qui vous invite à confirmer avant le remplacement, ou le paramètre `--no-overwrite`, qui ignore l'entrée si la sortie doit entraîner un remplacement. Pour supprimer l'avertissement de remplacement, utilisez `--quiet`. Pour capturer les erreurs et les avertissements de la CLI de AWS chiffrement, utilisez l'opérateur de `2>&1` redirection pour les écrire dans le flux de sortie.
**Note**
Les commandes qui remplacent les fichiers de sortie commencent par supprimer le fichier de sortie. Si la commande échoue, il est possible que le fichier de sortie soit déjà supprimé.
Vous pouvez spécifier l'emplacement de sortie de plusieurs façons.
+ Spécifiez un nom de fichier. Si vous spécifiez un chemin d'accès au fichier, tous les répertoires du chemin doivent exister avant l'exécution de la commande.
```
--output myEncryptedData.txt
```
+ Spécifiez un répertoire. Le répertoire de sortie doit exister avant l'exécution de la commande.
Si l'entrée contient des sous-répertoires, la commande reproduit les sous-répertoires sous le répertoire spécifié.
```
--output Test
```
Lorsque l'emplacement de sortie est un répertoire (sans nom de fichier), la CLI de AWS chiffrement crée des noms de fichiers de sortie basés sur les noms des fichiers d'entrée plus un suffixe. Les opérations de chiffrement ajoutent `.encrypted` au nom du fichier d'entrée et les opérations de déchiffrement ajoutent `.decrypted`. Pour modifier le suffixe, utilisez le paramètre `--suffix`.
Par exemple, si vous chiffrez `file.txt`, la commande de chiffrement crée `file.txt.encrypted`. Si vous déchiffrez `file.txt.encrypted`, la commande de déchiffrement crée `file.txt.encrypted.decrypted`.
+ Écrivez sur la ligne de commande (stdout). Entrez une valeur de `-` pour le paramètre `--output`. Vous pouvez utiliser `--output -` pour diriger la sortie vers une autre commande ou un autre programme.
```
--output -
```
## Procédure pour utiliser un contexte de chiffrement
La CLI de AWS chiffrement vous permet de fournir un contexte de chiffrement dans les commandes de chiffrement et de déchiffrement. Ce contexte n'est pas obligatoire, mais c'est une bonne pratique de chiffrement que nous recommandons.
Un *contexte de chiffrement* est un type de *données authentifiées supplémentaires* non secrètes et arbitraires. Dans la CLI de AWS chiffrement, le contexte de chiffrement consiste en un ensemble de `name=value` paires. Vous pouvez utiliser n'importe quel contenu dans les paires, y compris les informations sur les fichiers, les données qui vous aident à identifier l'opération de chiffrement dans les journaux ou les données nécessaires pour vos droits ou vos stratégies.
**Dans une commande de chiffrement**
Le contexte de chiffrement que vous spécifiez dans une commande de chiffrement, ainsi que toutes paires supplémentaires ajoutées par le [CMM](concepts.md#crypt-materials-manager), est lié de manière chiffrée aux données chiffrées. Il est également inclus (en texte brut) dans le [message chiffré](concepts.md#encryption-context) renvoyé par la commande. Si vous utilisez un AWS KMS key, le contexte de chiffrement peut également apparaître en texte brut dans les enregistrements et les journaux d'audit, tels que AWS CloudTrail.
L'exemple suivant illustre un contexte de chiffrement avec trois paires `name=value`.
```
--encryption-context purpose=test dept=IT class=confidential
```
**Dans une commande de déchiffrement**
Dans une commande de déchiffrement, le contexte de chiffrement vous permet de confirmer que vous déchiffrez le message chiffré correct.
Vous n'êtes pas tenu de fournir un contexte de chiffrement dans une commande de déchiffrement, même si un contexte de chiffrement a été utilisé pour le chiffrement. Toutefois, si vous le faites, la CLI de AWS chiffrement vérifie que chaque élément du contexte de chiffrement de la commande de déchiffrement correspond à un élément du contexte de chiffrement du message chiffré. Si certains éléments ne correspondent pas, la commande de déchiffrement échoue.
Par exemple, la commande suivante déchiffre le message chiffré uniquement si son contexte de chiffrement inclut `dept=IT`.
```
aws-encryption-cli --decrypt --encryption-context dept=IT ...
```
Un contexte de chiffrement est un élément important de votre stratégie de sécurité. Cependant, lorsque vous choisissez un contexte de chiffrement, n'oubliez pas que ses valeurs ne sont pas secrètes. N'incluez aucune donnée confidentielle dans le contexte de chiffrement.
**Pour spécifier un contexte de chiffrement**
+ Dans une commande de **chiffrement**, utilisez le paramètre `--encryption-context` avec une ou plusieurs paires `name=value`. Séparez chaque paire par un espace.
```
--encryption-context name=value [name=value] ...
```
+ Dans une commande de **déchiffrement**, la valeur du paramètre `--encryption-context` peut inclure des paires `name=value`, des éléments `name` (sans valeur) ou une combinaison des deux.
```
--encryption-context name[=value] [name] [name=value] ...
```
Si `name` ou `value` dans une paire `name=value` contient des espaces ou des caractères spéciaux, placez la totalité de la paire entre guillemets.
```
--encryption-context "department=software engineering" "Région AWS=us-west-2"
```
Par exemple, cette commande de chiffrement inclut un contexte de chiffrement avec deux paires, `purpose=test` et `dept=23`.
```
aws-encryption-cli --encrypt --encryption-context purpose=test dept=23 ...
```
Ces commandes de déchiffrement réussiraient. Le contexte de chiffrement de chaque commande est un sous-ensemble du contexte de chiffrement d'origine.
```
\\ Any one or both of the encryption context pairs
aws-encryption-cli --decrypt --encryption-context dept=23 ...
\\ Any one or both of the encryption context names
aws-encryption-cli --decrypt --encryption-context purpose ...
\\ Any combination of names and pairs
aws-encryption-cli --decrypt --encryption-context dept purpose=test ...
```
Cependant, ces commandes de déchiffrement échoueraient. Le contexte de chiffrement du message chiffré ne contient pas les éléments spécifiés.
```
aws-encryption-cli --decrypt --encryption-context dept=Finance ...
aws-encryption-cli --decrypt --encryption-context scope ...
```
## Comment définir une politique d'engagement
Pour définir la [politique d'engagement](concepts.md#commitment-policy) de la commande, utilisez le [`--commitment-policy`paramètre](crypto-cli-reference.md#syntax-commitment-policy). Ce paramètre est introduit dans la version 1.8. *x.* Il est valide dans les commandes de chiffrement et de déchiffrement. La politique d'engagement que vous définissez n'est valide que pour la commande dans laquelle elle apparaît. Si vous ne définissez pas de politique d'engagement pour une commande, la CLI de AWS chiffrement utilise la valeur par défaut.
Par exemple, la valeur de paramètre suivante définit la politique d'engagement sur`require-encrypt-allow-decrypt`, qui chiffre toujours avec une clé d'engagement, mais déchiffre un texte chiffré avec ou sans engagement de clé.
```
--commitment-policy require-encrypt-allow-decrypt
```
## Procédure pour stocker les paramètres dans un fichier de configuration
Vous pouvez gagner du temps et éviter les erreurs de frappe en enregistrant les paramètres et les valeurs de la CLI de AWS chiffrement fréquemment utilisés dans les fichiers de configuration.
Un *fichier de configuration* est un fichier texte qui contient les paramètres et les valeurs d'une commande de la CLI de AWS chiffrement. Lorsque vous faites référence à un fichier de configuration dans une commande de la CLI de AWS chiffrement, la référence est remplacée par les paramètres et les valeurs du fichier de configuration. L'effet est le même que si vous aviez saisi le contenu d'un fichier dans la ligne de commande. Un fichier de configuration peut avoir n'importe quel nom et peut être situé dans n'importe quel répertoire auquel l'utilisateur actuel peut accéder.
L'exemple de fichier de configuration suivant `key.conf` en spécifie deux AWS KMS keys dans des régions différentes.
```
--wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
--wrapping-keys key=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef
```
Pour utiliser le fichier de configuration dans une commande, ajoutez au nom du fichier le signe arobase, `@`, en préfixe. Dans une PowerShell console, utilisez un caractère backtick pour échapper au signe arobase (``@`).
Cet exemple de commande utilise le fichier `key.conf` dans une commande de chiffrement.
------
#### [ Bash ]
```
$ aws-encryption-cli -e @key.conf -i hello.txt -o testdir
```
------
#### [ PowerShell ]
```
PS C:\> aws-encryption-cli -e `@key.conf -i .\Hello.txt -o .\TestDir
```
------
**Règles des fichiers de configuration**
Les règles relatives à l'utilisation des fichiers de configuration sont les suivantes :
+ Vous pouvez inclure plusieurs paramètres dans chaque fichier de configuration et les répertorier dans n'importe quel ordre. Répertoriez chaque paramètre avec ses valeurs (le cas échéant) sur une ligne distincte.
+ Utilisez `#` pour ajouter un commentaire à toute ou partie d'une ligne.
+ Vous pouvez inclure des références à d'autres fichiers de configuration. N'utilisez pas un backtick pour échapper au `@` panneau, même à PowerShell l'intérieur.
+ Si vous utilisez des guillemets dans un fichier de configuration, le texte entre guillemets ne peut pas s'étendre sur plusieurs lignes.
Par exemple, voici le contenu d'un exemple de fichier `encrypt.conf`.
```
# Archive Files
--encrypt
--output /archive/logs
--recursive
--interactive
--encryption-context class=unclassified dept=IT
--suffix # No suffix
--metadata-output ~/metadata
@caching.conf # Use limited caching
```
Vous pouvez également inclure plusieurs fichiers de configuration dans une commande. Cet exemple de commande utilise à la fois les fichiers de configuration `encrypt.conf` et `master-keys.conf`.
------
#### [ Bash ]
```
$ aws-encryption-cli -i /usr/logs @encrypt.conf @master-keys.conf
```
------
#### [ PowerShell ]
```
PS C:\> aws-encryption-cli -i $home\Test\*.log `@encrypt.conf `@master-keys.conf
```
------
**Suivant :** [essayez les exemples de CLI de AWS chiffrement](crypto-cli-examples.md)
# Exemples de CLI AWS de chiffrement
Utilisez les exemples suivants pour essayer la CLI de AWS chiffrement sur la plate-forme de votre choix. Pour obtenir de l'aide concernant les clés principales et d'autres paramètres, consultez [Comment utiliser la CLI AWS de chiffrement](crypto-cli-how-to.md). Pour accéder à une référence rapide, consultez [AWS Encryption SDK Syntaxe et référence des paramètres de la CLI](crypto-cli-reference.md).
**Note**
Les exemples suivants utilisent la syntaxe de la version 2.1 de la CLI de AWS chiffrement. *x.*
Les nouvelles fonctionnalités de sécurité ont été initialement publiées dans les versions 1.7 de la CLI de AWS chiffrement. *x* et 2.0. *x.* Cependant, AWS Encryption CLI version 1.8. *x* remplace la version 1.7. *x* et CLI de AWS chiffrement 2.1. *x* remplace 2.0. *x.* Pour plus de détails, consultez l'[avis de sécurité](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) correspondant dans le [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)référentiel sur GitHub.
Pour un exemple montrant comment utiliser la fonctionnalité de sécurité qui limite les clés de données chiffrées, voir[Limiter les clés de données chiffrées](configure.md#config-limit-keys).
Pour un exemple illustrant l'utilisation des clés AWS KMS multirégionales, consultez[Utilisation de plusieurs régions AWS KMS keys](configure.md#config-mrks).
**Topics**
+ [Chiffrement d'un fichier](#cli-example-encrypt-file)
+ [Déchiffrement d'un fichier](#cli-example-decrypt-file)
+ [Chiffrement de tous les fichiers d'un répertoire](#cli-example-encrypt-directory)
+ [Déchiffrement de tous les fichiers d'un répertoire](#cli-example-decrypt-directory)
+ [Chiffrement et déchiffrement sur la ligne de commande](#cli-example-stdin)
+ [Utilisation de plusieurs clés principales](#cli-example-multimaster)
+ [Chiffrement et déchiffrement dans les scripts](#cli-example-script)
+ [Utilisation de la mise en cache des clés de données](#cli-example-caching)
## Chiffrement d'un fichier
Cet exemple utilise la CLI de AWS chiffrement pour chiffrer le contenu du `hello.txt` fichier, qui contient une chaîne « Hello World ».
Lorsque vous exécutez une commande de chiffrement sur un fichier, la CLI de AWS chiffrement obtient le contenu du fichier, génère une [clé de données](concepts.md#DEK) unique, chiffre le contenu du fichier sous la clé de données, puis écrit le [message chiffré](concepts.md#message) dans un nouveau fichier.
La première commande enregistre l'ARN clé d'un AWS KMS key dans la `$keyArn` variable. Lorsque vous chiffrez avec un AWS KMS key, vous pouvez l'identifier à l'aide d'un ID de clé, d'un ARN de clé, d'un nom d'alias ou d'un ARN d'alias. Pour plus de détails sur les identificateurs de clé d'un AWS KMS key, consultez la section [Identifiants de clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) dans le guide du *AWS Key Management Service développeur*.
La seconde commande chiffre le contenu du fichier. La commande utilise le paramètre `--encrypt` pour spécifier l'opération et le paramètre `--input` pour indiquer le fichier à chiffrer. Le [`--wrapping-keys`paramètre](crypto-cli-how-to.md#crypto-cli-master-key) et son attribut **clé** requis indiquent à la commande d'utiliser l'ARN AWS KMS key représenté par la clé.
La commande utilise le paramètre `--metadata-output` pour spécifier un fichier texte pour les métadonnées à propos de l'opération de chiffrement. En tant que bonne pratique, la commande utilise le paramètre `--encryption-context` pour spécifier un [contexte de chiffrement](crypto-cli-how-to.md#crypto-cli-encryption-context).
Cette commande utilise également le [`--commitment-policy`paramètre](crypto-cli-reference.md#syntax-commitment-policy) pour définir explicitement la politique d'engagement. Dans la version 1.8. *x*, ce paramètre est obligatoire lorsque vous utilisez le `--wrapping-keys` paramètre. À partir de la version 2.1. *x*, le `--commitment-policy` paramètre est facultatif, mais recommandé.
La valeur du paramètre `--output`, un point (.), indique à la commande d'écrire le fichier de sortie dans le répertoire actuel.
------
#### [ Bash ]
```
\\ To run this example, replace the fictitious key ARN with a valid value.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ aws-encryption-cli --encrypt \
--input hello.txt \
--wrapping-keys key=$keyArn \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt \
--output .
```
------
#### [ PowerShell ]
```
# To run this example, replace the fictitious key ARN with a valid value.
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> aws-encryption-cli --encrypt `
--input Hello.txt `
--wrapping-keys key=$keyArn `
--metadata-output $home\Metadata.txt `
--commitment-policy require-encrypt-require-decrypt `
--encryption-context purpose=test `
--output .
```
------
Lorsque la commande de chiffrement aboutit, elle ne renvoie pas de sortie. Pour déterminer si la commande a abouti, vérifiez la valeur booléenne dans la variable `$?`. Lorsque la commande aboutit, la valeur de `$?` est `0` (Bash) ou `True` (PowerShell). Lorsque la commande échoue, la valeur de `$?` est différente de zéro (Bash) ou `False` (PowerShell).
------
#### [ Bash ]
```
$ echo $?
0
```
------
#### [ PowerShell ]
```
PS C:\> $?
True
```
------
Vous pouvez également utiliser une commande de liste de répertoires pour vérifier que la commande de chiffrement a créé un nouveau fichier `hello.txt.encrypted`. Comme la commande encrypt ne spécifiait pas de nom de fichier pour la sortie, la CLI de AWS chiffrement a écrit la sortie dans un fichier portant le même nom que le fichier d'entrée, plus un `.encrypted` suffixe. Pour utiliser un autre suffixe ou supprimer le suffixe, utilisez le paramètre `--suffix`.
Le fichier `hello.txt.encrypted` contient un [message chiffré](concepts.md#message) qui comprend le texte chiffré du fichier `hello.txt`, une copie chiffrée de la clé de données et des métadonnées supplémentaires, y compris le contexte de chiffrement.
------
#### [ Bash ]
```
$ ls
hello.txt hello.txt.encrypted
```
------
#### [ PowerShell ]
```
PS C:\> dir
Directory: C:\TestCLI
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/15/2017 5:57 PM 11 Hello.txt
-a---- 9/17/2017 1:06 PM 585 Hello.txt.encrypted
```
------
## Déchiffrement d'un fichier
Cet exemple utilise la CLI de AWS chiffrement pour déchiffrer le contenu du `Hello.txt.encrypted` fichier chiffré dans l'exemple précédent.
La commande de déchiffrement utilise le paramètre `--decrypt` pour indiquer l'opération et le paramètre `--input` pour identifier le fichier à déchiffrer. La valeur du paramètre `--output` est un point qui représente le répertoire actuel.
Le `--wrapping-keys` paramètre avec un attribut **clé** indique la clé d'encapsulation utilisée pour déchiffrer le message chiffré. Dans les commandes de déchiffrement avec AWS KMS keys, la valeur de l'attribut clé doit être un [ARN clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN). Le `--wrapping-keys` paramètre est obligatoire dans une commande de déchiffrement. Si vous en utilisez AWS KMS keys, vous pouvez utiliser l'attribut **key** AWS KMS keys pour spécifier le déchiffrement ou l'attribut de **découverte** avec une valeur de `true` (mais pas les deux). Si vous utilisez un fournisseur de clé principale personnalisé, les attributs de **clé** et **de fournisseur** sont obligatoires.
Le [`--commitment-policy`paramètre](crypto-cli-reference.md#syntax-commitment-policy) est facultatif à partir de la version 2.1. *x*, mais c'est recommandé. Son utilisation indique clairement votre intention, même si vous spécifiez la valeur par défaut`require-encrypt-require-decrypt`.
Le paramètre `--encryption-context` est facultatif dans la commande de déchiffrement, même lorsqu'un [contexte de chiffrement](crypto-cli-how-to.md#crypto-cli-encryption-context) est fourni dans la commande de chiffrement. Dans ce cas, la commande de déchiffrement utilise le même contexte de chiffrement que celui fourni dans la commande de chiffrement. Avant le déchiffrement, la AWS CLI de chiffrement vérifie que le contexte de chiffrement du message chiffré inclut une paire. `purpose=test` Si ce n'est pas le cas, la commande de déchiffrement échoue.
Le paramètre `--metadata-output` spécifie un fichier pour les métadonnées relatives à l'opération de déchiffrement. La valeur du paramètre `--output`, un point (.), écrit le fichier de sortie dans le répertoire actuel.
Il est recommandé d'utiliser le `--max-encrypted-data-keys` paramètre pour éviter de déchiffrer un message mal formé avec un nombre excessif de clés de données chiffrées. Spécifiez le nombre attendu de clés de données chiffrées (une pour chaque clé d'encapsulation utilisée pour le chiffrement) ou un maximum raisonnable (5, par exemple). Pour en savoir plus, consultez [Limiter les clés de données chiffrées](configure.md#config-limit-keys).
Le texte brut est `--buffer` renvoyé uniquement une fois que toutes les entrées ont été traitées, y compris la vérification de la signature numérique, le cas échéant.
------
#### [ Bash ]
```
\\ To run this example, replace the fictitious key ARN with a valid value.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys key=$keyArn \
--commitment-policy require-encrypt-require-decrypt \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output .
```
------
#### [ PowerShell ]
```
\\ To run this example, replace the fictitious key ARN with a valid value.
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> aws-encryption-cli --decrypt `
--input Hello.txt.encrypted `
--wrapping-keys key=$keyArn `
--commitment-policy require-encrypt-require-decrypt `
--encryption-context purpose=test `
--metadata-output $home\Metadata.txt `
--max-encrypted-data-keys 1 `
--buffer `
--output .
```
------
Lorsqu'une commande de déchiffrement aboutit, elle ne renvoie pas de sortie. Pour déterminer si la commande a abouti, récupérez la valeur de la variable `$?`. Vous pouvez également utiliser une commande de liste de répertoires pour vérifier que la commande a créé un nouveau fichier avec un suffixe `.decrypted`. Pour voir le contenu en texte brut, utilisez une commande pour récupérer le contenu d'un fichier, par exemple `cat` ou [Get-Content](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.management/get-content).
------
#### [ Bash ]
```
$ ls
hello.txt hello.txt.encrypted hello.txt.encrypted.decrypted
$ cat hello.txt.encrypted.decrypted
Hello World
```
------
#### [ PowerShell ]
```
PS C:\> dir
Directory: C:\TestCLI
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/17/2017 1:01 PM 11 Hello.txt
-a---- 9/17/2017 1:06 PM 585 Hello.txt.encrypted
-a---- 9/17/2017 1:08 PM 11 Hello.txt.encrypted.decrypted
PS C:\> Get-Content Hello.txt.encrypted.decrypted
Hello World
```
------
## Chiffrement de tous les fichiers d'un répertoire
Cet exemple utilise la CLI de AWS chiffrement pour chiffrer le contenu de tous les fichiers d'un répertoire.
Lorsqu'une commande affecte plusieurs fichiers, la CLI de AWS chiffrement traite chaque fichier individuellement. Elle récupère le contenu du fichier, récupère une [clé de données](concepts.md#DEK) unique pour le fichier à partir de la clé principale, chiffre le contenu du fichier sous la clé de données et écrit les résultats dans un nouveau fichier dans le répertoire de sortie. Par conséquent, vous pouvez déchiffrer les fichiers de sortie de manière indépendante.
Cette liste du répertoire `TestDir` affiche les fichiers en texte brut que nous souhaitons chiffrer.
------
#### [ Bash ]
```
$ ls testdir
cool-new-thing.py hello.txt employees.csv
```
------
#### [ PowerShell ]
```
PS C:\> dir C:\TestDir
Directory: C:\TestDir
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/12/2017 3:11 PM 2139 cool-new-thing.py
-a---- 9/15/2017 5:57 PM 11 Hello.txt
-a---- 9/17/2017 1:44 PM 46 Employees.csv
```
------
La première commande enregistre le nom [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn) d'un AWS KMS key dans la `$keyArn` variable.
La deuxième commande chiffre le contenu des fichiers dans le répertoire `TestDir` et écrit les fichiers du contenu chiffré dans le répertoire `TestEnc`. Si le répertoire `TestEnc` n'existe pas, la commande échoue. Étant donné que l'emplacement d'entrée est un répertoire, le paramètre `--recursive` est obligatoire.
Le [`--wrapping-keys`paramètre](crypto-cli-how-to.md#crypto-cli-master-key) et son attribut **clé** obligatoire spécifient la clé d'encapsulation à utiliser. La commande de chiffrement inclut un [contexte de chiffrement](crypto-cli-how-to.md#crypto-cli-encryption-context), `dept=IT`. Lorsque vous spécifiez un contexte de chiffrement dans une commande qui chiffre plusieurs fichiers, le même contexte de chiffrement est utilisée pour tous les fichiers.
La commande comporte également un `--metadata-output` paramètre indiquant à la CLI de AWS chiffrement où écrire les métadonnées relatives aux opérations de chiffrement. La CLI de AWS chiffrement écrit un enregistrement de métadonnées pour chaque fichier chiffré.
Elle [`--commitment-policy parameter`](crypto-cli-how-to.md#crypto-cli-commitment-policy)est facultative à partir de la version 2.1. *x*, mais c'est recommandé. Si la commande ou le script échoue parce qu'il ne peut pas déchiffrer un texte chiffré, le paramètre de politique d'engagement explicite peut vous aider à détecter rapidement le problème.
Lorsque la commande est terminée, la CLI de AWS chiffrement écrit les fichiers chiffrés `TestEnc` dans le répertoire, mais elle ne renvoie aucune sortie.
La dernière commande répertorie les fichiers dans le répertoire `TestEnc`. Il existe un fichier de sortie du contenu chiffré pour chaque fichier d'entrée de contenu en texte brut. Étant donné que la commande n'a pas spécifié d'autre suffixe, la commande de chiffrement a ajouté `.encrypted` à chacun des noms des fichiers d'entrée.
------
#### [ Bash ]
```
# To run this example, replace the fictitious key ARN with a valid master key identifier.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ aws-encryption-cli --encrypt \
--input testdir --recursive\
--wrapping-keys key=$keyArn \
--encryption-context dept=IT \
--commitment-policy require-encrypt-require-decrypt \
--metadata-output ~/metadata \
--output testenc
$ ls testenc
cool-new-thing.py.encrypted employees.csv.encrypted hello.txt.encrypted
```
------
#### [ PowerShell ]
```
# To run this example, replace the fictitious key ARN with a valid master key identifier.
PS C:\> $keyArn = arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
PS C:\> aws-encryption-cli --encrypt `
--input .\TestDir --recursive `
--wrapping-keys key=$keyArn `
--encryption-context dept=IT `
--commitment-policy require-encrypt-require-decrypt `
--metadata-output .\Metadata\Metadata.txt `
--output .\TestEnc
PS C:\> dir .\TestEnc
Directory: C:\TestEnc
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/17/2017 2:32 PM 2713 cool-new-thing.py.encrypted
-a---- 9/17/2017 2:32 PM 620 Hello.txt.encrypted
-a---- 9/17/2017 2:32 PM 585 Employees.csv.encrypted
```
------
## Déchiffrement de tous les fichiers d'un répertoire
Cet exemple déchiffre tous les fichiers d'un répertoire. Il commence par les fichiers du répertoire `TestEnc` qui ont été chiffrés dans l'exemple précédent.
------
#### [ Bash ]
```
$ ls testenc
cool-new-thing.py.encrypted hello.txt.encrypted employees.csv.encrypted
```
------
#### [ PowerShell ]
```
PS C:\> dir C:\TestEnc
Directory: C:\TestEnc
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/17/2017 2:32 PM 2713 cool-new-thing.py.encrypted
-a---- 9/17/2017 2:32 PM 620 Hello.txt.encrypted
-a---- 9/17/2017 2:32 PM 585 Employees.csv.encrypted
```
------
Cette commande de déchiffrement déchiffre tous les fichiers du TestEnc répertoire et écrit les fichiers en texte brut dans le répertoire. TestDec Le `--wrapping-keys` paramètre avec un attribut **clé** et une valeur [ARN clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) indique à la CLI de AWS chiffrement laquelle utiliser AWS KMS keys pour déchiffrer les fichiers. La commande utilise le `--interactive` paramètre pour indiquer à la CLI de AWS chiffrement de vous demander avant de remplacer un fichier portant le même nom.
Cette commande utilise également le contexte de chiffrement qui a été fourni lorsque les fichiers ont été chiffrés. Lors du déchiffrement de plusieurs fichiers, la AWS CLI de chiffrement vérifie le contexte de chiffrement de chaque fichier. Si la vérification du contexte de chiffrement d'un fichier échoue, la CLI de AWS chiffrement rejette le fichier, écrit un avertissement, enregistre l'échec dans les métadonnées, puis poursuit la vérification des fichiers restants. Si la CLI de AWS chiffrement ne parvient pas à déchiffrer un fichier pour une autre raison, l'ensemble de la commande de déchiffrement échoue immédiatement.
Dans cet exemple, les messages chiffrés de tous les fichiers d'entrée contiennent l'élément du contexte de chiffrement `dept=IT`. Toutefois, si vous procédiez au déchiffrement de messages ayant des contextes de chiffrement différents, vous devriez toujours être en mesure de vérifier une partie du contexte de chiffrement. Par exemple, si certains messages avaient un contexte de chiffrement `dept=finance` et d'autres messages `dept=IT`, vous pourriez vérifier que le contexte de chiffrement contient toujours un nom `dept` sans spécifier la valeur. Pour plus de précisions, vous pourriez déchiffrer les fichiers dans des commandes distinctes.
La commande de déchiffrement ne renvoie pas de sortie, mais vous pouvez utiliser une commande de liste de répertoires pour vérifier qu'elle a crée de nouveaux fichiers avec le suffixe `.decrypted`. Pour voir le contenu en texte brut, utilisez une commande pour récupérer le contenu d'un fichier.
------
#### [ Bash ]
```
# To run this example, replace the fictitious key ARN with a valid master key identifier.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ aws-encryption-cli --decrypt \
--input testenc --recursive \
--wrapping-keys key=$keyArn \
--encryption-context dept=IT \
--commitment-policy require-encrypt-require-decrypt \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output testdec --interactive
$ ls testdec
cool-new-thing.py.encrypted.decrypted hello.txt.encrypted.decrypted employees.csv.encrypted.decrypted
```
------
#### [ PowerShell ]
```
# To run this example, replace the fictitious key ARN with a valid master key identifier.
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> aws-encryption-cli --decrypt `
--input C:\TestEnc --recursive `
--wrapping-keys key=$keyArn `
--encryption-context dept=IT `
--commitment-policy require-encrypt-require-decrypt `
--metadata-output $home\Metadata.txt `
--max-encrypted-data-keys 1 `
--buffer `
--output C:\TestDec --interactive
PS C:\> dir .\TestDec
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 10/8/2017 4:57 PM 2139 cool-new-thing.py.encrypted.decrypted
-a---- 10/8/2017 4:57 PM 46 Employees.csv.encrypted.decrypted
-a---- 10/8/2017 4:57 PM 11 Hello.txt.encrypted.decrypted
```
------
## Chiffrement et déchiffrement sur la ligne de commande
Ces exemples vous montrent comment diriger l'entrée vers des commandes (stdin) et écrire la sortie dans la ligne de commande (stdout). Ils expliquent comment représenter stdin et stdout dans une commande et comment utiliser les outils de codage en Base64 intégrés pour empêcher que le shell interprète mal les caractères non-ASCII.
Cet exemple dirige une chaîne en texte brut vers une commande de chiffrement et enregistre le message chiffré dans une variable. Ensuite, il dirige le message chiffré de la variable vers une commande de déchiffrement, qui écrit sa sortie dans le pipeline (stdout).
L'exemple se compose de trois commandes :
+ La première commande enregistre l'[ARN clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) d'un AWS KMS key dans la `$keyArn` variable.
------
#### [ Bash ]
```
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
------
#### [ PowerShell ]
```
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
```
------
+ La deuxième commande dirige la chaîne `Hello World` vers la commande de chiffrement et enregistre le résultat dans la variable `$encrypted`.
Les `--output` paramètres `--input` et sont obligatoires dans toutes les commandes de la CLI de AWS chiffrement. Pour indiquer que l'entrée est dirigée vers la commande (stdin), utilisez un trait d'union (`-`) pour la valeur du paramètre `--input`. Pour envoyer la sortie vers la ligne de commande (stdout), utilisez un tiret pour la valeur du paramètre `--output`.
Le paramètre `--encode` code en base64 la sortie avant de la renvoyer. Cela empêche que le shell interprète mal les caractères non-ASCII dans le message chiffré.
Étant donné que cette commande est une simple preuve de concept, nous avons omis le contexte de chiffrement et supprimé les métadonnées (`-S`).
------
#### [ Bash ]
```
$ encrypted=$(echo 'Hello World' | aws-encryption-cli --encrypt -S \
--input - --output - --encode \
--wrapping-keys key=$keyArn )
```
------
#### [ PowerShell ]
```
PS C:\> $encrypted = 'Hello World' | aws-encryption-cli --encrypt -S `
--input - --output - --encode `
--wrapping-keys key=$keyArn
```
------
+ La troisième commande dirige le message chiffré de la variable `$encrypted` vers la commande de déchiffrement.
Cette commande de déchiffrement utilise `--input -` pour indiquer que l'entrée provient du pipeline (stdin) et `--output -` pour envoyer la sortie vers le pipeline (stdout). (Le paramètre d'entrée prend l'emplacement de l'entrée, et non les octets d'entrée réels. Vous ne pouvez donc pas utiliser la variable `$encrypted` en tant que valeur du paramètre `--input`.)
Cet exemple utilise l'attribut **discovery** du `--wrapping-keys` paramètre pour permettre à la CLI de AWS chiffrement d'en utiliser un AWS KMS key pour déchiffrer les données. Il ne spécifie pas de [politique d'engagement](concepts.md#commitment-policy), il utilise donc la valeur par défaut pour la version 2.1. *x* et versions ultérieures,`require-encrypt-require-decrypt`.
Étant donné que la sortie a été chiffrée, puis codée, la commande de déchiffrement utilise le paramètre `--decode` pour décoder l'entrée codée en Base64 avant de la déchiffrer. Vous pouvez également utiliser le paramètre `--decode` pour décoder l'entrée codée en Base64 avant de la chiffrer.
Cette fois encore, la commande omet le contexte de chiffrement et supprime les métadonnées (-`S`).
------
#### [ Bash ]
```
$ echo $encrypted | aws-encryption-cli --decrypt --wrapping-keys discovery=true --input - --output - --decode --buffer -S
Hello World
```
------
#### [ PowerShell ]
```
PS C:\> $encrypted | aws-encryption-cli --decrypt --wrapping-keys discovery=$true --input - --output - --decode --buffer -S
Hello World
```
------
Vous pouvez également effectuer les opérations de chiffrement et de déchiffrement dans une même commande sans la variable intermédiaire.
Comme dans l'exemple précédent, les paramètres `--input` et `--output` ont une valeur `-` et la commande utilise le paramètre `--encode` pour coder la sortie et le paramètre `--decode` pour décoder l'entrée.
------
#### [ Bash ]
```
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ echo 'Hello World' |
aws-encryption-cli --encrypt --wrapping-keys key=$keyArn --input - --output - --encode -S |
aws-encryption-cli --decrypt --wrapping-keys discovery=true --input - --output - --decode -S
Hello World
```
------
#### [ PowerShell ]
```
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> 'Hello World' |
aws-encryption-cli --encrypt --wrapping-keys key=$keyArn --input - --output - --encode -S |
aws-encryption-cli --decrypt --wrapping-keys discovery=$true --input - --output - --decode -S
Hello World
```
------
## Utilisation de plusieurs clés principales
Cet exemple montre comment utiliser plusieurs clés principales lors du chiffrement et du déchiffrement de données dans la CLI de chiffrement. AWS
Lorsque vous utilisez plusieurs clés principales pour chiffrer des données, n'importe quelle clé principale peut être utilisée pour déchiffrer les données. Cette stratégie garantit que vous pouvez déchiffrer les données même si l'une des clés principales n'est pas disponible. Si vous stockez les données chiffrées en plusieurs Régions AWS exemplaires, cette stratégie vous permet d'utiliser une clé principale dans la même région pour déchiffrer les données.
Lorsque vous procédez à un chiffrement avec plusieurs clés principales, la première clé principale joue un rôle spécifique. Elle génère la clé de données qui est utilisée pour chiffrer les données. Les autres clés principales chiffrent la clé de données en texte brut. Le [message chiffré](concepts.md#message) inclut les données chiffrées et un ensemble de clés de données chiffrées, une pour chaque clé principale. Même si la première clé principale a généré la clé de données, toutes les clés principales peuvent déchiffrer les clés de données, qui peuvent être utilisées pour déchiffrer les données.
**Chiffrement à l'aide de trois clés principales**
Cet exemple de commande utilise trois clés d'encapsulation pour chiffrer le `Finance.log` fichier, une clé sur trois Régions AWS.
Elle écrit ensuite le message chiffré dans le répertoire `Archive`. La commande utilise le paramètre `--suffix` sans valeur pour supprimer le suffixe. Par conséquent, les noms des fichiers d'entrée et de sortie seront les mêmes.
La commande utilise le paramètre `--wrapping-keys` avec trois attributs **key**. Vous pouvez également utiliser plusieurs paramètres `--wrapping-keys` dans la même commande.
Pour chiffrer le fichier journal, la CLI de AWS chiffrement demande à la première clé d'encapsulation de la liste de générer la clé de données qu'elle utilise pour chiffrer les données. `$key1` Il utilise ensuite chacune des autres clés d'encapsulation pour chiffrer une copie en texte brut de la même clé de données. Le message chiffré dans le fichier de sortie inclut les trois des clés de données chiffrées.
------
#### [ Bash ]
```
$ key1=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ key2=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef
$ key3=arn:aws:kms:ap-southeast-1:111122223333:key/1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d
$ aws-encryption-cli --encrypt --input /logs/finance.log \
--output /archive --suffix \
--encryption-context class=log \
--metadata-output ~/metadata \
--wrapping-keys key=$key1 key=$key2 key=$key3
```
------
#### [ PowerShell ]
```
PS C:\> $key1 = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> $key2 = 'arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef'
PS C:\> $key3 = 'arn:aws:kms:ap-southeast-1:111122223333:key/1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d'
PS C:\> aws-encryption-cli --encrypt --input D:\Logs\Finance.log `
--output D:\Archive --suffix `
--encryption-context class=log `
--metadata-output $home\Metadata.txt `
--wrapping-keys key=$key1 key=$key2 key=$key3
```
------
Cette commande déchiffre la copie chiffrée du fichier `Finance.log` et l'écrit dans un fichier `Finance.log.clear` du répertoire `Finance`. Pour déchiffrer des données chiffrées en dessous de trois AWS KMS keys, vous pouvez spécifier les trois mêmes données AWS KMS keys ou un sous-ensemble de celles-ci. Cet exemple ne spécifie que l'un des AWS KMS keys.
Pour indiquer à la CLI AWS KMS keys de AWS chiffrement laquelle utiliser pour déchiffrer vos données, utilisez l'attribut **clé** du `--wrapping-keys` paramètre. [Lors du déchiffrement avec AWS KMS keys, la valeur de l'attribut **clé** doit être un ARN clé.](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)
Vous devez être autorisé à appeler l'[API Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) sur le site AWS KMS keys que vous spécifiez. Pour plus d'informations, consultez [Authentification et contrôle d'accès pour AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html).
À titre de bonne pratique, ces exemples utilisent le `--max-encrypted-data-keys` paramètre pour éviter de déchiffrer un message mal formé avec un nombre excessif de clés de données chiffrées. Même si cet exemple n'utilise qu'une seule clé d'encapsulation pour le déchiffrement, le message chiffré comporte trois (3) clés de données chiffrées, une pour chacune des trois clés d'encapsulation utilisées lors du chiffrement. Spécifiez le nombre attendu de clés de données chiffrées ou une valeur maximale raisonnable, telle que 5. Si vous spécifiez une valeur maximale inférieure à 3, la commande échoue. Pour en savoir plus, consultez [Limiter les clés de données chiffrées](configure.md#config-limit-keys).
------
#### [ Bash ]
```
$ aws-encryption-cli --decrypt --input /archive/finance.log \
--wrapping-keys key=$key1 \
--output /finance --suffix '.clear' \
--metadata-output ~/metadata \
--max-encrypted-data-keys 3 \
--buffer \
--encryption-context class=log
```
------
#### [ PowerShell ]
```
PS C:\> aws-encryption-cli --decrypt `
--input D:\Archive\Finance.log `
--wrapping-keys key=$key1 `
--output D:\Finance --suffix '.clear' `
--metadata-output .\Metadata\Metadata.txt `
--max-encrypted-data-keys 3 `
--buffer `
--encryption-context class=log
```
------
## Chiffrement et déchiffrement dans les scripts
Cet exemple montre comment utiliser la CLI de AWS chiffrement dans les scripts. Vous pouvez écrire des scripts qui chiffrent et déchiffrent simplement les données, ou des scripts qui effectuent des chiffrements ou des déchiffrements dans le cadre d'un processus de gestion des données.
Dans cet exemple, le script obtient une collection de fichiers journaux, les compresse, les chiffre, puis copie les fichiers chiffrés dans un compartiment Amazon S3. Ce script traite chaque fichier séparément. Vous pouvez ainsi les déchiffrer et les développer de manière indépendante.
Lorsque vous compressez et chiffrez les fichiers, assurez-vous d'effectuer la compression avant le chiffrement. Les données correctement chiffrées ne sont pas compressibles.
**Avertissement**
Soyez prudent lorsque vous compressez des données qui incluent à la fois des secrets et des données pouvant être contrôlées par un utilisateur malveillant. La taille finale des données compressées peut révéler par inadvertance des informations sensibles sur son contenu.
------
#### [ Bash ]
```
# Continue running even if an operation fails.
set +e
dir=$1
encryptionContext=$2
s3bucket=$3
s3folder=$4
masterKeyProvider="aws-kms"
metadataOutput="/tmp/metadata-$(date +%s)"
compress(){
gzip -qf $1
}
encrypt(){
# -e encrypt
# -i input
# -o output
# --metadata-output unique file for metadata
# -m masterKey read from environment variable
# -c encryption context read from the second argument.
# -v be verbose
aws-encryption-cli -e -i ${1} -o $(dirname ${1}) --metadata-output ${metadataOutput} -m key="${masterKey}" provider="${masterKeyProvider}" -c "${encryptionContext}" -v
}
s3put (){
# copy file argument 1 to s3 location passed into the script.
aws s3 cp ${1} ${s3bucket}/${s3folder}
}
# Validate all required arguments are present.
if [ "${dir}" ] && [ "${encryptionContext}" ] && [ "${s3bucket}" ] && [ "${s3folder}" ] && [ "${masterKey}" ]; then
# Is $dir a valid directory?
test -d "${dir}"
if [ $? -ne 0 ]; then
echo "Input is not a directory; exiting"
exit 1
fi
# Iterate over all the files in the directory, except *gz and *encrypted (in case of a re-run).
for f in $(find ${dir} -type f \( -name "*" ! -name \*.gz ! -name \*encrypted \) ); do
echo "Working on $f"
compress ${f}
encrypt ${f}.gz
rm -f ${f}.gz
s3put ${f}.gz.encrypted
done;
else
echo "Arguments: "
echo " and ENV var \$masterKey must be set"
exit 255
fi
```
------
#### [ PowerShell ]
```
#Requires -Modules AWSPowerShell, Microsoft.PowerShell.Archive
Param
(
[Parameter(Mandatory)]
[ValidateScript({Test-Path $_})]
[String[]]
$FilePath,
[Parameter()]
[Switch]
$Recurse,
[Parameter(Mandatory=$true)]
[String]
$wrappingKeyID,
[Parameter()]
[String]
$masterKeyProvider = 'aws-kms',
[Parameter(Mandatory)]
[ValidateScript({Test-Path $_})]
[String]
$ZipDirectory,
[Parameter(Mandatory)]
[ValidateScript({Test-Path $_})]
[String]
$EncryptDirectory,
[Parameter()]
[String]
$EncryptionContext,
[Parameter(Mandatory)]
[ValidateScript({Test-Path $_})]
[String]
$MetadataDirectory,
[Parameter(Mandatory)]
[ValidateScript({Test-S3Bucket -BucketName $_})]
[String]
$S3Bucket,
[Parameter()]
[String]
$S3BucketFolder
)
BEGIN {}
PROCESS {
if ($files = dir $FilePath -Recurse:$Recurse)
{
# Step 1: Compress
foreach ($file in $files)
{
$fileName = $file.Name
try
{
Microsoft.PowerShell.Archive\Compress-Archive -Path $file.FullName -DestinationPath $ZipDirectory\$filename.zip
}
catch
{
Write-Error "Zip failed on $file.FullName"
}
# Step 2: Encrypt
if (-not (Test-Path "$ZipDirectory\$filename.zip"))
{
Write-Error "Cannot find zipped file: $ZipDirectory\$filename.zip"
}
else
{
# 2>&1 captures command output
$err = (aws-encryption-cli -e -i "$ZipDirectory\$filename.zip" `
-o $EncryptDirectory `
-m key=$wrappingKeyID provider=$masterKeyProvider `
-c $EncryptionContext `
--metadata-output $MetadataDirectory `
-v) 2>&1
# Check error status
if ($? -eq $false)
{
# Write the error
$err
}
elseif (Test-Path "$EncryptDirectory\$fileName.zip.encrypted")
{
# Step 3: Write to S3 bucket
if ($S3BucketFolder)
{
Write-S3Object -BucketName $S3Bucket -File "$EncryptDirectory\$fileName.zip.encrypted" -Key "$S3BucketFolder/$fileName.zip.encrypted"
}
else
{
Write-S3Object -BucketName $S3Bucket -File "$EncryptDirectory\$fileName.zip.encrypted"
}
}
}
}
}
}
```
------
## Utilisation de la mise en cache des clés de données
Cet exemple utilise la [mise en cache des clés de données](data-key-caching.md) dans une commande qui chiffre un grand nombre de fichiers.
Par défaut, la CLI de AWS chiffrement (et les autres versions de la AWS Encryption SDK) génère une clé de données unique pour chaque fichier crypté. Bien que l'utilisation d'une clé de données unique pour chaque opération est une bonne pratique de chiffrement, la réutilisation limitée des clés de données est acceptable dans certaines situations. Si vous envisagez de mettre en cache des clés de données, contactez un ingénieur sécurité afin de comprendre les exigences de sécurité de votre application et déterminer les seuils de sécurité qui vous conviennent le mieux.
Dans cet exemple, la mise en cache des clés de données accélère l'opération de chiffrement en réduisant la fréquence des demandes auprès du fournisseur de clés principales.
La commande de cet exemple chiffre un grand répertoire avec plusieurs sous-répertoires qui contiennent un total d'environ 800 petits fichiers journaux. La première commande enregistre l'ARN de la AWS KMS key dans une variable `keyARN`. La deuxième commande chiffre tous les fichiers du répertoire d'entrée (de façon récursive) et les écrit dans un répertoire d'archivage. La commande utilise le paramètre `--suffix` pour spécifier le suffixe `.archive`.
Le paramètre `--caching` permet la mise en cache des clés de données. L'attribut **capacity**, qui limite le nombre de clés de données dans le cache, est défini sur 1, car le traitement de fichiers en série n'utilise jamais plus d'une clé de données à la fois. L'attribut **max\$1age**, qui détermine la durée pendant laquelle la clé de données mise en cache peut être utilisée, est défini sur 10 secondes.
L'attribut **max\$1messages\$1encrypted** facultatif est défini sur 10 messages. Par conséquent, une même clé de données n'est jamais utilisée pour chiffrer plus de 10 fichiers. Le fait de limiter le nombre de fichiers chiffrés par chaque clé de données réduit le nombre de fichiers qui seraient touchés dans le cas peu probable où une clé de données serait compromise.
Pour exécuter cette commande sur les fichiers journaux générés par votre système d'exploitation, vous pouvez avoir besoin d'autorisations d'administrateur (`sudo` dans Linux et **Exécuter en tant qu'administrateur** dans Windows).
------
#### [ Bash ]
```
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ aws-encryption-cli --encrypt \
--input /var/log/httpd --recursive \
--output ~/archive --suffix .archive \
--wrapping-keys key=$keyArn \
--encryption-context class=log \
--suppress-metadata \
--caching capacity=1 max_age=10 max_messages_encrypted=10
```
------
#### [ PowerShell ]
```
PS C:\> $keyARN = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> aws-encryption-cli --encrypt `
--input C:\Windows\Logs --recursive `
--output $home\Archive --suffix '.archive' `
--wrapping-keys key=$keyARN `
--encryption-context class=log `
--suppress-metadata `
--caching capacity=1 max_age=10 max_messages_encrypted=10
```
------
Pour tester l'effet de la mise en cache des clés de données, cet exemple utilise l'applet de commande [Measure-Command](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/measure-command) dans. PowerShell Lorsque vous exécutez cet exemple sans mise en cache des clés de données, l'exécution dure environ 25 secondes. Ce processus génère une nouvelle clé de données pour chaque fichier du répertoire.
```
PS C:\> Measure-Command {aws-encryption-cli --encrypt `
--input C:\Windows\Logs --recursive `
--output $home\Archive --suffix '.archive' `
--wrapping-keys key=$keyARN `
--encryption-context class=log `
--suppress-metadata }
Days : 0
Hours : 0
Minutes : 0
Seconds : 25
Milliseconds : 453
Ticks : 254531202
TotalDays : 0.000294596298611111
TotalHours : 0.00707031116666667
TotalMinutes : 0.42421867
TotalSeconds : 25.4531202
TotalMilliseconds : 25453.1202
```
La mise en cache des clés de données accélère le processus, même lorsque vous limitez chaque clé de données à un maximum de 10 fichiers. L'exécution de la commande dure désormais moins de 12 secondes et réduit le nombre d'appels au fournisseur de clés principales à 1/10 de la valeur d'origine.
```
PS C:\> Measure-Command {aws-encryption-cli --encrypt `
--input C:\Windows\Logs --recursive `
--output $home\Archive --suffix '.archive' `
--wrapping-keys key=$keyARN `
--encryption-context class=log `
--suppress-metadata `
--caching capacity=1 max_age=10 max_messages_encrypted=10}
Days : 0
Hours : 0
Minutes : 0
Seconds : 11
Milliseconds : 813
Ticks : 118132640
TotalDays : 0.000136727592592593
TotalHours : 0.00328146222222222
TotalMinutes : 0.196887733333333
TotalSeconds : 11.813264
TotalMilliseconds : 11813.264
```
Si vous supprimez la restriction `max_messages_encrypted`, tous les fichiers sont chiffrés sous la même clé de données. Ce changement augmente le risque de réutilisation des clés de données sans réellement accélérer le processus. Cependant, cela réduit le nombre d'appels au fournisseur de clés principales à 1.
```
PS C:\> Measure-Command {aws-encryption-cli --encrypt `
--input C:\Windows\Logs --recursive `
--output $home\Archive --suffix '.archive' `
--wrapping-keys key=$keyARN `
--encryption-context class=log `
--suppress-metadata `
--caching capacity=1 max_age=10}
Days : 0
Hours : 0
Minutes : 0
Seconds : 10
Milliseconds : 252
Ticks : 102523367
TotalDays : 0.000118661304398148
TotalHours : 0.00284787130555556
TotalMinutes : 0.170872278333333
TotalSeconds : 10.2523367
TotalMilliseconds : 10252.3367
```
# AWS Encryption SDK Syntaxe et référence des paramètres de la CLI
Cette rubrique fournit des diagrammes de syntaxe et de brèves descriptions des paramètres pour vous aider à utiliser l'interface de ligne de commande (CLI) du kit AWS Encryption SDK . Pour obtenir de l'aide sur l'encapsulation des clés et d'autres paramètres, consultez[Comment utiliser la CLI AWS de chiffrement](crypto-cli-how-to.md). Pour obtenir des exemples, consultez [Exemples de CLI AWS de chiffrement](crypto-cli-examples.md). Pour obtenir la documentation complète, consultez [Lisez les documents](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/).
**Topics**
+ [AWS Syntaxe CLI de chiffrement](#crypto-cli-syntax)
+ [AWS Paramètres de ligne de commande de chiffrement de la CLI](#crypto-cli-parameters)
+ [Paramètres avancés](#cli-advanced-parameters)
## AWS Syntaxe CLI de chiffrement
Ces diagrammes de syntaxe de la CLI de AWS chiffrement montrent la syntaxe de chaque tâche que vous effectuez avec la CLI de AWS chiffrement. Ils représentent la syntaxe recommandée dans la version 2.1 de la CLI de AWS chiffrement. *x* et versions ultérieures.
Les nouvelles fonctionnalités de sécurité ont été initialement publiées dans les versions 1.7 de la CLI de AWS chiffrement. *x* et 2.0. *x.* Cependant, AWS Encryption CLI version 1.8. *x* remplace la version 1.7. *x* et CLI de AWS chiffrement 2.1. *x* remplace 2.0. *x.* Pour plus de détails, consultez l'[avis de sécurité](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) correspondant dans le [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)référentiel sur GitHub.
**Note**
Sauf indication contraire dans la description des paramètres, chaque paramètre ou attribut ne peut être utilisé qu'une seule fois dans chaque commande.
Si vous utilisez un attribut qu'un paramètre ne prend pas en charge, la CLI de AWS chiffrement ignore cet attribut non pris en charge sans avertissement ni erreur.
**Obtenir de l'aide**
Pour obtenir la syntaxe complète de la CLI de AWS chiffrement avec les descriptions des paramètres, utilisez `--help` ou`-h`.
```
aws-encryption-cli (--help | -h)
```
**Obtenir la version**
Pour obtenir le numéro de version de votre installation de CLI de AWS chiffrement, utilisez`--version`. Assurez-vous d'inclure la version lorsque vous posez des questions, signalez des problèmes ou partagez des conseils sur l'utilisation de la CLI de AWS chiffrement.
```
aws-encryption-cli --version
```
**Chiffrer des données**
Le diagramme de syntaxe suivant montre les paramètres utilisés par une commande **encrypt**.
```
aws-encryption-cli --encrypt
--input [--recursive] [--decode]
--output