/ /

Fundamentals

Docs Home

/ /

Crear un esquema de cifrado

Acerca de esta tarea

Para que los campos cifrados sean consultables, crea un esquema de cifrado. Este esquema define qué campos se pueden query y qué tipos de queries están permitidos. Para obtener más información, consulte Campos cifrados y consultas activadas.

Importante

Queryable Encryption supports equality, range, prefix, suffix, and substring queries. You can configure a field for only one of the equality or range query types. You can enable both prefix and suffix on the same field, but you can't combine substring with another query type.

Antes de comenzar

Cuando hagas que los campos cifrados sean consultables, considera el rendimiento y la seguridad. Para obtener detalles sobre cómo cada opción de configuración afecta a estos, consulta Configura los campos cifrados para una búsqueda y almacenamiento óptimos.

Para calcular el espacio de almacenamiento que requieren las consultas de prefijo, sufijo y subcadena antes de configurarlas, consulte Estimar el impacto en el almacenamiento del cifrado consultable.

Referencia de campo

Puedes configurar el cifrado para cada campo en el arreglo fields de tu encryptedFieldsObject. La siguiente tabla describe los subcampos disponibles:

Campo	Tipo	Descripción
`path`	String	Requerido. La ruta de notación de puntos al campo a cifrar, como `"patientInfo.ssn"`. Puedes especificar cualquier campo excepto el campo `_id`.
`bsonType`	String	Obligatorio. El tipo BSON del campo que se va a cifrar. Para obtener una lista completa de los tipos compatibles, consulte Tipos BSON.
`keyId`	UUID	Opcional. El UUID de la DEK que se utilizará para cifrar este campo. El UUID es un elemento de datos binarios BSON del subtipo `4`. Los ID de clave deben ser únicos. Especificar un `keyId` que ya está en uso devuelve un error. Si se omite, puedes utilizar el método asistente `createEncryptedCollection()` para crear claves automáticamente.
`queries`	Objeto	opcional. Permite consultas sobre este campo cifrado. Si se omite, el campo se cifra pero no se puede consultar. Para obtener más información sobre las opciones de query, consulta Configura campos cifrados para una búsqueda y almacenamiento óptimos.

Pasos

Crear el esquema de cifrado.

Incluye un encryptedFieldsObject con un fields arreglo:

const encryptedFieldsObject = {
   fields: []
}

Especifica los campos a cifrar.

Agregue las cadenas path y bsonType a un documento dentro del arreglo de campos:
```
const encryptedFieldsObject = {
   fields: [
      {
         path: "myDocumentField",
         bsonType: "int"
      }
   ]
}
```
Importante
Puedes especificar cualquier campo para el cifrado excepto el campo _id.
Opcionalmente, configura un campo keyId con el ID DEK.
Importante
Los ID de clave deben ser únicos, de lo contrario, el servidor devuelve un error.
Al configurar AutoEncryptionSettings en el cliente, puedes utilizar el método asistente createEncryptedCollection para crear claves automáticamente.
```
{
   path: "myDocumentField",
   bsonType: "int",
   keyId: "<unique data encryption key>"
}
```

Habilite las consultas de igualdad en los campos deseados.

Esto permite consultar con los operadores $eq, $ne, $in y $nin.

Agrega el objeto queries y establece queryType en "equality":

{
   path: "myDocumentField",
   bsonType: "int",
   queries: { queryType: "equality" }
}

Habilita consultas de rango en los campos deseados.

Esto permite consultar con los operadores $lt, $lte, $gt y $gte.

Para obtener detalles sobre cómo las siguientes opciones afectan la seguridad y el rendimiento, consulte Configurar campos cifrados para una búsqueda y almacenamiento óptimos.

Agrega el objeto queries y establece queryType en "range":
```
{
   path: "myDocumentRangeField",
   bsonType: "int",
   queries: { queryType: "range" }
}
```

Configura los siguientes campos:

