As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Criptografia em nível de campo do lado do cliente

A criptografia em nível de campo (FLE) do lado do cliente do Amazon DocumentDB permite que você criptografe dados confidenciais em aplicativos clientes antes de serem transferidos para um cluster do Amazon DocumentDB. Os dados confidenciais permanecem criptografados quando armazenados e processados em um cluster e são descriptografados no aplicativo cliente quando recuperados.

Conceitos básicos

A configuração inicial da FLE do lado do cliente no Amazon DocumentDB é um processo de quatro etapas que inclui a criação de uma chave de criptografia, a associação de um perfil ao aplicativo, a configuração do aplicativo e a definição da operação CRUD com opções de criptografia.

Etapa 1: criar as chaves de criptografia

Usando o AWS Key Management Service, crie uma chave simétrica que seja usada para criptografar e descriptografar o campo de dados confidenciais e forneça a ela as permissões de uso do IAM necessárias. O AWS KMS armazena a chave do cliente (CK) que é usada para criptografar chaves de dados (DKs). Recomendamos armazenar a chave do cliente no KMS para fortalecer sua postura de segurança. A chave de dados é a chave secundária que é armazenada em uma coleção do Amazon DocumentDB e é necessária para criptografar campos confidenciais antes de armazenar o documento no Amazon DocumentDB. A chave do cliente criptografa a chave de dados que, por sua vez, criptografa e descriptografa seus dados. Se estiver usando um cluster global, você poderá criar uma chave multirregional que pode ser usada por diferentes perfis de serviço em diferentes regiões.

Para obter mais informações sobre o AWS Key Management Service, inclusive como criar uma chave, consulte o Guia do desenvolvedor do Key Management ServiceAWS.

Etapa 2: associar um perfil ao aplicativo

Criar uma política do IAM com permissões para o AWS KMS. Essa política permite que as identidades do IAM às quais está associada obtenham e descriptografem a chave do KMS especificada no campo do recurso. Seu aplicativo assume esse perfil do IAM para se autenticar com o AWS KMS.

A política deve ter a seguinte aparência:

{ "Effect": "Allow",
"Action": ["kms:Decrypt", "kms:Encrypt"],
"Resource": "Customer Key ARN"
}

Etapa 3: configurar o aplicativo

Até agora, você definiu uma chave do cliente em AWS KMS e criou um perfil do IAM e forneceu a ele as permissões corretas do IAM para acessar a chave do cliente. Importe os pacotes necessários.

import boto3
import json
import base64
from pymongo import MongoClient
from pymongo.encryption import (Algorithm,
                                ClientEncryption)

# create a session object: 
my_session = boto3.session.Session()

# get access_key and secret_key programmatically using get_frozen_credentials() method:
 current_credentials = my_session.get_credentials().get_frozen_credentials()

Etapa 4: definir uma operação CRUD

Defina a operação CRUD com opções de criptografia.

Exemplo: arquivo de configuração de criptografia em nível de campo do lado do cliente

No exemplo a seguir, substitua cada espaço reservado para entrada do usuário por suas próprias informações.

# import python packages:
import boto3
import json
import base64
from pymongo import MongoClient
from pymongo.encryption import (Algorithm,
                                ClientEncryption)

def main():
    
    # create a session object:
    my_session = boto3.session.Session()
    
    # get aws_region from session object:
    aws_region = my_session.region_name
    
    # get access_key and secret_key programmatically using get_frozen_credentials() method:
    current_credentials = my_session.get_credentials().get_frozen_credentials()
    provider = "aws"
    
    # define the kms_providers which is later used to create the Data Key:
    kms_providers = {
        provider: {
            "accessKeyId": current_credentials.access_key,
            "secretAccessKey": current_credentials.secret_key
        }
    }
    
    # enter the kms key ARN. Replace the example ARN value.
    kms_arn = "arn:aws:kms:us-east-1:123456789:key/abcd-efgh-ijkl-mnop"
    customer_key = {
        "region": aws_region,
        "key":kms_arn
    }

    # secrets manager is used to strore and retrieve user credentials for connecting to an Amazon DocumentDB cluster. 
    # retrieve the secret using the secret name. Replace the example secret key.
    secret_name = "/dev/secretKey"
    docdb_credentials = json.loads(my_session.client(service_name = 'secretsmanager', region_name = "us-east-1").get_secret_value(SecretId = secret_name)['SecretString'])

    connection_params = '/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false'
    conn_str = 'mongodb://' + docdb_credentials["username"] + ':' + docdb_credentials["password"] + '@' + docdb_credentials["host"] + ':' + str(docdb_credentials["port"]) + connection_params
    client = MongoClient(conn_str) 

    coll = client.test.coll
    coll.drop()
    
    # store the encryption data keys in a key vault collection (having naming convention as db.collection):
    key_vault_namespace = "encryption.dataKeys"
    key_vault_db_name, key_vault_coll_name = key_vault_namespace.split(".", 1)

    # set up the key vault (key_vault_namespace) for this example:
    key_vault = client[key_vault_db_name][key_vault_coll_name]
    key_vault.drop()
    key_vault.create_index("keyAltNames", unique=True)

    client_encryption = ClientEncryption(
        kms_providers,
        key_vault_namespace,
        client,
        coll.codec_options)
    
    # create a new data key for the encrypted field:
    data_key_id = client_encryption.create_data_key(provider, master_key=customer_key, key_alt_names=["some_key_alt_name"], key_material = None)
    
    # explicitly encrypt a field:
    encrypted_first_name = client_encryption.encrypt(
    "Jane",
    Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
    key_id=data_key_id
    )
    coll.insert_one(
    {"gamerTag": "jane_doe90",
    "firstName": encrypted_first_name
    })
    doc = coll.find_one()
    print('Encrypted document: %s' % (doc,))
    
    # explicitly decrypt the field:
    doc["encryptedField"] = client_encryption.decrypt(doc["encryptedField"])
    print('Decrypted document: %s' % (doc,))
    
    # cleanup resources:
    client_encryption.close()
    client.close()
    
    if __name__ == "__main__":
        main()

Consulta no FLE do lado do cliente

O Amazon DocumentDB é compatível com consultas de igualdade de pontos com FLE do lado do cliente. Consultas de desigualdade e comparação podem retornar resultados imprecisos. As operações de leitura e gravação podem ter um comportamento inesperado ou incorreto em comparação com a emissão da mesma operação em relação ao valor descriptografado.

Por exemplo, para consultar filtros para documentos em que a pontuação do jogador é maior que 500:

db.users.find( {
    "gamerscore" : { $gt : 500 }
})

O cliente usa um método de criptografia explícito para criptografar o valor da consulta:

encrypted_gamerscore_filter = client_encryption.encrypt(
    500,
        Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
        key_alt_name=data_key_id
        )

db.users.find( {
    "gamerscore" : { $gt : encrypted_gamerscore_filter }
} )

na operação de busca, o Amazon DocumentDB compara o valor criptografado de 500 com os valores de campo criptografados armazenados em cada documento usando a verificação maior que a desigualdade. A verificação de desigualdade na operação de busca pode retornar um resultado diferente quando executada usando dados e valores descriptografados, mesmo que a operação tenha gerado resultados com êxito.

Limitações

As limitações a seguir se aplicam à criptografia em nível de campo do lado do cliente do Amazon DocumentDB: