

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.

# Kit SDK de chiffrement AWS pour JavaScript
<a name="javascript"></a>

 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
<a name="javascript-compatibility"></a>

 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é
<a name="javascript-language-compatibility"></a>

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
<a name="javascript-browser-compatibility"></a>

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
<a name="javascript-installation"></a>

 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
<a name="javascript-modules"></a>

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
<a name="jsn-modules-node"></a>

[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
<a name="jsn-modules-browser"></a>

[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
<a name="jsn-modules-all"></a>

[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
<a name="js-examples"></a>

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
<a name="javascript-example-encrypt"></a>

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
<a name="javascript-example-decrypt"></a>

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.