Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Beispiele für dieAWSCLI für Verschlüsselung

Verwenden Sie die folgenden Beispiele, um dieAWSVerschlüsselungs-CLI auf der Plattform, die Sie bevorzugen. Weitere Informationen zum Master-Schlüssel und anderen Parametern finden Sie unter So verwenden Sie die AWS Encryption CLI. Informationen zum schnellen Einstieg finden Sie unter AWS Encryption SDK CLI – Syntax und Parameterreferenz.

Ein Beispiel, das zeigt, wie Sie die Sicherheitsfunktion verwenden, die verschlüsselte Datenschlüssel einschränkt, finden Sie unterBeschränkung verschlüsselter Datenschlüsselaus.

Für ein Beispiel, das zeigt, wie man benutztAWS KMSWeitere regionale Schlüssel finden Sie unterVerwenden Sie mehrere Regionen AWS KMS keysaus.

Verschlüsseln einer Datei

In diesem Beispiel verwenden wir denAWSVerschlüsselungs-CLI zum Verschlüsseln deshello.txt-Datei, die eine Zeichenfolge „Hello World“ enthält.

Wenn Sie einen verschlüsselten Befehl für eine Datei ausführen, wird derAWSVerschlüsselungs-CLI ruft den Inhalt der Datei ab, generiert eine eindeutigeDatenschlüssel, verschlüsselt den Dateiinhalt unter dem Datenschlüssel und schreibt dannVerschlüsselte Nachrichtin eine neue Datei.

Der erste Befehl speichert den Schlüssel-ARN einesAWS KMS keyim$keyArnVariable. Beim Verschlüsseln mit einemAWS KMS keyverwenden, können Sie es anhand einer Schlüssel-ID, eines Schlüssel-ARN, eines Aliasnamens oder Alias-ARN identifizieren. Für Details über die Schlüsselkennungen fürAWS KMS keyfinden Sie unterKey BezeichnerimAWS Key Management ServiceEntwicklerhandbuchaus.

Der zweite Befehl verschlüsselt den Dateiinhalt. Der Befehl verwendet den Parameter --encrypt, um die Operation anzugeben, und den Parameter --input, um die zu verschlüsselnde Datei anzugeben. Der --wrapping-keys-Parameter und das dafür erforderliche Schlüsselattribut weisen den Befehl an, den durch den Schlüssel-ARN dargestellten AWS KMS key zu verwenden.

Der Befehl verwendet den --metadata-output-Parameter, um eine Textdatei für die Metadaten über die Verschlüsselungsoperation anzugeben. Als bewährte Methode verwendet der Befehl den --encryption-context-Parameter, um einen Verschlüsselungskontext anzugeben.

Dieser Befehl verwendet auch die--commitment-policyEinstellungum die Verpflichtungspolitik explizit festzulegen. In Version 1.8.xDieser Parameter ist erforderlich, wenn Sie die--wrapping-keys-Parameter. Ab Version 2.1.x, der--commitment-policyDer Parameter ist zwar optional, wird aber empfohlen.

Der Wert des --output-Parameters, ein Punkt (.), weist den Befehl an, die Ausgabedatei in das aktuelle Verzeichnis zu speichern.

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 .

Wenn der Verschlüsselungsbefehl erfolgreich ausgeführt wird, erfolgt keine Ausgabe. Um festzustellen, ob der Befehl erfolgreich ausgeführt wurde, überprüfen Sie den booleschen Wert in der Variablen $?. Wenn der Befehl erfolgreich war, ist der Wert von$?ist0(Bash) oderTrue(PowerShell) enthalten. Wenn der Befehl fehlschlägt, ist der Wert von$?ist ungleich Null (Bash) oderFalse(PowerShell) enthalten.

Bash

$ echo $?
0

PowerShell

PS C:\> $?
True

Sie können auch einen Verzeichnisauflistungsbefehl ausführen, um zu überprüfen, ob der Verschlüsselungsbefehl eine neue Datei erstellt hat, hello.txt.encrypted. Da der Verschlüsselungsbefehl keinen Dateinamen für die Ausgabe angegeben hat, hat dieAWSVerschlüsselungs-CLI hat die Ausgabe in eine Datei mit dem gleichen Namen wie die Eingabedatei mit der.encryptedSuffix. Um ein anderes Suffix zu verwenden oder das Suffix wegzulassen, verwenden Sie den --suffix-Parameter.

Die Datei hello.txt.encrypted enthält eine verschlüsselte Nachricht, die den Verschlüsselungstext der hello.txt-Datei enthält, eine verschlüsselte Kopie des Datenschlüssels und zusätzlichen Metadaten, einschließlich des Verschlüsselungskontexts.

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

Entschlüsseln einer Datei

In diesem Beispiel verwenden wir denAWSVerschlüsselungs-CLI zum Entschlüsseln des Inhalts desHello.txt.encryptedDie Datei, die im vorangegangenen Beispiel verschlüsselt wurde.

Der Entschlüsselungsbefehl verwendet den Parameter --decrypt, um die Operation anzugeben, und den Parameter --input, um die zu entschlüsselnde Datei anzugeben. Der Wert des --output -Parameters ist ein Punkt, der das aktuelle Verzeichnis darstellt.

Die--wrapping-keysParameterwert mit einemSchlüsselAttribut gibt den Umschlagschlüssel an, der zum Entschlüsseln der verschlüsselten Nachricht verwendet wird. Im Entschlüsseln von Befehlen mitAWS KMS keysmuss der Wert des SchlüsselattributsSchüssel-ARNaus. Die--wrapping-keysDer Parameter muss in einem Entschlüsselungsbefehl angegeben werden. Wenn Sie verwendenAWS KMS keysverwenden können Sie dieSchlüsselAttribut zum AngabeAWS KMS keyszum Entschlüsseln oderEntdeckungAttribut mit einem Wert vontrue(aber nicht beides). Wenn Sie einen Kundenmasterschlüssel-Anbieter verwenden, wird dieSchlüsselundAnbieterAttribute sind erforderlich.

Die--commitment-policyEinstellungist ab Version 2.1 optional.x, aber es wird empfohlen. Wenn Sie es verwenden, wird Ihre Absicht explizit klar, auch wenn Sie den Standardwert angeben,require-encrypt-require-decryptaus.

Der Parameter --encryption-context ist optional im Entschlüsselungsbefehl, auch dann, wenn im Verschlüsselungsbefehl ein Verschlüsselungskontext angegeben ist. In diesem Fall verwendet der Entschlüsselungsbefehl denselben Verschlüsselungskontext wie denjenigen, der im Verschlüsselungsbefehl angegeben wurde. Vor dem Entschlüsseln wird derAWSDie Verschlüsselungs-CLI überprüft, ob der Verschlüsselungskontext in der verschlüsselten Nachricht einenpurpose=testPaar. Wenn dies nicht der Fall ist, schlägt der Entschlüsselungsbefehl fehl.

Der --metadata-output-Parameter gibt eine Datei für Metadaten über die Entschlüsselungsoperation an. Der Wert des --output-Parameters, ein Punkt (.), weist den Befehl an, die Ausgabedatei in das aktuelle Verzeichnis zu schreiben.

Verwenden Sie als bewährte Methode die--max-encrypted-data-keys-Parameter, um zu vermeiden, dass eine fehlerhafte Nachricht mit einer übermäßigen Anzahl verschlüsselter Datenschlüssel entschlüsselt wird. Geben Sie die erwartete Anzahl verschlüsselter Datenschlüssel (einen für jeden in der Verschlüsselung verwendeten Umschlagschlüssel) oder ein angemessenes Maximum (z. B. 5) an. Details hierzu finden Sie unter Beschränkung verschlüsselter Datenschlüssel.

Die--buffergibt Klartext erst zurück, nachdem alle Eingaben verarbeitet wurden, einschließlich der Überprüfung der digitalen Signatur, falls eine vorhanden ist.

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 .

Wenn der Entschlüsselungsbefehl erfolgreich ausgeführt wird, erfolgt keine Ausgabe. Um festzustellen, ob der Befehl erfolgreich ausgeführt wurde, rufen Sie den Wert der Variablen $? ab. Sie können auch einen Verzeichnisauflistungsbefehl ausführen, um zu überprüfen, ob der Verschlüsselungsbefehl eine neue Datei erstellt mit dem Suffix .decrypted erstellt hat. Um den Klartextinhalt anzuzeigen, verwenden Sie einen Befehl, um den Dateiinhalt abzurufen, wie beispielsweise cat oder 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

Alle Dateien in einem Verzeichnis verschlüsseln

In diesem Beispiel verwenden wir denAWSVerschlüsselungs-CLI zum Verschlüsseln des Inhalts aller Dateien in einem Verzeichnis.

Wenn ein Befehl mehrere Dateien betrifft, wird dieAWSDie CLI für die Verschlüsselung verarbeitet jede Datei einzeln. Sie ruft den Dateiinhalt ab, ruft einen eindeutigen Datenschlüssel für die Datei aus dem Master-Schlüssel ab, verschlüsselt den Inhalt der Datei unter dem Datenschlüssel und schreibt die Ergebnisse in eine neue Datei im Ausgabeverzeichnis. Aus diesem Grund können Sie die Ausgabedateien unabhängig voneinander entschlüsseln.

Diese Auflistung des TestDir-Verzeichnisses zeigt die Klartext-Dateien, die wir verschlüsseln möchten.

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

Der erste Befehl speichert dasAmazon Resource Name (ARN, Amazon-Ressourcenname)von einemAWS KMS keyim$keyArnVariable.

Der zweite Befehl verschlüsselt den Inhalt von Dateien im TestDir-Verzeichnis und schreibt die Dateien mit dem verschlüsselten Inhalt in das TestEnc-Verzeichnis. Wenn das TestEnc-Verzeichnis nicht vorhanden ist, schlägt der Befehl fehl. Da der Eingabespeicherort ein Verzeichnis ist, muss der --recursive-Parameter angegeben werden.

Die--wrapping-keysEinstellung, und es ist erforderlichSchlüssel, geben Sie den zu verwendenden Umbruchschlüssel an. Der Verschlüsselungsbefehl umfasst einen Verschlüsselungskontext, dept=IT. Wenn Sie einen Verschlüsselungskontext in einem Befehl angeben, der mehrere Dateien verschlüsselt, wird für alle Dateien derselbe Verschlüsselungskontext verwendet.

Der Befehl hat auch eine--metadata-outputParameter, um das zu sagenAWSVerschlüsselungs-CLI, wohin sie die Metadaten über die Verschlüsselungsoperationen schreiben soll. DieAWSDie Verschlüsselungs-CLI schreibt einen Metadaten-Datensatz für jede Datei, die verschlüsselt wurde.

Die--commitment-policy parameterist ab Version 2.1 optional.x, aber es wird empfohlen. Wenn der Befehl oder das Skript fehlschlägt, weil es einen Chiffretext nicht entschlüsseln kann, hilft Ihnen die Einstellung der expliziten Verpflichtungsrichtlinie möglicherweise, das Problem schnell zu erkennen.

Wenn der Befehl abgeschlossen ist, wird dieAWSEncryption CLI schreibt die verschlüsselten Dateien in dieTestEnc-Verzeichnis, gibt aber keine Ausgabe zurück.

Der letzte Befehl listet die Dateien im Verzeichnis TestEnc auf. Es gibt eine Ausgabedatei des verschlüsselten Inhalts für jede Eingabedatei mit Klartext-Inhalt. Da der Befehl kein alternatives Suffix angegeben hat, hat der Verschlüsselungsbefehl .encrypted an jeden der jede der Eingabedateinamen angefügt.

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

Alle Dateien in einem Verzeichnis entschlüsseln

In diesem Beispiel werden alle Dateien in einem Verzeichnis entschlüsselt. Es beginnt mit den Dateien im Verzeichnis TestEnc, die im vorherigen Beispiel verschlüsselt wurden.

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

Dieser Entschlüsselungsbefehl entschlüsselt alle Dateien imTestEnc-Verzeichnis und schreibt die Klartext-Dateien in dieTestDec-Verzeichnis. Die--wrapping-keysParameterwert mit einemSchlüsselAttribut und einSchüssel-ARNvalue sagtAWSVerschlüsselung CLI welcheAWS KMS keysum die Dateien zu entschlüsseln. Der Befehl verwendet die--interactiveParameter, um das zu sagenAWSVerschlüsselungs-CLI, die Sie auffordert, eine Datei mit demselben Namen zu überschreiben.

