Enkripsi tingkat bidang sisi klien

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

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

Amazon DocumentDB client-side field level encryption (FLE) memungkinkan Anda mengenkripsi data sensitif dalam aplikasi klien Anda sebelum ditransfer ke cluster Amazon DocumentDB. Data sensitif tetap dienkripsi ketika disimpan dan diproses dalam cluster dan didekripsi pada aplikasi klien ketika 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

Menggunakan AWS Key Management Service, membuat kunci simetris yang digunakan untuk mengenkripsi dan mendekripsi bidang data sensitif dan memberikan izin penggunaan IAM yang diperlukan. AWS KMS menyimpan Kunci Pelanggan (CK) yang digunakan untuk mengenkripsi Kunci Data (DKs). Kami merekomendasikan untuk menyimpan Kunci Pelanggan di KMS untuk 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 Pelanggan mengenkripsi Kunci Data yang pada gilirannya mengenkripsi dan mendekripsi data Anda. Jika Anda menggunakan klaster global, Anda dapat membuat kunci multi-wilayah yang dapat digunakan oleh peran layanan yang berbeda di berbagai wilayah.

Untuk informasi selengkapnya tentang AWS Key Management Service, termasuk cara membuat kunci, lihat Panduan Pengembang Layanan Manajemen AWS Kunci.

Langkah 2: Kaitkan 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 dalam bidang sumber daya. Aplikasi Anda mengasumsikan peran IAM ini untuk diautentikasi dengan. AWS KMS

Kebijakan harus terlihat mirip dengan ini:

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

Langkah 3: Konfigurasikan aplikasi

Sekarang Anda menetapkan Kunci Pelanggan AWS KMS dan membuat peran IAM dan memberikannya izin IAM yang tepat untuk mengakses Kunci Pelanggan. 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 user input 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 strore 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["encryptedField"] = client_encryption.decrypt(doc["encryptedField"])
    print('Decrypted document: %s' % (doc,))
    
    # cleanup resources:
    client_encryption.close()
    client.close()
    
    if __name__ == "__main__":
        main()

Menanyakan di FLE sisi klien

Amazon DocumentDB mendukung kueri kesetaraan titik dengan FLE sisi klien. Ketidaksetaraan dan kueri perbandingan dapat mengembalikan hasil yang tidak akurat. Operasi baca dan tulis mungkin memiliki perilaku yang tidak terduga atau salah dibandingkan dengan mengeluarkan operasi yang sama terhadap nilai yang didekripsi.

Misalnya, untuk meminta filter untuk dokumen di mana skor gamerlebih besar dari 500:

db.users.find( {
    "gamerscore" : { $gt : 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_alt_name=data_key_id
        )

db.users.find( {
    "gamerscore" : { $gt : encrypted_gamerscore_filter }
} )

Dalam operasi find, Amazon DocumentDB membandingkan nilai terenkripsi 500 dengan nilai bidang terenkripsi yang disimpan di setiap dokumen menggunakan pemeriksaan lebih besar dari ketidaksetaraan. Pemeriksaan ketidaksetaraan dalam operasi find dapat mengembalikan hasil yang berbeda ketika dilakukan dengan menggunakan data dan nilai yang didekripsi, meskipun operasi berhasil menghasilkan hasil.

Batasan

Batasan berikut berlaku untuk enkripsi level bidang sisi klien Amazon DocumentDB: