This use case guide is an introduction to implementing automatic Client-Side Field Level Encryption using supported MongoDB drivers and is intended for full-stack developers. The guide presents the following information in the context of a real-world scenario:
- How Client-Side Field Level Encryption works
- Reasons to choose this security feature
- How to implement Client-Side Field Level Encryption with the MongoDB driver
Applications frequently use and store sensitive data such as confidential personal details, payment information, or proprietary data. In some jurisdictions, this type of data is subject to governance, privacy, and security compliance mandates. Unauthorized access of sensitive data or a failure to comply with a mandate often results in significant reputation damage and financial penalties. Therefore, it is important to keep sensitive data secure. MongoDB online course helps you to learn more effectively along with the real time projects.
In this scenario, we secure sensitive data on a Medical Care Management System which stores patients' personal information, insurance information, and medical records for a fictional company, MedcoMD. None of the patient data is public, and certain data such as their social security number (SSN, a US government-issued id number), insurance policy number, and vital sign measurements are particularly sensitive and subject to privacy compliance. It is important for the company and the patient that the data is kept private and secure.
MedcoMD needs this system to satisfy the following use cases:
- Doctors use the system to access Patients' medical records, insurance information, and add new vital sign measurements.
- Receptionists use the system to verify the Patients' identity, using a combination of their contact information and the last four digits of their Social Security Number (SSN).
- Receptionists can view a Patient's insurance policy provider, but not their policy number.
- Receptionists cannot access a Patient's medical records.
MedcoMD is also concerned with disclosure of sensitive data through any of the following methods:
- Accidental disclosure of data on the Receptionist's publicly-viewable screen.
- Direct access to the database by a superuser such as a database administrator.
- Capture of data over an insecure network.
- Access to the data by reading a server's memory.
- Access to the on-disk data by reading database or backup files.
What can MedcoMD do to balance the functionality and access restrictions of their Medical Care Management System?
Comparison of Security Features
The MedcoMD engineers review the Medical Care Management System specification and research the proper solution for limiting access to sensitive data.
The first MongoDB security feature they evaluated was Role based Access control which allows administrators to grant and restrict collection-level permissions for users. With the appropriate role definition and assignment, this solution prevents accidental disclosure of data and access. However, it does not prevent capture of the data over an insecure network, direct access of data by a superuser, access to data by reading the server's memory, or access to on-disk data by reading the database or backup files.
The next MongoDB security features they evaluated which encrypts the database files on disk and Transport Encryption Using TLS/SSL which encrypts data over the network. When applied together, these two features prevent access to on-disk database files as well as capture of the data on the network, respectively. When combined with Role-Based Access Control, these three security features offer near-comprehensive security coverage of the sensitive data, but lack a mechanism to prevent the data from being read from the server's memory.
Finally, the MedcoMD engineers discovered a feature that independently satisfies all the security criteria. Client-side Field Level Encryption allows the engineers to specify the fields of a document that should be kept encrypted. Sensitive data is transparently encrypted/decrypted by the client and only communicated to and from the server in encrypted form. This mechanism keeps the specified data fields secure in encrypted form on both the server and the network. While all clients have access to the non-sensitive data fields, only appropriately-configured CSFLE clients are able to read and write the sensitive data fields. Best MongoDB course from industrial experts with more techniques.
MedcoMD will provide Receptionists with a client that is not configured to access data encrypted with CSFLE. This will prevent them from viewing the sensitive fields and accidentally leaving them displayed on-screen in a public area. MedcoMD will provide Doctors with a client with CSFLE enabled which will allow them to access the sensitive data fields in the privacy of their own office.
Equipped with CSFLE, MedcoMD can keep their sensitive data secure and compliant to data privacy regulations with MongoDB.
This section explains the following configuration and implementation details of CSFLE:
- Software required to run your client and server in your local development environment.
- Creation and validation of the encryption keys.
- Configuration of the client for automatic field-level encryption.
- Queries, reads, and writes of encrypted fields.
About the Mongocryptd Application
The MongoDB client communicates with a separate encryption application called
mongocryptd which automates the client-side field level encryption. This application is installed with MongoDB Enterprise Server.
When we create a CSFLE-enabled MongoDB client, the
mongocryptd process is automatically started by default, and handles the following responsibilities:
- Validates the encryption instructions defined in the JSON Schema and flags the referenced fields for encryption in read and write operations.
- Prevents unsupported operations from being executed on encrypted fields.
MedcoMD wanted to develop a system that securely stores sensitive medical records for their patients. They also wanted strong data access and security guarantees that do not rely on individual users. After researching the available options, MedcoMD determined that MongoDB Client-Side Field Level Encryption satisfies their requirements and decided to implement it in their application. To implement CSFLE they:
1. Created a Locally-Managed Master Encryption Key
A locally-managed master key allowed MedcoMD to rapidly develop the client application without external dependencies and avoid accidentally leaking sensitive production credentials.
2. Generated an Encrypted Data Key with the Master Key
CSFLE uses envelope encryption, so they generated a data key that encrypts and decrypts each field and then encrypted the data key using a master key. This allows MedcoMD to store the encrypted data key in MongoDB so that it is shared with all clients while preventing access to clients that don't have access to the master key.
3. Created a JSON Schema
CSFLE can automatically encrypt and decrypt fields based on a provided JSON Schema that specifies which fields to encrypt and how to encrypt them. MongoDB online training for more skills.
4. Tested and Validated Queries with the CSFLE Client
MedcoMD engineers tested their CSFLE implementation by inserting and querying documents with encrypted fields. They then validated that clients without CSFLE enabled could not read the encrypted data.