Exemples de l'interface de ligne de commande (CLI) du kit Kit SDK de chiffrement AWS - Kit SDK de chiffrement AWS

Si nous fournissons une traduction de la version anglaise du guide, la version anglaise du guide aura préséance en cas de contradiction. La traduction sera une traduction automatique.

Exemples de l'interface de ligne de commande (CLI) du kit Kit SDK de chiffrement AWS

Utilisez les exemples suivants pour tester l'Kit CLI de chiffrement AWS sur la plateforme de votre choix. Pour obtenir de l'aide concernant les clés principales et d'autres paramètres, veuillez consulter Utilisation de l'interface de ligne de commande du kit Kit SDK de chiffrement AWS. 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 Kit SDK de chiffrement AWS.

Chiffrement d'un fichier

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

Lorsque vous exécutez une commande de chiffrement sur un fichier, l'Kit CLI de chiffrement AWS récupère le contenu du fichier, génère une clé de données unique, chiffre le contenu du fichier sous la clé de données, puis écrit le message chiffré dans un nouveau fichier.

La première commande enregistre l'Amazon Resource Name (ARN) d'une clé principale client (CMK) AWS KMS dans la variable $cmkArn. Pour de plus amples informations sur les identificateurs de clé pour une clé principale client AWS KMS, veuillez consulter Identificateurs de clé dans le AWS Key Management Service Developer Guide.

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 --master-keys et son attribut key obligatoire indiquent à la commande d'utiliser la clé principale 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.

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. $ cmkArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab $ aws-encryption-cli --encrypt \ --input hello.txt \ --master-keys key=$cmkArn \ --metadata-output ~/metadata \ --encryption-context purpose=test \ --output .
PowerShell
# To run this example, replace the fictitious key ARN with a valid value. PS C:\> $CmkArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab' PS C:\> aws-encryption-cli --encrypt ` --input Hello.txt ` --master-keys key=$CmkArn ` --metadata-output $home\Metadata.txt ` --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 voir que la commande de chiffrement a créé un nouveau fichier, hello.txt.encrypted. Comme la commande de chiffrement n’a pas spécifié de nom de fichier pour la sortie, le champ Kit CLI de chiffrement AWS 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é 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 l'Kit CLI de chiffrement AWS pour déchiffrer le contenu du fichier Hello.txt.encrypted 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.

Cette commande ne comporte pas le paramètre --master-keys. Un paramètre --master-keys est obligatoire dans les commandes de déchiffrement uniquement lorsque vous utilisez un fournisseur de clés principales personnalisé. Si vous utilisez une CMK AWS KMS vous ne pouvez pas spécifier de clé principale, car AWS KMS l'obtient du message chiffré.

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 le déchiffrement, l'Kit CLI de chiffrement AWS vérifie que le contexte de chiffrement du message chiffré comprend 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.

Bash
$ aws-encryption-cli --decrypt \ --input hello.txt.encrypted \ --encryption-context purpose=test \ --metadata-output ~/metadata \ --output .
PowerShell
PS C:\> aws-encryption-cli --decrypt ` --input Hello.txt.encrypted ` --encryption-context purpose=test ` --metadata-output $home\Metadata.txt ` --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 l'Kit CLI de chiffrement AWS pour chiffrer le contenu de tous les fichiers d'un répertoire.

Lorsqu'une commande affecte plusieurs fichiers, l'Kit CLI de chiffrement AWS 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'Amazon Resource Name (ARN) d'une clé principale client (CMK) AWS KMS dans la variable $cmkArn.

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 paramètre --master-keys et son attribut key requis spécifient la clé principale. 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é pour tous les fichiers.

La commande contient également un paramètre --metadata-output pour indiquer à l'Kit CLI de chiffrement AWS où écrire les métadonnées relatives aux opérations de chiffrement. L'Kit CLI de chiffrement AWS écrit un enregistrement de métadonnées pour chaque fichier qui a été chiffré.

Lorsque la commande se termine, l'Kit CLI de chiffrement AWS écrit les fichiers chiffrés dans le répertoire TestEnc, mais ne renvoie pas de 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 clé principale identifier. $ cmkArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab $ aws-encryption-cli --encrypt \ --input testdir --recursive\ --master-keys key=$cmkArn \ --encryption-context dept=IT \ --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 clé principale identifier. PS C:\> $cmkArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab' PS C:\> aws-encryption-cli --encrypt ` --input .\TestDir --recursive ` --master-keys key=$cmkArn ` --encryption-context dept=IT ` --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 répertoire TestEnc et écrit les fichiers en texte brut dans le répertoire TestDec. Étant donné que les fichiers chiffrés ont été chiffrés sous une CMK AWS KMS, la commande ne comporte pas de paramètre --master-keys. La commande utilise le paramètre --interactive pour indiquer à l'Kit CLI de chiffrement AWS de vous adresser une invite avant de remplacer un fichier par un autre du 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, l'Kit CLI de chiffrement AWS vérifie le contexte de chiffrement de chaque fichier. Si la vérification du contexte de chiffrement sur un fichier échoue, l'Kit CLI de chiffrement AWS rejette le fichier, écrit un avertissement, enregistre la défaillance dans les métadonnées, puis continue à vérifier les fichiers restants. Si, pour toute autre raison, l'Kit CLI de chiffrement AWS ne parvient pas à déchiffrer un fichier, 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
$ aws-encryption-cli --decrypt --input testenc --recursive \ --encryption-context dept=IT \ --metadata-output ~/metadata \ --output testdec --interactive $ ls testdec cool-new-thing.py.encrypted.decrypted hello.txt.encrypted.decrypted employees.csv.encrypted.decrypted
PowerShell
PS C:\> aws-encryption-cli --decrypt ` --input C:\TestEnc --recursive ` --encryption-context dept=IT ` --metadata-output $home\Metadata.txt ` --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'Amazon Resource Name (ARN) d'une clé principale client (CMK) AWS KMS dans la variable $cmkArn.

    Bash
    $ cmkArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
    PowerShell
    PS C:\> $cmkArn = '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 paramètres --input et --output sont obligatoires dans toutes les commandes de l'Kit CLI de chiffrement AWS. 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 \ --master-keys key=$cmkArn )
    PowerShell
    PS C:\> $encrypted = 'Hello World' | aws-encryption-cli --encrypt -S ` --input - --output - --encode ` --master-keys key=$cmkArn

     

  • 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.)

    É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 --input - --output - --decode -S Hello World
    PowerShell
    PS C:\> $encrypted | aws-encryption-cli --decrypt --input - --output - --decode -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
$ cmkArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab $ echo 'Hello World' | aws-encryption-cli --encrypt --master-keys key=$cmkArn --input - --output - --encode -S | aws-encryption-cli --decrypt --input - --output - --decode -S Hello World
PowerShell
PS C:\> $cmkArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab' PS C:\> 'Hello World' | aws-encryption-cli --encrypt --master-keys key=$cmkArn --input - --output - --encode -S | aws-encryption-cli --decrypt --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 l'Kit CLI de chiffrement AWS.

Lorsque vous utilisez plusieurs clés principales pour chiffrer des données, n'importe quelle clés principales 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 plusieurs ré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 chiffrez avec plusieurs clés principales, la première clé principale joue un rôle spécial. 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é qui en résulte 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 principales pour chiffrer le fichier Finance.log, une pour chacune des 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 --master-keys avec trois attributs key. Vous pouvez également utiliser plusieurs paramètres --master-keys dans la même commande.

Pour chiffrer le fichier journal, l'Kit CLI de chiffrement AWS demande à la première clé principale de la liste, $cmk1, de générer la clé de données qu'elle utilise pour chiffrer les données. Ensuite, elle utilise chacune des autres clés principales pour chiffrer la copie en texte brut de la clé de données. Le message chiffré dans le fichier de sortie inclut les trois des clés de données chiffrées.

Bash
$ cmk1=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab $ cmk2=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef $ cmk3=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 \ --master-keys key=$cmk1 key=$cmk2 key=$cmk3
PowerShell
PS C:\> $cmk1 = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab' PS C:\> $cmk2 = 'arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef' PS C:\> $cmk3 = '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 ` --master-keys key=$cmk1 key=$cmk2 key=$cmk3

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.

Lorsque vous déchiffrez des données qui ont été chiffrées sous des CMKs AWS KMS, vous ne pouvez pas indiquer à AWS KMS d'utiliser une CMK spécifique pour déchiffrer les données. L'attribut key du paramètre --master-keys n'est pas valide dans une commande de déchiffrement avec le fournisseur aws-kms. L'Kit CLI de chiffrement AWS peut utiliser n'importe quelle CMKs qui a été utilisée pour chiffrer les données, à condition que les informations d'identification AWS que vous utilisez sont autorisées à appeler l'API Decrypt sur la clé principale. Pour plus d'informations, consultez Authentification et contrôle d'accès pour AWS KMS.

Bash
$ aws-encryption-cli --decrypt --input /archive/finance.log \ --output /finance --suffix '.clear' \ --metadata-output ~/metadata \ --encryption-context class=log
PowerShell
PS C:\> aws-encryption-cli --decrypt ` --input D:\Archive\Finance.log ` --output D:\Finance --suffix '.clear' ` --metadata-output .\Metadata\Metadata.txt ` --encryption-context class=log

Chiffrement et déchiffrement dans les scripts

Cet exemple montre comment utiliser l'Kit CLI de chiffrement AWS dans des 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 un ensemble de fichiers journaux qu'il compresse et 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.

PowerShell
#Requires -Modules AWSPowerShell, Microsoft.PowerShell.Archive Param ( [Parameter(Mandatory)] [ValidateScript({Test-Path $_})] [String[]] $FilePath, [Parameter()] [Switch] $Recurse, [Parameter(Mandatory=$true)] [String] $masterKeyID, [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=$masterKeyID 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" } } } } } }
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

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, l'Kit CLI de chiffrement AWS (et d'autres versions du kit Kit SDK de chiffrement AWS) génère une clé de données unique pour chaque fichier qu'elle 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 CMK dans une variable cmkARN. 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
$ cmkArn=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 \ --master-keys key=$cmkArn \ --encryption-context class=log \ --suppress-metadata \ --caching capacity=1 max_age=10 max_messages_encrypted=10
PowerShell
PS C:\> $cmkArn = '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' ` --master-keys key=$cmkARN ` --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 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' ` --master-keys key=$cmkARN ` --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 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' ` --master-keys key=$cmkARN ` --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, il 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' ` --master-keys key=$cmkARN ` --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