View a markdown version of this page

Client-side Verschlüsselung auf Feldebene - Amazon DocumentDB

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Client-side Verschlüsselung auf Feldebene

Mit der clientseitigen Verschlüsselung auf Feldebene (FLE) von Amazon DocumentDB können Sie vertrauliche Daten in Ihren Client-Anwendungen verschlüsseln, bevor sie an einen Amazon DocumentDB-Cluster übertragen werden. Sensible Daten bleiben verschlüsselt, wenn sie in einem Cluster gespeichert und verarbeitet werden, und werden beim Abrufen in der Client-Anwendung entschlüsselt.

Erste Schritte

Die Erstkonfiguration der clientseitigen FLE in Amazon DocumentDB ist ein vierstufiger Prozess, der die Erstellung eines Verschlüsselungsschlüssels, das Zuweisen einer Rolle zur Anwendung, die Konfiguration der Anwendung und die Definition des CRUD-Vorgangs mit Verschlüsselungsoptionen umfasst.

Schritt 1: Erstellen Sie die Verschlüsselungsschlüssel

Verwenden AWS Key Management Service, erstellen Sie einen symmetrischen, vom Kunden verwalteten Schlüssel, der das sensible Datenfeld ver- und entschlüsselt, und gewähren Sie ihm die erforderlichen IAM-Nutzungsberechtigungen. AWS KMS speichert den vom Kunden verwalteten Schlüssel, der zum Verschlüsseln von Datenschlüsseln verwendet wird. Speichert den vom Kunden verwalteten Schlüssel in AWS KMS stärkt Ihre Sicherheitslage. Der Datenschlüssel ist der Sekundärschlüssel, der in einer Amazon DocumentDB-Sammlung gespeichert wird und benötigt wird, um vertrauliche Felder zu verschlüsseln, bevor das Dokument in Amazon DocumentDB gespeichert wird. Der vom Kunden verwaltete Schlüssel verschlüsselt den Datenschlüssel, der wiederum Ihre Daten verschlüsselt und entschlüsselt. Wenn Sie einen globalen Cluster verwenden, können Sie einen Schlüssel für mehrere Regionen erstellen, den verschiedene Servicerollen in verschiedenen Regionen verwenden können.

Für weitere Informationen über AWS Key Management Service, einschließlich Informationen zum Erstellen eines Schlüssels, finden Sie unter AWS Key Management Service Konzepte in der AWS Key Management Service Leitfaden für Entwickler.

Schritt 2: Ordnen Sie der Anwendung eine Rolle zu

Erstellen Sie eine IAM-Richtlinie mit den entsprechenden AWS KMS Berechtigungen. Diese Richtlinie ermöglicht es den IAM-Identitäten, an die sie angehängt ist, den im Ressourcenfeld angegebenen KMS-Schlüssel zu verschlüsseln und zu entschlüsseln. Ihre Anwendung nimmt diese IAM-Rolle für die Authentifizierung an AWS KMS.

Die Richtlinie sollte in etwa so aussehen:

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

Schritt 3: Konfigurieren Sie die Anwendung

Sie haben einen vom Kunden verwalteten Schlüssel definiert in AWS KMS und haben eine IAM-Rolle mit den erforderlichen Zugriffsberechtigungen erstellt. Importieren Sie die erforderlichen Pakete.

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()
  1. Spezifizieren aws als AWS KMS Geben Sie die Kontoinformationen ein, die Sie im vorherigen Schritt abgerufen haben, und geben Sie sie ein.

    provider = "aws" kms_providers = { provider: { "accessKeyId": current_credentials.access_key, "secretAccessKey": current_credentials.secret_key } }
  2. Geben Sie den vom Kunden verwalteten Schlüssel an, um den Datenschlüssel zu verschlüsseln:

    customer_key = { “region”: “AWS region of the customer_key”, “key”: “customer_key ARN” } key_vault_namespace = "encryption.dataKeys" key_alt_name = 'TEST_DATA_KEY'
  3. Konfigurieren Sie den MongoClient Objekt:

    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 )
  4. Generieren Sie Ihren Datenschlüssel:

    data_key_id = client_encryption.create_data_key(provider, customer_key, key_alt_name = [key_alt_name])
  5. Rufen Sie Ihren vorhandenen Datenschlüssel ab:

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

Schritt 4: Definieren Sie eine CRUD-Operation

Definieren Sie den CRUD-Vorgang mit Verschlüsselungsoptionen.

  1. Definieren Sie die Sammlung wie write/read/lösche ein einzelnes Dokument:

    coll = client.gameinfo.users
  2. Explizite Verschlüsselung — Felder verschlüsseln und einfügen:

    Anmerkung

    Es muss genau einer der Werte „key_id“ oder „key_alt_name“ angegeben werden.

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

Beispiel: Konfigurationsdatei für die clientseitige Verschlüsselung auf Feldebene

Ersetzen Sie im folgenden Beispiel die einzelnen placeholder mit Ihren eigenen Informationen.

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

Abfragen in clientseitiger FLE

Amazon DocumentDB unterstützt nur Gleichheitsabfragen mit clientseitigen FLE-verschlüsselten Werten.

Um beispielsweise Dokumente abzufragen, bei denen der verschlüsselte Gamerscore gleich 500 ist, verwendet der Client eine explizite Verschlüsselungsmethode, um den Abfragewert zu verschlüsseln:

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