Exemples deAWSCLI de chiffrement - AWS Encryption SDK
Chiffrement d'un fichierDéchiffrement d'un fichierChiffrement de tous les fichiers d'un répertoireDéchiffrement de tous les fichiers d'un répertoireChiffrement et déchiffrement sur la ligne de commandeUtilisation de plusieurs clés principalesChiffrement et déchiffrement dans les scriptsUtilisation de la mise en cache des clés de données

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 deAWSCLI de chiffrement

Utilisez les exemples suivants pour tester leAWSL'interface de chiffrement sur la plateforme de votre choix. Pour obtenir de l'aide concernant les clés principales et d'autres paramètres, consultez Comment utiliser l'interface de ligne de commande AWS de chiffrement. Pour accéder à une référence rapide, consultez Référence des paramètres et de la syntaxe de l'interface de ligne de commande du kit AWS Encryption SDK.

Note

Les exemples suivants utilisent la syntaxe deAWSVersion 2.1 de ligne de commande de chiffrement.h/24, j/7.

Les nouvelles fonctionnalités de sécurité ont été initialement publiées dansAWSVersion de ligne de commande de chiffrement 1.7.h/24, j/7et 2.0.h/24, j/7. Toutefois,AWSVersion de ligne de commande de chiffrement version 1.8.h/24, j/7remplace la version 1.7.h/24, j/7etAWSChiffrement CLI 2.1.h/24, j/7remplace 2,0.h/24, j/7. Pour en savoir plus, consultez leconseil de sécuritédans leaws-encryption-sdk-clirepository surGitHub.

Pour obtenir un exemple montrant comment utiliser la fonctionnalité de sécurité qui limite les clés de données chiffrées, voirLimiter les clés de données chiffrées.

Pour un exemple montrant comment utiliserAWS KMSClés multi-régions, voirUtilisation de plusieurs régions AWS KMS keys.

Chiffrement d'un fichier

Cet exemple utilise leAWSCryptage CLI pour chiffrer le contenu de l'hello.txt, qui contient une chaîne « Hello World ».

Lorsque vous exécutez une commande de chiffrement sur un fichier, leAWSL'interface de chiffrement récupère le contenu du fichier, génère unclé de données, chiffre le contenu du fichier sous la clé de données, puis écrit lemessage chiffrévers un nouveau fichier.

La première commande enregistre l'ARN clé d'unAWS KMS keydans le$keyArnVariable. Lors du chiffrement avec unAWS 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'unAWS KMS key, voirIdentificateurs clésdans leAWS Key Management ServiceManuel du 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 paramètre --wrapping-keys et son attribut key obligatoire indiquent à la commande d'utiliser la AWS KMS key représentée par l'ARN de 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.

Cette commande utilise également la commande--commitment-policyparamètrepour définir explicitement la politique d'engagement. Dans la version 1.8.h/24, j/7, ce paramètre est obligatoire lorsque vous utilisez l'--wrapping-keys  Paramètre . À partir de la version 2.1.h/24, j/7, le--commitment-policyLe 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$?est0(Bash) ouTrue(PowerShell). Lorsque la commande échoue, la valeur de$?est différent de zéro (Bash) ouFalse(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. Étant donné que la commande de chiffrement n'a pas spécifié de nom de fichier pour la sortie, l'AWSL'interface de chiffrement a écrit la sortie dans un fichier nommé de la même façon que le fichier d'entrée, auquel un.encryptedsuffixe. Pour utiliser un autre suffixe ou supprimer le suffixe, utilisez le paramètre --suffix.

Le fichier hello.txt.encrypted contient un message chiffré 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 leAWSEncryption CLI pour déchiffrer le contenu duHello.txt.encryptedfichier qui a été 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-keysParamètre avec uncléspécifie la clé d'encapsulation utilisée pour déchiffrer le message chiffré. Dans les commandes de déchiffrement avecAWS KMS keys, la valeur de l'attribut clé doit être une valeurARN de clé. Le--wrapping-keysest obligatoire dans une commande de déchiffrement. Si vous utilisezAWS KMS keys, vous pouvez utiliser lecléAttribut à spécifierAWS KMS keyspour le déchiffrement ou ledécouverteavec une valeur detrue(mais pas les deux). Si vous utilisez un fournisseur de clés principales personnalisé, l'cléetfournisseurLes attributs sont obligatoires.

Le--commitment-policyparamètreest facultatif à partir de la version 2.1.h/24, j/7, mais il est recommandé. Son utilisation rend explicitement votre intention claire, 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 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 de déchiffrer, leAWSL'interface de ligne de commande de chiffrement vérifie que le contexte de chiffrement du message chiffré comprend unepurpose=testpaire. 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.

À titre de bonne pratique, utilisez le--max-encrypted-data-keyspour é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 dans le chiffrement) ou un maximum raisonnable (par exemple 5). Pour plus d'informations, consultez Limiter les clés de données chiffrées.

