Client-side field-level encryption (CSFLE) in MongoDB is set up through five key steps. First, generate a 96-byte local encryption key using openssl and store it securely. Second, ensure your MongoDB driver supports CSFLE and install any required dependencies such as the MongoDB Crypt shared library. Third, define an automatic encryption schema in JSON format specifying which fields to encrypt and their encryption method. Fourth, configure the MongoDB client using AutoEncryptionOpts to reference the key file and schema map enabling automatic encryption during insert and query operations. Fifth, implement secure key management practices including planning for migration to a KMS avoiding hardcoded keys and managing manual key rotation when necessary. Following these steps ensures sensitive data is encrypted before leaving the application protecting privacy and compliance without exposing unencrypted data to the database.

Setting up and managing client-side field-level encryption (CSFLE) in MongoDB gives you fine-grained control over data security by encrypting sensitive fields before they ever leave your application. This means the database never sees the unencrypted data, which is great for compliance and privacy. But it’s not plug-and-play — there are a few steps to get right.

Generate a Local Key and Set Up Your Environment

Before you start encrypting anything, you need an encryption key. With CSFLE, this key stays on your side — hence "client-side." You can generate a 96-byte local key using a tool like openssl:

openssl rand 96 > master-key.bin

This file will be used as your local key. Make sure to store it securely — it's the root of your encryption setup.

Next, make sure your MongoDB driver supports CSFLE. Official drivers for Node.js, Python, Java, and others do support it, but you may need to install additional dependencies or libraries like the MongoDB Crypt shared library.

Define Your Encryption Schema

CSFLE requires that you define ahead of time which fields you want encrypted and how. This is done through a special schema called an automatic encryption schema. You specify this in JSON format, mapping collection namespaces to their encrypted fields.

Here’s a basic example for a collection called mydb.persons where we want to encrypt the ssn field using AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic` encryption:

{
  "mydb.persons": {
    "properties": {
      "ssn": {
        "encrypt": {
          "bsonType": "string",
          "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
        }
      }
    },
    "required": ["ssn"]
  }
}

You’ll reference this schema when configuring your MongoDB client. The encryption happens automatically during insert and query operations — assuming everything else is set up correctly.

Configure the MongoDB Client with Auto Encryption Settings

Once you have your key and schema ready, you need to configure your MongoDB client to use them.

In code, this usually involves setting up an AutoEncryptionOpts object that points to your key file and schema map. Here's a simplified example in Python:

from pymongo import MongoClient
from pymongo.encryption_options import AutoEncryptionOpts

auto_encryption_opts = AutoEncryptionOpts(
    key_vault_namespace="encryption.__keyVault",
    kms_providers={"local": {"key": open("master-key.bin", "rb").read()}},
    schema_map=schema  # the schema dict from earlier
)

client = MongoClient(auto_encryption_opts=auto_encryption_opts)

With this setup, inserting into mydb.persons will automatically encrypt the ssn field before sending it to the server. Queries for ssn will also be decrypted automatically.

Just keep in mind:

• Indexes on encrypted fields won't work unless the encryption is deterministic.
• You must manage the schema carefully — if a field is missing from the schema, it won’t be encrypted.
• Don’t lose your encryption key — without it, your data becomes unreadable.

Handle Key Management and Rotate Keys Carefully

While this guide uses a local key for simplicity, real-world setups often use a Key Management Service (KMS) like AWS KMS or Azure Key Vault. These provide better key rotation, auditing, and access control.

If you're starting with a local key, plan for eventual migration to a KMS. Also, don’t hardcode keys in your app — load them from secure configuration files or environment variables.

Key rotation isn’t automatic either. If you change keys, you'll need to re-encrypt existing data manually. That’s why many teams stick with one long-lived key for a given dataset, especially if retroactive changes aren't required.

That's basically how you set up and manage CSFLE in MongoDB. It adds a layer of protection that’s hard to beat when done right, but it does require careful planning around schemas, keys, and infrastructure.

The above is the detailed content of How can you set up and manage client-side field-level encryption (CSFLE) in MongoDB?. For more information, please follow other related articles on the PHP Chinese website!