Dieser Befehl verwendet auch den Verschlüsselungskontext, die bereitgestellt wurde, als die Dateien verschlüsselt wurden. Beim Entschlüsseln von mehreren Dateien wird dieAWSDie Verschlüsselungs-CLI überprüft den Verschlüsselungskontext jeder Datei. Wenn die Überprüfung des Verschlüsselungskontextes für eine Datei fehlschlägt, wird derAWSDie Verschlüsselungs-CLI lehnt die Datei ab, schreibt eine Warnung, zeichnet den Ausfall in den Metadaten auf und fährt dann mit der Überprüfung der verbleibenden Dateien fort. Wenn das SymbolAWSDie Verschlüsselungs-CLI kann eine Datei aus anderen Gründen nicht entschlüsseln, der gesamte Entschlüsselungsbefehl schlägt sofort fehl.

In diesem Beispiel enthalten die verschlüsselten Nachrichten in allen Eingabedateien das Verschlüsselungskontextelement dept=IT. Wenn Sie jedoch Nachrichten mit unterschiedlichen Verschlüsselungskontexten entschlüsseln, können Sie möglicherweise immer noch einen Teil des Verschlüsselungskontexts überprüfen. Hatten beispielsweise einige Nachrichten den Verschlüsselungskontext dept=finance, andere hatten dept=IT, könnten Sie überprüfen, ob der Verschlüsselungskontext immer einen dept-Namen enthält, ohne den Wert anzugeben. Wenn Sie spezifischer vorgehen möchten, können Sie die Dateien in separaten Befehlen entschlüsseln.

Die Entschlüsselungsbefehl gibt keine Ausgabe zurück, aber Sie können einen Verzeichnislistenbefehl verwenden, um zu prüfen, ob der Befehl neue Dateien mit dem Suffix .decrypted erstellt hat. Um den Klartextinhalt anzuzeigen, verwenden Sie einen Befehl, um den Dateiinhalt abzurufen.

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

Verschlüsseln und Entschlüsseln in der Befehlszeile

Diese Beispiele zeigen Ihnen, wie Sie Eingaben an Befehle übergeben (stdin) und Ausgaben in die Befehlszeile schreiben (stdout). Sie erklären, wie stdin und stdout in einem Befehl dargestellt werden, und wie die eingebauten Base64-Codierungstools verwendet werden, um zu verhindern, dass die Shell Nicht-ASCII-Zeichen falsch interpretiert.

Dieses Beispiel übergibt eine Klartext-Zeichenfolge an einen Verschlüsselungsbefehl und speichert die verschlüsselte Nachricht in einer Variablen. Dann übergibt es die verschlüsselte Nachricht in der Variablen an einen Entschlüsselungsbefehl, der seine Ausgabe in die Pipeline schreibt (stdout).

Das Beispiel besteht aus drei Befehlen:

Sie können die Ver- und Entschlüsselungsoperationen auch in einem einzigen Befehl ohne die dazwischenliegende Variable durchführen.

Wie im vorherigen Beispiel haben die Parameter --input und --output einen --Wert, und der Befehl verwendet den --encode-Parameter, um die Ausgabe zu codieren, und den --decode Parameter, um die Eingabe zu decodieren.

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

Verwenden mehrerer Hauptschlüssel

Dieses Beispiel zeigt, wie mehrere Master-Schlüssel beim Ver- und Entschlüsseln von Daten imAWSCLI für Verschlüsselung.

Wenn Sie mehrere Master-Schlüssel verwenden, um Daten zu verschlüsseln, kann einer der Master-Schlüssel verwendet werden, um die Daten zu entschlüsseln. Diese Strategie stellt sicher, dass Sie die Daten entschlüsseln können, selbst wenn einer der Master-Schlüssel nicht verfügbar ist. Wenn Sie die verschlüsselten Daten in mehreren speichernAWS-RegionenMit dieser Strategie können Sie einen Master-Schlüssel in derselben Region verwenden, um die Daten zu entschlüsseln.