Campo	Tipo	Descripción
mínidad y maximidad	Igual que campo `bsonType`	Obligatorio si `bsonType` es `decimal` o `double`. Opcional pero muy recomendable si es `int`, `long` o `date`. Por defecto, se establecen en los valores mínimos y máximos del `bsonType`. Cuando sea posible, especificar límites en una query mejora el rendimiento. Si consulta valores fuera de estos límites inclusivos, MongoDB devuelve un error.

{
   path: "myDocumentRangeField",
   bsonType: "int",
   queries: { queryType: "range",
              min: 0,
              max: 1200
   }
}

Activa las consultas de prefijos, sufijos o subcadenas en los campos deseados.

Estos tipos de consultas son solo para campos string. Puedes habilitar tanto prefix como suffix en el mismo campo, pero no puedes habilitar ninguno si usas substring.

prefix las consultas habilitan las expresiones de agregación de $encStrStartsWith y $encStrNormalizedEq.
suffix las consultas habilitan las expresiones de agregación de $encStrEndsWith y $encStrNormalizedEq.
substring las consultas habilitan las expresiones de agregación de $encStrContains y $encStrNormalizedEq.

Agrega el objeto queries y define queryType como "prefix", "suffix" o "substring":
```
{
   path: "myDocumentStringField",
   bsonType: "string",
   queries: { queryType: "substring" }
}
```

Configura los siguientes campos.

Para obtener detalles sobre cómo afectan la seguridad y el rendimiento, consulta Configurar campos cifrados para búsqueda y almacenamiento óptimos.

Campo	Tipo	Descripción
`strMaxLength`	entero	`substring` solo queries. La longitud máxima permitida para un campo indexado por subcadena.
`strMinQueryLength`	entero	La longitud mínima permitida de prefijo/sufijo/subcadena para query.
`strMaxQueryLength`	entero	La longitud máxima permitida de prefijo/sufijo/subcadena para query. IMPORTANTE: Este ajuste tiene un gran impacto en el rendimiento de las query. Limítalo siempre que sea posible.
`caseSensitive`	Booleano	opcional. Si las consultas distinguen entre mayúsculas y minúsculas. Por defecto `true`.
`diacriticSensitive`	Booleano	opcional. Si las búsquedas son sensibles a los signos diacríticos. Por defecto `true`.

{
   path: "myDocumentStringField",
   bsonType: "string",
   queries: {
      "queryType": "substring",
      "strMaxLength": 30,
      "strMinQueryLength": 1,
      "strMaxQueryLength": 20,
      "caseSensitive": false
   }
}

Ejemplo

Este ejemplo muestra cómo crear un esquema de cifrado para datos hospitalarios.

Considere el siguiente documento que contiene información de identidad personal (PII), información de tarjetas de crédito e información médica sensible:

{
   "firstName": "Jon",
   "lastName": "Snow",
   "patientId": 12345187,
   "address": "123 Cherry Ave",
   "medications": [
      "Adderall",
      "Lipitor"
   ],
   "patientInfo": {
      "ssn": "921-12-1234",
      "billing": {
            "type": "visa",
            "number": "1234-1234-1234-1234"
      }
   }
}

Para garantizar que la información médica confidencial y los datos personales identificables permanezcan seguros, este esquema de cifrado añade los campos relevantes:

const encryptedFieldsObject = {
   fields: [
      {
         path: "patientId",
         bsonType: "int"
      },
      {
         path: "patientInfo.ssn",
         bsonType: "string"
      },
      {
         path: "medications",
         bsonType: "array"
      },
      {
         path: "patientInfo.billing",
         bsonType: "object"
      }
   ]
}

Añadir la propiedad queries hace que los campos patientId y patientInfo.ssn sean consultables. Este ejemplo permite consultas de igualdad:

const encryptedFieldsObject = {
   fields: [
      {
         path: "patientId",
         bsonType: "int",
         queries: { queryType: "equality" }
      },
      {
         path: "patientInfo.ssn",
         bsonType: "string",
         queries: { queryType: "equality" }
      },
      {
         path: "medications",
         bsonType: "array"
      },
      {
         path: "patientInfo.billing",
         bsonType: "object"
      },
   ]
}

Volver

Estimar el impacto del almacenamiento

Cifrar colecciones al crearlas