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.

Vertrauliche Daten durch Verschlüsselung auf Feldebene schützen

Mit Amazon CloudFront können Sie sichere end-to-end Verbindungen zu Originalservern erzwingen, indem SieHTTPS. Die Verschlüsselung auf Feldebene fügt zusammen mit HTTPS eine zusätzliche Sicherheitsebene hinzu, mit der Sie bestimmte Daten während der gesamten Systemverarbeitung so schützen können, dass nur bestimmte Anwendungen sie sehen können.

Die Verschlüsselung auf Feldebene ermöglicht es Ihren Benutzern, vertrauliche Informationen in sicherer Weise auf Ihre Webserver hochzuladen. Die vertraulichen Informationen, die von Ihren Benutzern bereitgestellt werden, werden am Rand, in der Nähe des Benutzers, verschlüsselt und bleiben über den gesamten Anwendungs-Stack hinweg verschlüsselt. Diese Verschlüsselung stellt sicher, dass nur Anwendungen, die die Daten benötigen - und über die Anmeldeinformationen zum Entschlüsseln verfügen - dies tun können.

Um die Verschlüsselung auf Feldebene zu verwenden, geben Sie bei der Konfiguration Ihrer CloudFront Distribution die Felder in POST Anfragen an, die Sie verschlüsseln möchten, sowie den öffentlichen Schlüssel, mit dem sie verschlüsselt werden sollen. Sie können bis zu 10 Datenfelder in einer Anfrage verschlüsseln. (Sie können nicht alle Daten in einer Anfrage mit Verschlüsselung auf Feldebene verschlüsseln; Sie müssen einzelne Felder angeben, die verschlüsselt werden sollen.)

Wenn die HTTPS Anfrage mit Verschlüsselung auf Feldebene an den Ursprung weitergeleitet wird und die Anfrage über Ihre ursprüngliche Anwendung oder Ihr Subsystem weitergeleitet wird, sind die sensiblen Daten weiterhin verschlüsselt, wodurch das Risiko einer Datenschutzverletzung oder eines versehentlichen Datenverlusts der sensiblen Daten verringert wird. Komponenten, die aus geschäftlichen Gründen Zugriff auf die sensiblen Daten benötigen, wie z. B. ein Zahlungssystem für eine Kreditnummer, können mit dem entsprechenden privaten Schlüssel entschlüsseln und auf die Daten zugreifen.

CloudFront Bei der Verschlüsselung auf Feldebene wird eine asymmetrische Verschlüsselung verwendet, die auch als Verschlüsselung mit öffentlichen Schlüsseln bezeichnet wird. Sie geben einen öffentlichen Schlüssel an CloudFront, und alle vertraulichen Daten, die Sie angeben, werden automatisch verschlüsselt. Der Schlüssel, den Sie angeben, CloudFront kann nicht zum Entschlüsseln der verschlüsselten Werte verwendet werden. Das kann nur mit Ihrem privaten Schlüssel geschehen.

Überblick über die Verschlüsselung auf Feldebene

Die folgenden Schritte geben einen Überblick über die Einrichtung der Verschlüsselung auf Feldebene. Spezifische Schritte finden Sie unter Richten Sie die Verschlüsselung auf Feldebene ein.

Richten Sie die Verschlüsselung auf Feldebene ein

Führen Sie die folgenden Schritte aus, um mit der Verschlüsselung auf Feldebene zu beginnen. Weitere Informationen zu Kontingenten (früher als Limits bezeichnet) für die Verschlüsselung auf Feldebene finden Sie unter Kontingente.

Schritt 1: Erstellen Sie ein RSA key pair

Zu Beginn müssen Sie ein RSA key pair erstellen, das einen öffentlichen Schlüssel und einen privaten Schlüssel umfasst. Der öffentliche Schlüssel ermöglicht CloudFront die Verschlüsselung von Daten, und der private Schlüssel ermöglicht es Komponenten an Ihrem Ursprung, die verschlüsselten Felder zu entschlüsseln. Sie können Open SSL oder ein anderes Tool verwenden, um ein key pair zu erstellen. Die Schlüsselgröße muss 2048 Bit betragen.

Wenn Sie beispielsweise Open verwenden, können Sie den folgenden Befehl verwendenSSL, um ein key pair mit einer Länge von 2048 Bit zu generieren und es in der Datei private_key.pem zu speichern:

openssl genrsa -out private_key.pem 2048

Die erstellte Datei enthält den öffentlichen und den privaten Schlüssel. Um den öffentlichen Schlüssel aus dieser Datei zu extrahieren, führen Sie den folgenden Befehl aus:

openssl rsa -pubout -in private_key.pem -out public_key.pem

Die Datei mit dem öffentlichen Schlüssel (public_key.pem) enthält den codierten Schlüsselwert, den Sie im folgenden Schritt einfügen.

Schritt 2: Fügen Sie Ihren öffentlichen Schlüssel hinzu CloudFront

Nachdem Sie Ihr RSA key pair erhalten haben, fügen Sie Ihren öffentlichen Schlüssel zu hinzu CloudFront.

Sie können weitere Schlüssel zur Verwendung hinzufügen, CloudFront indem Sie die Schritte des Verfahrens wiederholen.

Schritt 3: Erstellen eines Profils für die Verschlüsselung auf Feldebene

Nachdem Sie mindestens einen öffentlichen Schlüssel hinzugefügt haben CloudFront, erstellen Sie ein Profil, das angibt, CloudFront welche Felder verschlüsselt werden sollen.

Schritt 4: Erstellen einer Konfiguration

