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 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