Utilisation du chiffrement au niveau du champ pour faciliter la protection des données sensibles

Avec Amazon CloudFront, vous pouvez renforcer la sécurité des connexions de bout en bout aux serveurs d’origine à l’aide de HTTPS. Le chiffrement au niveau du champ ajoute une couche de sécurité, qui vous permet de protéger des données spécifiques tout au long du traitement du système, pour que seules certaines applications puissent les voir.

Grâce au chiffrement au niveau du champ, vous pouvez permettre à vos utilisateurs de charger de manière sécurisée des informations sensibles envoyées à vos serveurs web. Les informations sensibles fournies par vos utilisateurs sont chiffrées à la périphérie, à proximité de l’utilisateur, et restent chiffrées tout le long de votre pile d’applications. Ce chiffrement garantit que seules les applications qui ont besoin des données (et qui disposent des informations d’identification pour les déchiffrer) sont en mesure de le faire.

Pour utiliser le chiffrement au niveau du champ, lors de la configuration de votre distribution CloudFront, spécifiez l’ensemble des champs de requêtes POST que vous voulez voir chiffrés et la clé publique à utiliser pour les chiffrer. Vous pouvez chiffrer jusqu’à 10 champs de données dans une requête. (Vous ne pouvez pas chiffrer toutes les données dans une requête avec chiffrement au niveau du champ ; vous devez spécifier des champs individuels à chiffrer).

Lorsque la requête HTTPS avec chiffrement au niveau du champ est réacheminée vers l’origine, et que la requête est acheminée dans votre application ou sous-système d’origine, les données sensibles sont toujours chiffrées, ce qui réduit le risque de violation ou de perte accidentelle des données sensibles. Les composants devant accéder aux données sensibles pour des raisons professionnelles, comme un système de traitement de paiement qui aurait besoin d’accéder à un numéro de crédit, peuvent utiliser la clé privée adéquate pour déchiffrer les données et y accéder.

Le chiffrement au niveau du champ de CloudFront utilise le chiffrement asymétrique, également connu sous le nom de chiffrement à clé publique. Vous fournissez une clé publique à CloudFront et toutes les données sensibles que vous spécifiez sont automatiquement chiffrées. La clé que vous fournissez à CloudFront ne peut pas être utilisée pour déchiffrer les valeurs chiffrées. Seule votre clé privée est valide.

Présentation du chiffrement au niveau du champ

Les étapes suivantes présentent la configuration de chiffrement au niveau du champ. Pour connaître les étapes spécifiques, consultez Configuration du chiffrement au niveau du champ.

Configuration du chiffrement au niveau du champ

Suivez ces étapes pour commencer à utiliser le chiffrement au niveau du champ. Pour en savoir plus sur les quotas (auparavant appelés limites) liés au chiffrement au niveau du champ, consultez Quotas.

Étape 1 : créer une paire de clés RSA

Pour commencer, vous devez créer une paire de clés RSA qui inclut une clé publique et une clé privée. La clé publique permet à CloudFront de chiffrer les données, tandis que la clé privée permet aux composants au niveau de votre origine de déchiffrer les champs qui ont été chiffrés. Vous pouvez utiliser OpenSSL ou un autre outil pour créer une paire de clés. La taille de la clé doit être de 2 048 bits.

Par exemple, si vous utilisez OpenSSL, vous pouvez exécuter la commande suivante pour générer une paire de clés avec une longueur de 2048 bits et l’enregistrer dans le fichier private_key.pem:

openssl genrsa -out private_key.pem 2048

Le fichier obtenu contient à la fois la clé publique et la clé privée. Pour extraire la clé publique de ce fichier, exécutez la commande suivante :

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

Le fichier de clé publique (public_key.pem) contient la valeur de clé codée que vous collez à l’étape suivante.

Étape 2 : ajouter la clé publique à CloudFront

Après avoir obtenu votre paire de clés RSA, ajoutez votre clé publique à CloudFront.

Pour ajouter d’autres clés à utiliser avec CloudFront, répétez cette procédure.

Étape 3 : créer un profil de chiffrement au niveau du champ

Après avoir ajouté au moins une clé publique à CloudFront, créez un profil indiquant à CloudFront les champs à chiffrer.

Étape 4 : créer une configuration

Après avoir créé un ou plusieurs profils de chiffrement au niveau du champ, créez une configuration spécifiant le type de contenu de la requête incluant les données à chiffrer, le profil à utiliser pour le chiffrement et d’autres options indiquant la manière dont vous voulez que CloudFront gère le chiffrement.

Par exemple, lorsque CloudFront ne parvient pas à chiffrer les données, vous pouvez spécifier s’il doit bloquer ou réacheminer une requête vers votre origine dans les cas suivants :

Dans une configuration, vous pouvez également spécifier si fournir un profil en tant qu’argument de requête dans une URL substitue un profil que vous avez mappé vers le type de contenu de cette requête. Par défaut, CloudFront utilise le profil que vous avez mappé à un type de contenu, si vous en spécifiez un. Cela vous permet d’avoir un profil utilisé par défaut, mais de décider, pour certaines requêtes, d’appliquer un autre profil.

Donc, par exemple, vous pouvez spécifier (dans votre configuration) SampleProfile comme profil d’argument de requête à utiliser. Vous pouvez ensuite utiliser l’URL https://d1234.cloudfront.net?fle-profile=SampleProfile au lieu de https://d1234.cloudfront.net, pour que CloudFront utilise SampleProfile pour cette demande, au lieu du profil que vous avez configuré pour le type de contenu de la requête.

Vous pouvez créer jusqu’à 10 configurations pour un seul compte, puis associer l’une des configurations au comportement de cache d’une distribution pour le compte.

Étape 5 : ajouter une configuration à un comportement de cache

Pour utiliser le chiffrement au niveau du champ, associez une configuration à un comportement de cache pour une distribution en ajoutant l’ID de configuration en tant que valeur pour votre distribution.

Pour plus d’informations, consultez Référence de tous les paramètres de distribution.

Déchiffrage de champs de données à votre origine

CloudFront chiffre les champs de données à l’aide du AWS Encryption SDK. Les données restent chiffrées dans l’ensemble de votre pile d’applications et ne sont accessibles qu’aux applications possédant les informations d’identification pour les déchiffrer.

Après le chiffrement, le texte chiffré est encodé en base64. Lorsque vos applications déchiffrent le texte à l’origine, elles doivent d’abord décoder le texte chiffré, puis utiliser le kit SDK de chiffrement AWS pour déchiffrer les données.

L’exemple de code suivant illustre la façon dont les applications peuvent déchiffrer des données à votre origine. Remarques :

Exemple de 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));
    }
}