Nachdem Sie ein oder mehrere Verschlüsselungsprofile auf Feldebene erstellt haben, erstellen Sie eine Konfiguration, die den Inhaltstyp der Anforderung angibt, die die zu verschlüsselnden Daten enthält, das für die Verschlüsselung zu verwendende Profil und andere Optionen, die angeben, wie Sie mit der Verschlüsselung umgehen CloudFront möchten.

Wenn die Daten beispielsweise nicht verschlüsselt CloudFront werden können, können Sie in den folgenden Szenarien angeben, ob eine Anfrage blockiert oder an Ihren Ursprung weitergeleitet werden CloudFront soll:

In einer Konfiguration können Sie auch angeben, ob die Angabe eines Profils als Abfrageargument in einer ein Profil URL überschreibt, das Sie dem Inhaltstyp für diese Abfrage zugeordnet haben. CloudFront Verwendet standardmäßig das Profil, das Sie einem Inhaltstyp zugeordnet haben, sofern Sie einen angeben. Auf diese Weise können Sie ein Profil haben, das standardmäßig verwendet wird, aber für bestimmte Anforderungen entscheiden, dass Sie ein anderes Profil erzwingen möchten.

So können Sie z. B. (in Ihrer Konfiguration) SampleProfile als das zu verwendende Abfrageargumentprofil festlegen. Dann könnten Sie URL https://d1234.cloudfront.net?fle-profile=SampleProfile statt des Profilshttps://d1234.cloudfront.net, das Sie SampleProfile für den Inhaltstyp der Anfrage eingerichtet haben, das anstelle von anstelle von CloudFront verwenden, um diese Anfrage verwenden zu können.

Sie können bis zu 10 Konfigurationen für ein einzelnes Konto erstellen und dann eine der Konfigurationen dem Cache-Verhalten einer beliebigen Verteilung für das Konto zuordnen.

Schritt 5: Hinzufügen einer Konfiguration zu einem Cache-Verhalten

Um eine Verschlüsselung auf Feldebene zu verwenden, verknüpfen Sie eine Konfiguration mit einem Cache-Verhalten für eine Verteilung, indem Sie die Konfigurations-ID als Wert für Ihre Verteilung hinzufügen.

Weitere Informationen finden Sie unter Referenz zu Verteilungseinstellungen.

Entschlüsseln Sie Datenfelder an Ihrem Ursprung

CloudFront verschlüsselt Datenfelder mit dem. AWS Encryption SDK Die Daten bleiben während des gesamten Anwendungs-Stacks verschlüsselt und können nur von Anwendungen abgerufen werden, die über die Anmeldeinformationen verfügen, um sie zu entschlüsseln.

Nach der Verschlüsselung wird der Verschlüsselungstext base64-kodiert. Wenn Ihre Anwendungen den Text am Ursprung entschlüsseln, müssen sie zuerst den Chiffretext dekodieren und dann die AWS Verschlüsselung SDK verwenden, um die Daten zu entschlüsseln.

Das folgende Codebeispiel veranschaulicht, wie Anwendungen Daten an Ihrem Ursprung entschlüsseln können. Beachten Sie Folgendes:

Beispiel-Code

import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import org.apache.commons.codec.binary.Base64;

import com.amazonaws.encryptionsdk.AwsCrypto;
import com.amazonaws.encryptionsdk.CryptoResult;
import com.amazonaws.encryptionsdk.jce.JceMasterKey;

/**
 * Sample example of decrypting data that has been encrypted by CloudFront field-level encryption.
 */
public class DecryptExample {

    private static final String PRIVATE_KEY_FILENAME = "private_key.der";
    private static final String PUBLIC_KEY_FILENAME = "public_key.der";
    private static PublicKey publicKey;
    private static PrivateKey privateKey;

    // CloudFront uses the following values to encrypt data, and your origin must use same values to decrypt it.
    // In your own code, for PROVIDER_NAME, use the provider name that you specified when you created your field-level
    // encryption profile. This sample uses 'DEMO' for the value.
    private static final String PROVIDER_NAME = "DEMO";
    // In your own code, use the key name that you specified when you added your public key to CloudFront. This sample
    // uses 'DEMOKEY' for the key name.
    private static final String KEY_NAME = "DEMOKEY";
    // CloudFront uses this algorithm when encrypting data.
    private static final String ALGORITHM = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";

    public static void main(final String[] args) throws Exception {

        final String dataToDecrypt = args[0];

        // This sample uses files to get public and private keys.
        // In practice, you should distribute the public key and save the private key in secure storage.
        populateKeyPair();

        System.out.println(decrypt(debase64(dataToDecrypt)));
    }

    private static String decrypt(final byte[] bytesToDecrypt) throws Exception {
        // You can decrypt the stream only by using the private key.

        // 1. Instantiate the SDK
        final AwsCrypto crypto = new AwsCrypto();

        // 2. Instantiate a JCE master key
        final JceMasterKey masterKey = JceMasterKey.getInstance(
                publicKey,
                privateKey,
                PROVIDER_NAME,
                KEY_NAME,
                ALGORITHM);

        // 3. Decrypt the data
        final CryptoResult <byte[], ? > result = crypto.decryptData(masterKey, bytesToDecrypt);
        return new String(result.getResult());
    }

    // Function to decode base64 cipher text.
    private static byte[] debase64(final String value) {
        return Base64.decodeBase64(value.getBytes());
    }

    private static void populateKeyPair() throws Exception {
        final byte[] PublicKeyBytes = Files.readAllBytes(Paths.get(PUBLIC_KEY_FILENAME));
        final byte[] privateKeyBytes = Files.readAllBytes(Paths.get(PRIVATE_KEY_FILENAME));
        publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(PublicKeyBytes));
        privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
    }
}