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