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.

Topics

• Schritt 1: Erstellen Sie die Verschlüsselungsschlüssel

• Schritt 2: Ordnen Sie der Anwendung eine Rolle zu

• Schritt 3: Konfigurieren Sie die Anwendung

• Schritt 4: Definieren Sie eine CRUD-Operation

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

Schritt 1: Erstellen Sie die Verschlüsselungsschlüssel

Verwenden Sie: Erstellen Sie einen symmetrischen AWS Key Management Service, vom Kunden verwalteten Schlüssel, der das sensible Datenfeld verschlüsselt 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. Durch das Speichern des vom Kunden verwalteten Schlüssels wird Ihre Sicherheitslage AWS KMS gestärkt. 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.

Weitere Informationen dazu AWS Key Management Service, einschließlich der Erstellung eines Schlüssels, finden Sie unter AWS Key Management Service Konzepte im AWS Key Management Service Entwicklerhandbuch.

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 übernimmt diese IAM-Rolle, mit der sie sich authentifizieren kann. AWS KMS

Die Richtlinie sollte in etwa wie folgt 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 AWS KMS und 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. Geben Sie aws als AWS KMS Anbietertyp an und geben Sie die Kontoanmeldeinformationen ein, die Sie im vorherigen Schritt abgerufen haben.

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

2. Geben Sie den vom Kunden verwalteten Schlüssel zum Verschlüsseln des Datenschlüssels an:

   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 das 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, um ein einzelnes Dokument zu write/read /löschen:

   coll = client.gameinfo.users

2. Explizite Verschlüsselung — Felder verschlüsseln und Folgendes 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 jede Datei 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 einer 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 }
} )