Prise en main Interrogation dans un fichier FLE côté client

Client-side chiffrement au niveau du champ

Le chiffrement au niveau du champ (FLE) côté client d'Amazon DocumentDB vous permet de chiffrer les données sensibles de vos applications clientes avant leur transfert vers un cluster Amazon DocumentDB. Les données sensibles restent cryptées lorsqu'elles sont stockées et traitées dans un cluster et sont déchiffrées dans l'application cliente lors de leur récupération.

Rubriques

Prise en main
Interrogation dans un fichier FLE côté client

Prise en main

La configuration initiale du FLE côté client dans Amazon DocumentDB est un processus en quatre étapes qui comprend la création d'une clé de chiffrement, l'association d'un rôle à l'application, la configuration de l'application et la définition du fonctionnement du CRUD avec des options de chiffrement.

Rubriques

Étape 1 : Création des clés de chiffrement
Étape 2 : Associer un rôle à l'application
Étape 3 : Configuration de l'application
Étape 4 : Définition d'une opération CRUD
Exemple : fichier de configuration de chiffrement au niveau des champs côté client

Étape 1 : Création des clés de chiffrement

À l'aide de AWS Key Management Service, créez une clé symétrique gérée par le client qui chiffre et déchiffre le champ de données sensibles, et accordez-lui les autorisations d'utilisation IAM nécessaires. AWS KMS stocke la clé gérée par le client, qui est utilisée pour chiffrer les clés de données. Le stockage de la clé gérée par le client AWS KMS renforce votre posture de sécurité. La clé de données est la clé secondaire, qui est stockée dans une collection Amazon DocumentDB et est requise pour chiffrer les champs sensibles avant de stocker le document dans Amazon DocumentDB. La clé gérée par le client chiffre la clé de données, qui à son tour chiffre et déchiffre vos données. Si vous utilisez un cluster global, vous pouvez créer une clé multirégion que différents rôles de service peuvent utiliser dans différentes régions.

Pour plus d'informations sur la création d'une clé AWS Key Management Service, notamment sur la création d'une clé, consultez AWS Key Management Service les concepts du Guide du AWS Key Management Service développeur.

Étape 2 : Associer un rôle à l'application

Créez une politique IAM avec les AWS KMS autorisations appropriées. Cette politique permet aux identités IAM auxquelles elle est attachée de chiffrer et de déchiffrer la clé KMS spécifiée dans le champ de ressource. Votre application assume ce rôle IAM pour s'authentifier. AWS KMS

La politique devrait ressembler à ceci :


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

Étape 3 : Configuration de l'application

Vous avez défini une clé gérée par le client AWS KMS et créé un rôle IAM avec les autorisations nécessaires pour y accéder. Importez les packages obligatoires.


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

Spécifiez aws le type AWS KMS de fournisseur et entrez les informations d'identification du compte que vous avez récupérées à l'étape précédente.


provider = "aws"
kms_providers = {
    provider: {
        "accessKeyId": current_credentials.access_key,
        "secretAccessKey": current_credentials.secret_key
    }
}

Spécifiez la clé gérée par le client pour chiffrer la clé de données :


customer_key = {
“region”: “AWS region of the customer_key”,
    “key”: “customer_key ARN”
}

key_vault_namespace = "encryption.dataKeys"

key_alt_name = 'TEST_DATA_KEY'

Configurez MongoClient l'objet :


client = MongoClient(connection_string)

coll = client.test.coll
coll.drop()

client_encryption = ClientEncryption(
    kms_providers, # pass in the kms_providers variable from the previous step
    key_vault_namespace = key_vault_namespace,
    client,
    coll.codec_options
)

Générez votre clé de données :


data_key_id = client_encryption.create_data_key(provider,
    customer_key,
    key_alt_name = [key_alt_name])

Récupérez votre clé de données existante :


data_key = DataKey("aws",
    master_key = customer_key)
key_id = data_key["_id"]
data_key_id = client[key_vault_namespace].find_one({"_id": key_id})

Étape 4 : Définition d'une opération CRUD

Définissez l'opération CRUD à l'aide des options de chiffrement.

Définissez la collection pour write/read /supprimer un seul document :
```
coll = client.gameinfo.users
```

Chiffrement explicite : chiffrez les champs et insérez :

Note

Exactement l'un des éléments « key_id » ou « key_alt_name » doit être fourni.


encrypted_first_name = client_encryption.encrypt(
    "Jane",
    Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
    key_id=data_key_id
)
encrypted_last_name = client_encryption.encrypt(
    "Doe",
    Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
    key_id=data_key_id
)
encrypted_dob = client_encryption.encrypt(
    "1990-01-01",
    Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Random,
    key_id=data_key_id
)

coll.insert_one(
    {"gamerTag": "jane_doe90",
    "firstName": encrypted_first_name,
    "lastName": encrypted_last_name,
    "dateOfBirth":encrypted_dob,
    "Favorite_games":["Halo","Age of Empires 2","Medal of Honor"]
})

Exemple : fichier de configuration de chiffrement au niveau des champs côté client

Dans l'exemple suivant, remplacez chacune placeholder par vos propres informations.


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

Interrogation dans un fichier FLE côté client

Amazon DocumentDB prend uniquement en charge les requêtes d'égalité avec des valeurs chiffrées FLE côté client.

Par exemple, pour rechercher des documents dont le score de joueur chiffré est égal à 500, le client utilise une méthode de cryptage explicite pour chiffrer la valeur de la requête :


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Protection des données

Chiffrement de données au repos