Wenn Sie mit mehreren Master-Schlüsseln verschlüsseln, spielt der erste Master-Schlüssel eine spezielle Rolle. Er generiert den Datenschlüssel, der zum Verschlüsseln der Daten verwendet wird. Die verbleibenden Master-Schlüssel verschlüsseln den Klartext-Datenschlüssel. Die resultierende verschlüsselte Nachricht enthält die verschlüsselten Daten und eine Sammlung von verschlüsselten Datenschlüsseln, einen für jeden Master-Schlüssel. Obwohl der erste Master-Schlüssel den Datenschlüssel generiert hat, kann jeder der Master-Schlüssel einen der Datenschlüssel entschlüsseln, der verwendet werden kann, um die Daten zu entschlüsseln.

Verschlüsseln mit drei Hauptschlüsseln

Dieser Beispielbefehl verwendet drei Wrapping Keys, um dieFinance.logDatei, jeweils eine von dreiAWS-Regionenaus.

Er schreibt die verschlüsselte Nachricht in das Verzeichnis Archive. Der Befehl verwendet den --suffix -Parameter ohne Wert, um das Suffix zu unterdrücken, sodass die Eingabe- und Ausgabedateinamen gleich sind.

Der Befehl verwendet den --wrapping-keys-Parameter mit drei Schlüsselattributen. Sie können auch mehrere --wrapping-keys-Parameter im selben Befehl verwenden.

Um die Protokolldatei zu verschlüsseln, wird dieAWSEncryption CLI fragt den ersten Umschlagschlüssel in der Liste,$key1, um den Datenschlüssel zu generieren, der zum Verschlüsseln der Daten verwendet wird. Anschließend verwendet sie jeden der anderen Umschlagschlüssel zum Verschlüsseln einer Klartext-Kopie desselben Datenschlüssels. Die verschlüsselte Nachricht in der Ausgabedatei enthält alle drei verschlüsselten Datenschlüssel.

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

Dieser Befehl entschlüsselt die verschlüsselte Kopie der Datei Finance.log und schreibt sie in eine Finance.log.clear-Datei im Verzeichnis Finance. Um Daten zu entschlüsseln, die unter drei verschlüsselt sindAWS KMS keyskönnen Sie dieselben drei angebenAWS KMS keysoder irgendeine Teilmenge von ihnen. Dieses Beispiel gibt nur einen derAWS KMS keysaus.

Um das zu sagenAWSVerschlüsselung CLI welcheAWS KMS keysUm Ihre Daten zu entschlüsseln, verwenden Sie dieSchlüsselAttribut der--wrapping-keys-Parameter. Beim Entschlüsseln mitAWS KMS keys, der Wert desSchlüssel-Attribut muss einSchüssel-ARNaus.

Sie benötigen die Berechtigung zum Aufrufen derAPI entschlüsselnauf derAWS KMS keysSie geben an. Weitere Informationen finden Sie unter-Authentifizierung und -Zugriffskontrolle fürAWS KMSaus.

Als bewährte Methode verwenden diese Beispiele die--max-encrypted-data-keys-Parameter, um zu vermeiden, dass eine fehlerhafte Nachricht mit einer übermäßigen Anzahl verschlüsselter Datenschlüssel entschlüsselt wird. Obwohl in diesem Beispiel nur ein Umschlagschlüssel für die Entschlüsselung verwendet wird, enthält die verschlüsselte Nachricht drei (3) verschlüsselte Datenschlüssel; einen für jeden der drei beim Verschlüsseln verwendeten Wrapping Keys. Geben Sie die erwartete Anzahl verschlüsselter Datenschlüssel oder einen angemessenen Maximalwert an, z. B. Wenn Sie einen Maximalwert von weniger als 3 angeben, schlägt der Befehl fehl. Details hierzu finden Sie unter Beschränkung verschlüsselter Datenschlüssel.

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

Verschlüsseln und Entschlüsseln in Skripts

Dieses Beispiel veranschaulicht, wie Sie die verwendenAWSVerschlüsselungs-CLI in Skripten. Sie können Skripte schreiben, die nur Daten verschlüsseln und entschlüsseln, oder Skripts, die als Teil eines Datenverwaltungsprozesses verschlüsseln oder entschlüsseln.

In diesem Beispiel ruft das Skript eine Sammlung von Protokolldateien ab, komprimiert sie, verschlüsselt sie und kopiert die verschlüsselten Dateien in einen Amazon S3 S3-Bucket. Dieses Skript verarbeitet jede Datei einzeln, sodass Sie sie unabhängig voneinander entschlüsseln und erweitern können.

