Configurar Queryable Encryption

Overview

Queryable Encryption cifra los campos de documentos confidenciales en la capa de aplicación antes de escribir datos en MongoDB, al tiempo que permite que la aplicación query esos campos. Solo las aplicaciones que tienen acceso a sus llaves de cifrado pueden leer los datos de texto sin formato. Si un atacante obtiene acceso a la base de datos, solo podrá ver el texto cifrado porque no tiene acceso a las llaves de cifrado.

Por ejemplo, puede utilizar Queryable Encryption para cifrar campos que contengan:

• Números de Seguridad Social

• Números de tarjetas de crédito

• Información médica o de salud

• Información financiera

• Cualquier otra información sensible o de identificación personal

El proveedor de EF Core admite Queryable Encryption a través de una API de modelo fluido. Configura qué propiedades de entidad cifrar mediante el método OnModelCreating(), y el proveedor gestiona el cifrado automáticamente al leer y escribir datos.

Habilitar Queryable Encryption

Las siguientes secciones describen cómo configurar las opciones de cifrado en su contexto y marcar las propiedades de la entidad para el cifrado en su modelo:

MongoClientSettings.Extensions.AddAutoEncryption();

var kmsProviders = new Dictionary<
    string, IReadOnlyDictionary<string, object>>
{
    {
        "local",
        new Dictionary<string, object>
        {
            { "key", localMasterKey }
        }
    }
};
var keyVaultNamespace = CollectionNamespace.FromFullName(
    "encryption.__keyVault");
var mongoOptions = new MongoOptionsExtension()
    .WithConnectionString(connectionString)
    .WithDatabaseName("myDatabase")
    .WithKmsProviders(kmsProviders)
    .WithKeyVaultNamespace(keyVaultNamespace)
    .WithCryptProvider(
        CryptProvider.AutoEncryptSharedLibrary,
        Environment.GetEnvironmentVariable("CRYPT_SHARED_LIB_PATH"));
var optionsBuilder = new DbContextOptionsBuilder<MyDbContext>()
    .UseMongoDB(mongoOptions);

Ejemplo: Cifrar datos del paciente

La siguiente entidad Patient define el modelo orientado a documentos, con los campos SSN y DateOfBirth para cifrar:

public class Patient
{
    public ObjectId Id { get; set; }
    public string Name { get; set; } = null!;
    public string SSN { get; set; } = null!;
    public DateTime DateOfBirth { get; set; }
}

El siguiente HospitalContext marca esos campos para el cifrado en el método OnModelCreating(). SSN se cifra sin soporte de query, y DateOfBirth se cifra con soporte de query de rango. El constructor acepta los ID de dos llaves de cifrado de datos, que se crean en el almacén de llaves antes de inicializar el contexto:

public class HospitalContext : DbContext
{
    public DbSet<Patient> Patients { get; set; } = null!;
    private readonly Guid _ssnDataKeyId;
    private readonly Guid _dobDataKeyId;
    public HospitalContext(
        DbContextOptions options,
        Guid ssnDataKeyId,
        Guid dobDataKeyId)
        : base(options)
    {
        _ssnDataKeyId = ssnDataKeyId;
        _dobDataKeyId = dobDataKeyId;
    }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<Patient>(entity =>
        {
            entity.ToCollection("patients");
            entity.Property(p => p.SSN)
                  .IsEncrypted(_ssnDataKeyId);
            entity.Property(p => p.DateOfBirth)
                  .IsEncryptedForRange(
                      new DateTime(1900, 1, 1),
                      new DateTime(2100, 12, 31),
                      _dobDataKeyId);
        });
    }
}

El siguiente código configura las opciones de cifrado, crea una instancia de HospitalContext con los ID de clave de datos e inserta y consulta un documento Patient:

var mongoOptions = new MongoOptionsExtension()
    .WithConnectionString("<connection string URI>")
    .WithDatabaseName("hospitalDb")
    .WithKmsProviders(kmsProviders)
    .WithKeyVaultNamespace(keyVaultNamespace)
    .WithCryptProvider(
        CryptProvider.AutoEncryptSharedLibrary,
        Environment.GetEnvironmentVariable("CRYPT_SHARED_LIB_PATH"));
using var context = new HospitalContext(
    new DbContextOptionsBuilder<HospitalContext>()
        .UseMongoDB(mongoOptions)
        .Options,
    ssnDataKeyId,
    dobDataKeyId);
context.Database.EnsureCreated();
context.Patients.Add(new Patient
{
    Name = "John Doe",
    SSN = "123-45-6789",
    DateOfBirth = new DateTime(1985, 6, 15)
});
context.SaveChanges();
var results = context.Patients
    .Where(p => p.DateOfBirth > new DateTime(1980, 1, 1))
    .ToList();

Soporte de esquemas del lado del servidor

Por defecto, el proveedor de EF Core aplica la configuración de cifrado de campo solo al cliente. El cifrado solo para clientes es adecuado durante el desarrollo, cuando el esquema de cifrado aún puede estar evolucionando.

Para las implementaciones de producción, registre el esquema de cifrado en el servidor cuando cree la colección. Una vez que el servidor contiene el esquema, aplica el cifrado independientemente de la configuración del cliente, lo que protege contra escrituras de texto sin formato accidentales de clientes mal configurados. Después de registrar el esquema en el servidor, no puede cambiar qué campos se cifran sin volver a crear la colección.

Para crear una colección con un esquema del lado del servidor, pase el Model de su contexto a QueryableEncryptionSchemaGenerator.GenerateSchemas(). Luego, pase el resultado al método CreateCollection(), como se muestra en el siguiente ejemplo:

var encryptedSchemas =
    QueryableEncryptionSchemaGenerator.GenerateSchemas(
        context.Model);
using var client = new MongoClient(
    "<connection string URI>");
var database = client.GetDatabase("hospitalDb");
foreach (var entityType in context.Model
    .GetEntityTypes()
    .Where(e => e.IsDocumentRoot()))
{
    var collectionName = entityType.GetCollectionName();
    if (encryptedSchemas.TryGetValue(
            collectionName, out var schema))
    {
        database.CreateCollection(
            collectionName,
            new CreateCollectionOptions
            {
                EncryptedFields = schema
            });
    }
}
context.Database.EnsureCreated();

Una vez que la colección cifrada exista en el servidor, puede configurar nuevas instancias de contexto para usar solo el esquema del servidor. Establezca QueryableEncryptionSchemaMode.Ignore en el MongoOptionsExtension, como se muestra en el siguiente ejemplo:

var mongoOptions = new MongoOptionsExtension()
    .WithConnectionString("<connection string URI>")
    .WithDatabaseName("hospitalDb")
    .WithKmsProviders(kmsProviders)
    .WithKeyVaultNamespace(keyVaultNamespace)
    .WithCryptProvider(
        CryptProvider.AutoEncryptSharedLibrary,
        Environment.GetEnvironmentVariable("CRYPT_SHARED_LIB_PATH"))
    .WithQueryableEncryptionSchemaMode(
        QueryableEncryptionSchemaMode.Ignore);

En el modo Ignore, cualquier configuración IsEncrypted en el método OnModelCreating() no tiene ningún efecto en el cifrado. El esquema del servidor controla qué campos están cifrados.

Información Adicional

Para obtener más información sobre Queryable Encryption, vea las secciones Queryable Encryption y Casos de uso de Queryable Encryption en el manual de MongoDB Server.

Para obtener detalles completos de la implementación, consulte la documentación de la API del proveedor de EF Core.