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 sensible Daten in Ihren Client-Anwendungen verschlüsseln, bevor sie in einen Amazon DocumentDB-Cluster übertragen werden. Vertrauliche 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, die Zuordnung 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

Erstellen Sie mithilfe AWS Key Management Service eines symmetrischen Schlüssels, der zum Verschlüsseln und Entschlüsseln des vertraulichen Datenfeldes verwendet wird, und erteilen Sie ihm die erforderlichen IAM-Nutzungsberechtigungen. AWS KMS speichert den Kundenschlüssel (CK), der zur Verschlüsselung von Datenschlüsseln (DKs) verwendet wird. Speichert den Kundenschlüssel in KMS, um Ihre Sicherheitslage zu stärken. Der Datenschlüssel ist der Sekundärschlüssel, der in einer Amazon DocumentDB-Sammlung gespeichert wird und benötigt wird, um sensible Felder zu verschlüsseln, bevor das Dokument in Amazon DocumentDB gespeichert wird. Der Kundenschlüssel verschlüsselt den Datenschlüssel, der wiederum Ihre Daten ver- und entschlüsselt. Wenn Sie einen globalen Cluster verwenden, können Sie einen Schlüssel für mehrere Regionen erstellen, der von verschiedenen Servicerollen in verschiedenen Regionen verwendet werden kann.

Weitere Informationen zum AWS Key Management Service, einschließlich der Erstellung eines Schlüssels, finden Sie im AWS Key Management Service Developer Guide.

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 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 etwa wie folgt aussehen:

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

Schritt 3: Konfigurieren Sie die Anwendung

Inzwischen haben Sie einen Kundenschlüssel definiert AWS KMS und eine IAM-Rolle erstellt und ihr die richtigen IAM-Berechtigungen für den Zugriff auf den Kundenschlüssel erteilt. 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()

Schritt 4: Definieren Sie eine CRUD-Operation

Definieren Sie den CRUD-Vorgang mit Verschlüsselungsoptionen.

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

Ersetzen Sie im folgenden Beispiel jede placeholder durch Ihre 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 der clientseitigen FLE

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

Um beispielsweise Dokumente abzufragen, bei denen der verschlüsselte Gamerscore 500 entspricht, 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 }
} )