Wenn Sie Dateien komprimieren und verschlüsseln, stellen Sie sicher, dass Sie sie komprimieren, bevor Sie sie verschlüsseln. Ordnungsgemäß verschlüsselte Daten können nicht komprimiert werden.

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

Verwenden von Datenschlüssel-Caching

Dieses Beispiel verwendet das Datenschlüssel-Caching in einem Befehl, der eine große Anzahl von Dateien verschlüsselt.

Standardmäßig ist derAWSEncryption CLI (und andere Versionen desAWS Encryption SDK) generiert einen eindeutigen Datenschlüssel für jede Datei, die sie verschlüsselt. Obwohl die Verwendung eines eindeutigen Datenschlüssels für jede Operation ist eine bewährte Methode in der Kryptografie ist, ist eine begrenzte Wiederverwendung von Datenschlüsseln in einigen Situationen akzeptabel. Falls Sie ein Datenschlüssel-Caching in Betracht ziehen, beraten Sie sich mit einem Sicherheitstechniker,um die Sicherheitsanforderungen Ihrer Anwendung zu verstehen und die für Sie geeigneten Sicherheitsbarrieren zu bestimmen.

In diesem Beispiel beschleunigt das Datenschlüssel-Caching die Verschlüsselungsoperation, indem sie die Frequenz der Anfragen an den Masterschlüssel-Anbieter reduziert.

Der Befehl in diesem Beispiel verschlüsselt ein großes Verzeichnis mit mehreren Unterverzeichnissen, die insgesamt ungefähr 800 kleine Protokolldateien enthalten. Der erste Befehl speichert den ARN des AWS KMS key in einer keyARN-Variablen. Der zweite Befehl verschlüsselt alle Dateien im Eingabeverzeichnis (rekursiv) und schreibt sie in ein Archiv-Verzeichnis. Der Befehl verwendet den --suffix -Parameter, um das .archive-Suffix anzugeben.

Der --caching-Parameter aktiviert das Datenschlüssel-Caching. Die Attribut capacity, das die Anzahl der Datenschlüssel im Cache begrenzt, wird auf 1 gesetzt, da die serielle Dateiverarbeitung nie mehr als einen Datenschlüssel gleichzeitig verwendet. Das Attribut max_age, mit dem festgelegt wird, wie lange der Datenschlüssel im Cache verwendet werden kann, ist auf 10 Sekunden eingestellt.

Das optionale Attribut max_messages_encrypted ist auf 10 Nachrichten festgelegt, sodass eine einzelner Datenschlüssel nie verwendet werden kann, um mehr als 10 Dateien zu verschlüsseln. Die Begrenzung der Anzahl der von einem Datenschlüssel verschlüsselten Dateien reduziert die Anzahl der Dateien, die in dem unwahrscheinlichen Fall betroffen wären, wenn ein Datenschlüssel kompromittiert wird.

Um diesen Befehl für von Ihrem Betriebssystem generierte Protokolldateien auszuführen, müssen Sie möglicherweise Administratorberechtigungen besitzen (sudo in Linux; Als Administrator ausführen in 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 

Um die Wirkung des Datenschlüssel-Cachings zu testen, verwendet dieses Beispiel dieMessen-Befehl-Cmdlet inPowerShellaus. Wenn Sie dieses Beispiel ohne Datenschlüssel-Caching ausführen, dauert seine Ausführung etwa 25 Sekunden. Dieser Prozess generiert einen neuen Datenschlüssel für jede Datei im Verzeichnis.

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

Das Datenschlüssel-Caching beschleunigt das Verfahren, auch wenn Sie die einzelnen Datenschlüssel auf maximal 10 Dateien begrenzen. Der Befehl benötigt jetzt weniger als 12 Sekunden und reduziert die Anzahl der Aufrufe des Masterschlüssel-Anbieter auf ein Zehntel des ursprünglichen Werts.

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

Wenn Sie die max_messages_encrypted-Einschränkung weglassen, werden alle Dateien unter demselben Datenschlüssel verschlüsselt. Diese Änderung erhöht das Risiko einer Wiederverwendung von Datenschlüsseln, ohne den Prozess sehr wesentlich schneller zu machen. Sie reduziert jedoch die Anzahl der Aufrufe des Masterschlüssel-Anbieters auf 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