Le--bufferrenvoie le texte brut uniquement après le traitement de toutes les entrées, y compris la vérification de la signature numérique si elle est présente.

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.

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 leAWSEncryption CLI pour chiffrer le contenu de tous les fichiers d'un répertoire.

Lorsqu'une commande affecte plusieurs fichiers, l'AWSL'interface de ligne de commande de chiffrement traite chaque fichier individuellement. Elle récupère le contenu du fichier, récupère une clé de données 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 l'optionAmazon Resource Name (ARN)d'unAWS KMS keydans le$keyArnVariable.

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-keysparamètre, et ce qui est requisclé, spécifiez la clé d'encapsulation à utiliser. La commande de chiffrement inclut un contexte de chiffrement, 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 dispose également d'un--metadata-outputpour indiquer le paramètreAWSEncryption CLI où écrire les métadonnées relatives aux opérations de chiffrement. LeAWSL'interface de ligne de chiffrement écrit un enregistrement de métadonnées pour chaque fichier qui a été chiffré.

Le--commitment-policy parameterest facultative à partir de la version 2.1.h/24, j/7, mais il est recommandé. Si la commande ou le script échoue parce qu'il ne peut pas déchiffrer un texte chiffré, le paramètre de stratégie d'engagement explicite peut vous aider à détecter rapidement le problème.

Lorsque la commande aboutit, leAWSEncryption CLI écrit les fichiers chiffrés dans leTestEnc, 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 duTestEncet écrit les fichiers en texte brut dans le répertoireTestDecrépertoire. Le--wrapping-keysParamètre avec uncléAttribut etARN de cléindique la valeurAWSCLI de chiffrement quiAWS KMS keysà utiliser pour déchiffrer les fichiers. La commande utilise le--interactivepour indiquer le paramètreAWSEncryption CLI pour vous adresser une invite avant de remplacer un fichier nommé.

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, l'AWSL'interface de ligne de chiffrement vérifie le contexte de chiffrement de chaque fichier. Si la vérification du contexte de chiffrement d'un fichier échoue, leAWSL'interface de chiffrement rejette le fichier, écrit un avertissement, enregistre l'échec dans les métadonnées, puis continue à vérifier les fichiers restants. Si l'icôneAWSL'interface de chiffrement ne parvient pas à déchiffrer un fichier pour toute 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'optionARN de cléd'unAWS KMS keydans le$keyArnVariable.

    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.

    Le--inputet--outputLes paramètres sont obligatoires dans tous lesAWSCommandes de commande de 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 ledécouverteAttribut du--wrapping-keyspour autoriser le paramètreAWSCLI de chiffrement pour utiliser n'importe quelAWS KMS keypour déchiffrer les données. Il ne spécifie pas depolitique d'engagement, il utilise donc la valeur par défaut de la version 2.1.h/24, j/7et plus tard,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 leAWSCLI de chiffrement.

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 dans plusieursRégions AWS, 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é 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 avec trois clés principales

Cet exemple de commande utilise trois clés d'encapsulation pour chiffrer leFinance.log, un dossier sur chacun des troisRé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, leAWSLa CLI de chiffrement demande la première clé d'encapsulation de la liste,$key1, pour générer la clé de données qu'elle utilise pour chiffrer les données. Ensuite, elle utilise 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 sous troisAWS KMS keys, vous pouvez spécifier les trois mêmesAWS KMS keysou n'importe quel sous-ensemble d'entre eux. Cet exemple spécifie uniquement l'une des options suivantes :AWS KMS keys.

Pour dire à laAWSCLI de chiffrement quiAWS KMS keyspour déchiffrer vos données, utilisez lecléAttribut du--wrapping-keys  Paramètre . Lors du déchiffrement avecAWS KMS keys, la valeur duclédoit être un attributARN de clé.

Vous devez être autorisé à appeler leAPI de déchiffrementsur leAWS KMS keysque vous spécifiez. Pour de plus amples informations, veuillez consulterAuthentification et contrôle d'accès pourAWS KMS.

À titre de bonne pratique, cet exemple utilise le--max-encrypted-data-keyspour é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 utilise 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, par exemple 5. Si vous spécifiez une valeur maximale inférieure à 3, la commande échoue. Pour plus d'informations, consultez Limiter les clés de données chiffrées.

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 vous montre comment utiliser l'AWSCLI de 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 récupère une collection de fichiers journaux, les compresse, 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: <Directory> <encryption context> <s3://bucketname> <s3 folder>"
    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 dans une commande qui chiffre un grand nombre de fichiers.

Par défaut, leAWSCLI de chiffrement (et autres versions de laAWS Encryption SDK) génère une clé de données unique pour chaque fichier qu'il chiffre. 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_age, 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_messages_encrypted 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'Commande mesureApplet de commande dansPowerShell. 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