Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Client-side crittografia a livello di campo

La crittografia a livello di campo (FLE) lato client di Amazon DocumentDB consente di crittografare i dati sensibili nelle applicazioni client prima che vengano trasferiti in un cluster Amazon DocumentDB. I dati sensibili rimangono crittografati quando vengono archiviati ed elaborati in un cluster e vengono decrittografati nell'applicazione client quando vengono recuperati.

Nozioni di base

La configurazione iniziale del FLE lato client in Amazon DocumentDB è un processo in quattro fasi che include la creazione di una chiave di crittografia, l'associazione di un ruolo all'applicazione, la configurazione dell'applicazione e la definizione del funzionamento CRUD con opzioni di crittografia.

Fase 1: Creazione delle chiavi di crittografia

Utilizzando AWS Key Management Service, crea una chiave simmetrica gestita dal cliente che crittografa e decrittografa il campo dei dati sensibili e concedi le autorizzazioni di utilizzo IAM necessarie. AWS KMS memorizza la chiave gestita dal cliente, utilizzata per crittografare le chiavi di dati. L'archiviazione della chiave gestita dal cliente AWS KMS rafforza il livello di sicurezza. La chiave dati è la chiave secondaria, archiviata in una raccolta Amazon DocumentDB ed è necessaria per crittografare i campi sensibili prima di archiviare il documento in Amazon DocumentDB. La chiave gestita dal cliente crittografa la chiave dati, che a sua volta crittografa e decrittografa i tuoi dati. Se utilizzi un cluster globale, puoi creare una chiave multiregionale che diversi ruoli di servizio possono utilizzare in diverse regioni.

Per ulteriori informazioni su AWS Key Management Service, incluso come creare una chiave, consulta AWS Key Management Service i concetti nella Guida per gli AWS Key Management Service sviluppatori.

Fase 2: Associare un ruolo all'applicazione

Crea una policy IAM con le AWS KMS autorizzazioni appropriate. Questa policy consente alle identità IAM a cui è collegata di crittografare e decrittografare la chiave KMS specificata nel campo delle risorse. L'applicazione assume questo ruolo IAM con cui autenticarsi. AWS KMS

La policy dovrebbe essere simile a questa:

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

Fase 3: Configurare l'applicazione

Hai definito una chiave gestita dal cliente AWS KMS e creato un ruolo IAM con le autorizzazioni necessarie per accedervi. Importa i pacchetti richiesti.

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()

Fase 4: Definire un'operazione CRUD

Definisci l'operazione CRUD con opzioni di crittografia.

Esempio: file di configurazione della crittografia a livello di campo sul lato client

Nel seguente esempio, sostituisci ciascuno placeholder con le tue informazioni.

# 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 store 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["firstName"] = client_encryption.decrypt(doc["firstName"])
    print('Decrypted document: %s' % (doc,))
    
    # cleanup resources:
    client_encryption.close()
    client.close()
    
if __name__ == "__main__":
    main()

Interrogazione nel FLE sul lato client

Amazon DocumentDB supporta solo le query di uguaglianza con valori crittografati FLE sul lato client.

Ad esempio, per richiedere documenti in cui il gamerscore crittografato è pari a 500, il client utilizza un metodo di crittografia esplicito per crittografare il valore della query:

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

coll.find( {
    "gamerscore" : { "$eq" : encrypted_gamerscore_filter }
} )