Use criptografia de nível de campo para ajudar a proteger dados confidenciais

Com o Amazon CloudFront, é possível impor conexões seguras de ponta a ponta a servidores de origem usando HTTPS. A criptografia no nível de campo acrescenta uma camada adicional de segurança que permite proteger dados específicos em todo o processamento do sistema, de modo que apenas alguns aplicativos possam vê-los.

A criptografia no nível de campo habilita permitir que usuários faça upload de informações confidenciais com segurança nos servidores web. As informações confidenciais fornecidas pelos usuários são criptografadas na borda, próximo ao usuário, e permanecem criptografadas em toda a pilha de aplicativos. Essa criptografia garante que somente os aplicativos que precisam dos dados e que têm as credenciais para descriptografá-los possam fazê-lo.

Para usar a criptografia no nível de campo, ao configurar a distribuição do CloudFront, especifique o conjunto de campos nas solicitações POST que você quer que sejam criptografados e a chave pública a ser usada para criptografá-los. Você pode criptografar até 10 campos de dados em uma solicitação. (Não é possível criptografar todos os dados em uma solicitação com criptografia no nível de campo; é preciso especificar campos individuais para criptografar.)

Quando a solicitação HTTPS com criptografia no nível de campo é encaminhada para a origem, e a solicitação é roteada em todo o subsistema ou aplicativo de origem, os dados confidenciais ainda são criptografados, reduzindo o risco de uma violação dos dados ou da perda acidental de dados confidenciais. Os componentes que precisam acessar os dados confidenciais por motivos comerciais, como um sistema de processamento de pagamento que precisa de acesso a um número de crédito, podem usar a chave privada apropriada para descriptografar e acessar os dados.

A criptografia no nível de campo do CloudFront usa criptografia assimétrica, também conhecida como criptografia de chave pública. Basta você fornecer uma chave pública para o CloudFront e todos os dados confidenciais especificados são criptografados automaticamente. A chave que você fornece ao CloudFront não pode ser usada para descriptografar os valores criptografados; somente sua chave privada poderá fazer isso.

Visão geral da criptografia no nível de campo

As etapas a seguir fornecem uma visão geral de como configurar a criptografia no nível de campo. Para obter as etapas específicas, consulte Configurar a criptografia em nível de campo.

Configurar a criptografia em nível de campo

Siga essas etapas para começar a usar a criptografia no nível de campo. Para saber mais sobre cotas (anteriormente conhecidas como limites) na criptografia em nível de campo, consulte Cotas.

Etapa 1: Criar um par de chaves do RSA

Para começar a usar, é necessário criar um par de chaves RSA que inclua uma chave pública e uma chave privada. A chave pública permite que o CloudFront criptografe dados e a chave privada permite que os componentes na origem descriptografem os campos que foram criptografados. Você pode usar o OpenSSL ou outra ferramenta para criar um par de chaves. O tamanho da chave deve ser de 2048 bits.

Por exemplo, se estiver usando OpenSSL, poderá usar o seguinte comando para gerar um par de chaves de 2.048 bits e salvá-lo no arquivo private_key.pem:

openssl genrsa -out private_key.pem 2048

O arquivo resultante contém a chave pública e a privada. Para extrair a chave pública do arquivo, execute o seguinte comando:

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

O arquivo de chave pública (public_key.pem) contém o valor de chave codificada que você colar na etapa seguinte.

Etapa 2: Adicionar uma chave pública ao CloudFront

Após obter o par de chaves RSA, adicione a sua chave pública ao CloudFront.

É possível adicionar mais chaves para uso com o CloudFront repetindo as etapas desse procedimento.

Etapa 3: Criar um perfil de criptografia no nível de campo

Depois de adicionar pelo menos uma chave pública ao CloudFront, crie um perfil que informe ao CloudFront quais campos serão criptografados.

Etapa 4: Criar uma configuração

Depois que criar um ou mais perfis de criptografia no nível de campo, crie uma configuração para especificar o tipo de conteúdo da solicitação que inclua os dados a serem criptografados, o perfil a ser usado na criptografia e outras opções especificando como você deseja que o CloudFront processe a criptografia.

Por exemplo, quando o CloudFront não puder criptografar os dados, você poderá especificar se ele deve bloquear ou encaminhar uma solicitação para a origem nos seguintes cenários:

Em uma configuração, você também pode especificar se um perfil fornecido como um argumento de consulta em uma URL poderá substituir o perfil que foi mapeado para o tipo de conteúdo dessa consulta. Por padrão, o CloudFront usará o perfil que você mapeou para um tipo de conteúdo, se houver um perfil especificado. Isso permite que você tenha um perfil que é usado por padrão, mas que possa decidir, em determinadas solicitações, que deseja impor um perfil diferente.

Assim, por exemplo, é possível especificar (em sua configuração) SampleProfile como o perfil do argumento de consulta a ser usado. Depois, você poderá usar o URL https://d1234.cloudfront.net?fle-profile=SampleProfile em vez de https://d1234.cloudfront.net, para que o CloudFront use SampleProfile para essa solicitação, em vez do perfil configurado para o tipo de conteúdo da solicitação.

Você pode criar até 10 configurações para uma única conta e, em seguida, associar uma das configurações ao comportamento de cache de qualquer distribuição da conta.

Etapa 5: Adicionar uma configuração ao comportamento de cache

Para usar a criptografia no nível de campo, vincule uma configuração ao comportamento de cache de uma distribuição adicionando o ID da configuração como um valor para a sua distribuição.

Para ter mais informações, consulte Referência de configurações da distribuição.

Descriptografar campos de dados na origem

O CloudFront criptografa os campos de dados usando o AWS Encryption SDK. Os dados permanecem criptografados em toda a pilha de aplicativos e podem ser acessados somente por aplicativos que tenham as credenciais necessárias para descriptografá-los.

Após a criptografia, o texto cifrado é codificado em base64. Quando as suas aplicações descriptografam o texto na origem, primeiro devem decodificar o texto cifrado e, depois, usar o SDK de criptografia da AWS para descriptografar os dados.

O exemplo de código a seguir ilustra como os aplicativos podem descriptografar dados na origem. Observe o seguinte:

Código de exemplo

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