Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Client-side enkripsi tingkat lapangan

Enkripsi tingkat bidang sisi klien Amazon DocumentDB (FLE) memungkinkan Anda mengenkripsi data sensitif di aplikasi klien sebelum ditransfer ke cluster Amazon DocumentDB. Data sensitif tetap dienkripsi ketika disimpan dan diproses dalam cluster dan didekripsi di aplikasi klien saat diambil.

Memulai

Konfigurasi awal FLE sisi klien di Amazon DocumentDB adalah proses empat langkah yang mencakup pembuatan kunci enkripsi, mengaitkan peran ke aplikasi, mengonfigurasi aplikasi, dan mendefinisikan operasi CRUD dengan opsi enkripsi.

Langkah 1: Buat kunci enkripsi

Dengan menggunakan AWS Key Management Service, buat kunci yang dikelola pelanggan simetris yang mengenkripsi dan mendekripsi bidang data sensitif, dan berikan izin penggunaan IAM yang diperlukan. AWS KMS menyimpan kunci yang dikelola pelanggan, yang digunakan untuk mengenkripsi kunci data. Menyimpan kunci yang dikelola pelanggan AWS KMS memperkuat postur keamanan Anda. Kunci data adalah kunci sekunder, yang disimpan dalam koleksi Amazon DocumentDB dan diperlukan untuk mengenkripsi bidang sensitif sebelum menyimpan dokumen di Amazon DocumentDB. Kunci yang dikelola pelanggan mengenkripsi kunci data, yang pada gilirannya mengenkripsi dan mendekripsi data Anda. Jika Anda menggunakan cluster global, Anda dapat membuat kunci Multi-wilayah yang dapat digunakan oleh peran layanan yang berbeda di Wilayah yang berbeda.

Untuk informasi selengkapnya tentang AWS Key Management Service, termasuk cara membuat kunci, lihat AWS Key Management Service konsep di Panduan Peng AWS Key Management Service embang.

Langkah 2: Mengaitkan peran dengan aplikasi

Buat kebijakan IAM dengan AWS KMS izin yang sesuai. Kebijakan ini memungkinkan identitas IAM yang dilampirkan untuk mengenkripsi dan mendekripsi kunci KMS yang ditentukan di bidang sumber daya. Aplikasi Anda mengasumsikan peran IAM ini untuk diautentikasi. AWS KMS

Kebijakan harus terlihat mirip dengan ini:

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

Langkah 3: Konfigurasikan aplikasi

Anda telah menentukan kunci yang dikelola pelanggan AWS KMS dan membuat peran IAM dengan izin yang diperlukan untuk mengaksesnya. Impor paket yang diperlukan.

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

Langkah 4: Tentukan operasi CRUD

Tentukan operasi CRUD dengan opsi enkripsi.

Contoh: file konfigurasi enkripsi tingkat bidang sisi klien

Dalam contoh berikut, ganti masing-masing placeholder dengan informasi Anda sendiri.

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

Menanyakan di FLE sisi klien

Amazon DocumentDB hanya mendukung kueri kesetaraan dengan nilai terenkripsi FLE sisi klien.

Misalnya, untuk menanyakan dokumen di mana skor pemain terenkripsi sama dengan 500, klien menggunakan metode enkripsi eksplisit untuk mengenkripsi nilai kueri:

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