Utilice el cifrado automático a nivel de campo del lado del cliente con GCP

Registrar una cuenta de servicio de GCP

1. Regístrese o inicie sesión en su cuenta existente en Google Cloud.

2. Crea una cuenta de servicio para tu proyecto

   Para crear una cuenta de servicio en Google Cloud, siga la guía Creación de una cuenta de servicio en la documentación oficial de Google.

3. Agregar una clave de cuenta de servicio

   Para agregar una clave de cuenta de servicio en Google Cloud, siga la guía Administrar claves de cuenta de servicio en la documentación oficial de Google.

   C#

   Go

   Java (Sync)

   Node.js

   Python

   Importante

   Al crear la clave de su cuenta de servicio, recibirá una descarga única de la información de la clave privada. Asegúrese de descargar este archivo en formato PKCS12 o JSON para usarlo más adelante en este tutorial.

   Importante

   Al crear la clave de su cuenta de servicio, recibirá una descarga única de la información de la clave privada. Asegúrese de descargar este archivo en formato PKCS12 o JSON para usarlo más adelante en este tutorial.

   Importante

   Al crear la clave de su cuenta de servicio, recibirá una descarga única de la información de la clave privada. A menos que utilice una cuenta de servicio asociada, asegúrese de descargar este archivo en formato PKCS12 o JSON para usarlo más adelante en este tutorial.

   Importante

   Al crear la clave de su cuenta de servicio, recibirá una descarga única de la información de la clave privada. Asegúrese de descargar este archivo en formato PKCS12 o JSON para usarlo más adelante en este tutorial.

   Importante

   Al crear la clave de su cuenta de servicio, recibirá una descarga única de la información de la clave privada. Asegúrese de descargar este archivo en formato PKCS12 o JSON para usarlo más adelante en este tutorial.

Crear una clave maestra de cliente de GCP

1. Crear una nueva clave maestra de cliente

   Crea un llavero y una llave simétrica siguiendo la guía Crear una llave de la documentación oficial de Google.

   Esta clave es su clave maestra de cliente(CMK).

   Registre los siguientes detalles de su CMK para usarlos en un paso futuro de este tutorial.

   Campo	Requerido	Descripción
   key_name	Sí	Identificador para el CMK.
   llavero	Sí	Identificador del grupo de claves al que pertenece su clave.
   key_version	No	La versión de la clave nombrada.
   ubicación	Sí	Región especificada para tu clave.
   punto final	No	El host y el puerto opcional de Google Cloud KMS. El valor predeterminado es cloudkms.googleapis.com.

Cree un índice único en su colección de Key Vault

Cree un índice único en el campo keyAltNames en su espacio de nombres encryption.__keyVault.

Seleccione la pestaña correspondiente a su controlador MongoDB preferido:

var connectionString = "<Your MongoDB URI>";
var keyVaultNamespace = CollectionNamespace.FromFullName("encryption.__keyVault");
var keyVaultClient = new MongoClient(connectionString);
var indexOptions = new CreateIndexOptions<BsonDocument>();
indexOptions.Unique = true;
indexOptions.PartialFilterExpression = new BsonDocument { { "keyAltNames", new BsonDocument { { "$exists", new BsonBoolean(true) } } } };
var builder = Builders<BsonDocument>.IndexKeys;
var indexKeysDocument = builder.Ascending("keyAltNames");
var indexModel = new CreateIndexModel<BsonDocument>(indexKeysDocument, indexOptions);
var keyVaultDatabase = keyVaultClient.GetDatabase(keyVaultNamespace.DatabaseNamespace.ToString());
// Drop the Key Vault Collection in case you created this collection
// in a previous run of this application.  
keyVaultDatabase.DropCollection(keyVaultNamespace.CollectionName);
// Drop the database storing your encrypted fields as all
// the DEKs encrypting those fields were deleted in the preceding line.
keyVaultClient.GetDatabase("medicalRecords").DropCollection("patients");
var keyVaultCollection = keyVaultDatabase.GetCollection<BsonDocument>(keyVaultNamespace.CollectionName.ToString());
keyVaultCollection.Indexes.CreateOne(indexModel);

uri := "<Your MongoDB URI>"
keyVaultClient, err := mongo.Connect(options.Client().ApplyURI(uri))
if err != nil {
	return fmt.Errorf("Connect error for regular client: %v", err)
}
defer func() {
	_ = keyVaultClient.Disconnect(context.TODO())
}()
keyVaultColl := "__keyVault"
keyVaultDb := "encryption"
keyVaultNamespace := keyVaultDb + "." + keyVaultColl
keyVaultIndex := mongo.IndexModel{
	Keys: bson.D{{"keyAltNames", 1}},
	Options: options.Index().
		SetUnique(true).
		SetPartialFilterExpression(bson.D{
			{"keyAltNames", bson.D{
				{"$exists", true},
			}},
		}),
}
// Drop the Key Vault Collection in case you created this collection
// in a previous run of this application.
if err = keyVaultClient.Database(keyVaultDb).Collection(keyVaultColl).Drop(context.TODO()); err != nil {
	log.Fatalf("Collection.Drop error: %v", err)
}
// Drop the database storing your encrypted fields as all
// the DEKs encrypting those fields were deleted in the preceding line.
if err = keyVaultClient.Database("medicalRecords").Collection("patients").Drop(context.TODO()); err != nil {
	log.Fatalf("Collection.Drop error: %v", err)
}
_, err = keyVaultClient.Database(keyVaultDb).Collection(keyVaultColl).Indexes().CreateOne(context.TODO(), keyVaultIndex)
if err != nil {
	panic(err)
}

String connectionString = "<Your MongoDB URI>";
String keyVaultDb = "encryption";
String keyVaultColl = "__keyVault";
String keyVaultNamespace = keyVaultDb + "." + keyVaultColl;
MongoClient keyVaultClient = MongoClients.create(connectionString);
// Drop the Key Vault Collection in case you created this collection
// in a previous run of this application.
keyVaultClient.getDatabase(keyVaultDb).getCollection(keyVaultColl).drop();
// Drop the database storing your encrypted fields as all
// the DEKs encrypting those fields were deleted in the preceding line.
keyVaultClient.getDatabase("medicalRecords").getCollection("patients").drop();
MongoCollection keyVaultCollection = keyVaultClient.getDatabase(keyVaultDb).getCollection(keyVaultColl);
IndexOptions indexOpts = new IndexOptions().partialFilterExpression(new BsonDocument("keyAltNames", new BsonDocument("$exists", new BsonBoolean(true) ))).unique(true);
keyVaultCollection.createIndex(new BsonDocument("keyAltNames", new BsonInt32(1)), indexOpts);
keyVaultClient.close();

const uri = "<Your Connection String>";
const keyVaultDatabase = "encryption";
const keyVaultCollection = "__keyVault";
const keyVaultNamespace = `${keyVaultDatabase}.${keyVaultCollection}`;
const keyVaultClient = new MongoClient(uri);
await keyVaultClient.connect();
const keyVaultDB = keyVaultClient.db(keyVaultDatabase);
// Drop the Key Vault Collection in case you created this collection
// in a previous run of this application.
await keyVaultDB.dropDatabase();
// Drop the database storing your encrypted fields as all
// the DEKs encrypting those fields were deleted in the preceding line.
await keyVaultClient.db("medicalRecords").dropDatabase();
const keyVaultColl = keyVaultDB.collection(keyVaultCollection);
await keyVaultColl.createIndex(
  { keyAltNames: 1 },
  {
    unique: true,
    partialFilterExpression: { keyAltNames: { $exists: true } },
  }
);

connection_string = "<your connection string here>"
key_vault_coll = "__keyVault"
key_vault_db = "encryption"
key_vault_namespace = f"{key_vault_db}.{key_vault_coll}"
key_vault_client = MongoClient(connection_string)
# Drop the Key Vault Collection in case you created this collection
# in a previous run of this application.
key_vault_client.drop_database(key_vault_db)
# Drop the database storing your encrypted fields as all
# the DEKs encrypting those fields were deleted in the preceding line.
key_vault_client["medicalRecords"].drop_collection("patients")
key_vault_client[key_vault_db][key_vault_coll].create_index(
    [("keyAltNames", ASCENDING)],
    unique=True,
    partialFilterExpression={"keyAltNames": {"$exists": True}},
)

Crear una llave de cifrado de datos

1. Agregue sus credenciales de GCP KMS

   C#

   Go

   Java (Sync)

   Node.js

   Python

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   var kmsProviderCredentials = new Dictionary<string, IReadOnlyDictionary<string, object>>();
   var provider = "gcp";
   var gcpKmsOptions = new Dictionary<string, object>
   {
      { "privateKey", "<Your GCP Private Key>" },
      { "email", "<Your GCP Email>" },
   };
   kmsProviderCredentials.Add(provider, gcpKmsOptions);

   También puede proporcionar un nombre personalizado para su proveedor de KMS. Para ello, introduzca una cadena que incluya el nombre del proveedor, seguido de dos puntos y el nombre personalizado. Al proporcionar un nombre único para un proveedor de KMS, podrá especificar varios proveedores del mismo tipo.

   Por ejemplo, puede nombrar su proveedor de KMS de GCP "my_gcp_provider" en su variable de credenciales de KMS como se muestra en el siguiente código:

   var kmsProviderCredentials = new Dictionary<string, IReadOnlyDictionary<string, object>>();
   var kmsOptions = new Dictionary<string, object>
   {
       { "email", _appSettings["Gcp:Email"] }, // Your GCP email
       { "privateKey", _appSettings["Gcp:PrivateKey"] } // Your GCP private key
   };
   kmsProviderCredentials.Add("gcp:my_gcp_provider", kmsOptions);

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   provider := "gcp"
   kmsProviders := map[string]map[string]interface{}{
   	provider: {
   		"email":      "<Your GCP Email>",
   		"privateKey": "<Your GCP Private Key>",
   	},
   }

   Tip

   Cuenta de servicio adjunta

   Si está utilizando una cuenta de servicio adjunta, puede permitir que la autentique automáticamente en su GCP KMS.

   Para autenticarse automáticamente, asigne un mapa vacío en lugar de uno que contenga sus credenciales de GCP, como se muestra en el siguiente código:

   String kmsProvider = "gcp";
   Map<String, Map<String, Object>> kmsProviders = new HashMap<String, Map<String, Object>>();
   Map<String, Object> providerDetails = new HashMap<>();
   kmsProviders.put(kmsProvider, providerDetails);

   Continúe con el siguiente paso de la guía después de agregar este código.

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   String kmsProvider = "gcp";
   Map<String, Map<String, Object>> kmsProviderDetails = new HashMap<String, Map<String, Object>>();
   Map<String, Object> providerDetails = new HashMap<>();
   providerDetails.put("email", "<Your GCP Email Address>");
   providerDetails.put("privateKey", "<Your GCP Private Key>");
   kmsProviderDetails.put(kmsProvider, providerDetails);

   También puede proporcionar un nombre personalizado para su proveedor de KMS. Para ello, introduzca una cadena que incluya el nombre del proveedor, seguido de dos puntos y el nombre personalizado. Al proporcionar un nombre único para un proveedor de KMS, podrá especificar varios proveedores del mismo tipo.

   Por ejemplo, puede nombrar su proveedor de KMS de GCP "my_gcp_provider" en su variable de credenciales de KMS como se muestra en el siguiente código:

   Map<String, Object> kmsProviderDetails = new HashMap<>();
   kmsProviderDetails.put("email", getEnv("GCP_EMAIL")); // Your GCP email
   kmsProviderDetails.put("privateKey", getEnv("GCP_PRIVATE_KEY")); // Your GCP private key
   Map<String, Map<String, Object>> kmsProviderCredentials = new HashMap<String, Map<String, Object>>();
   kmsProviderCredentials.put("gcp:my_gcp_provider", kmsProviderDetails);

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   const provider = "gcp";
   const kmsProviderCredentials = {
     gcp: {
       email: "<Your GCP Email>",
       privateKey: "<Your GCP Private Key>",
     },
   };

   También puede proporcionar un nombre personalizado para su proveedor de KMS. Para ello, introduzca una cadena que incluya el nombre del proveedor, seguido de dos puntos y el nombre personalizado. Al proporcionar un nombre único para un proveedor de KMS, podrá especificar varios proveedores del mismo tipo.

   Por ejemplo, puede nombrar su proveedor de KMS de GCP "my_gcp_provider" en su variable de credenciales de KMS como se muestra en el siguiente código:

   kmsProviders = {
     "gcp:my_gcp_provider": {
       email: process.env.GCP_EMAIL, // Your GCP email
       privateKey: process.env.GCP_PRIVATE_KEY, // Your GCP private key
     },
   };

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   provider = "gcp"
   kms_provider_credentials = {
       provider: {"email": "<your GCP email>", "privateKey": "<your GCP private key>"}
   }

   También puede proporcionar un nombre personalizado para su proveedor de KMS. Para ello, introduzca una cadena que incluya el nombre del proveedor, seguido de dos puntos y el nombre personalizado. Al proporcionar un nombre único para un proveedor de KMS, podrá especificar varios proveedores del mismo tipo.

   Por ejemplo, puede nombrar su proveedor de KMS de GCP "my_gcp_provider" en su variable de credenciales de KMS como se muestra en el siguiente código:

   kms_provider_credentials = {
       "gcp:my_gcp_provider": {
           "email": os.environ['GCP_EMAIL'], # Your GCP email
           "privateKey": os.environ['GCP_PRIVATE_KEY'] # Your GCP private key
       }
   }

   Tip

   Guardó un archivo que contiene las credenciales de la clave de su cuenta de servicio en el paso Crear una cuenta de servicio de GCP de esta guía.

   Si descargó sus credenciales en formato JSON, puede usar el siguiente comando para extraer el valor de su clave privada, sustituyendo <credentials-filename> por el nombre de su archivo de credenciales. El siguiente comando requiere la instalación de OpenSSL:

   cat <credentials-filename> | jq -r .private_key | openssl pkcs8 -topk8 -nocrypt -inform PEM -outform DER | base64

   Si descargó sus credenciales en formato PKCS12, debe especificar la contraseña de importación de su cuenta de servicio de GCP y agregar una frase de contraseña PEM para acceder a la clave cuando acceda a ella mediante el siguiente comando, sustituyendo <credentials-filename> con el nombre de su archivo de credenciales:

   openssl pkcs12 -info -in <credentials-filename>

2. Agregue su información clave

   Actualice el siguiente código para especificar su clave maestra de cliente:

   Tip

   Registró los detalles de su clave maestra de cliente en el paso Crear una clave maestra de cliente de esta guía.

   C#

   Go

   Java (Sync)

   Node.js

   Python

   var dataKeyOptions = new DataKeyOptions(
      masterKey: new BsonDocument
      {
          { "projectId", "Your GCP Project ID" },
          { "location", "Your GCP Key Location" } ,
          { "keyRing", "<Your GCP Key Ring>" },
          { "keyName", "<Your GCP Key Name>" },
      });

   masterKey := map[string]interface{}{
   	"projectId": "<Your GCP Project ID>",
   	"location":  "<Your GCP Location>",
   	"keyRing":   "<Your GCP Key Ring>",
   	"keyName":   "<Your GCP Key Name>",
   }

   BsonDocument masterKeyProperties = new BsonDocument();
   masterKeyProperties.put("provider", new BsonString(kmsProvider));
   masterKeyProperties.put("projectId", new BsonString("<Your GCP Project ID>"));
   masterKeyProperties.put("location", new BsonString("<Your GCP Key Location>"));
   masterKeyProperties.put("keyRing", new BsonString("<Your GCP Key Ring>"));
   masterKeyProperties.put("keyName", new BsonString("<Your GCP Key Name>"));

   const masterKey = {
     projectId: "<Your Project ID>",
     location: "<Your Key Location>",
     keyRing: "<Your Key Ring>",
     keyName: "<Your Key Name>",
   };

   master_key = {
       "projectId": "<GCP project identifier>",
       "location": "<GCP region>",
       "keyRing": "<GCP key ring name>",
       "keyName": "<GCP key name>",
   }

3. Genere su clave de cifrado de datos

   Genere su clave de cifrado de datos utilizando las variables declaradas en el paso uno de este tutorial.

   C#

   Go

   Java (Sync)

   Node.js

   Python

   var clientEncryptionOptions = new ClientEncryptionOptions(
       keyVaultClient: keyVaultClient,
       keyVaultNamespace: keyVaultNamespace,
       kmsProviders: kmsProviderCredentials
       );
   var clientEncryption = new ClientEncryption(clientEncryptionOptions);
   var dataKeyId = clientEncryption.CreateDataKey(provider, dataKeyOptions, CancellationToken.None);
   var dataKeyIdBase64 = Convert.ToBase64String(GuidConverter.ToBytes(dataKeyId, GuidRepresentation.Standard));
   Console.WriteLine($"DataKeyId [base64]: {dataKeyIdBase64}");

   clientEncryptionOpts := options.ClientEncryption().SetKeyVaultNamespace(keyVaultNamespace).
   	SetKmsProviders(kmsProviders)
   clientEnc, err := mongo.NewClientEncryption(keyVaultClient, clientEncryptionOpts)
   if err != nil {
   	return fmt.Errorf("NewClientEncryption error %v", err)
   }
   defer func() {
   	_ = clientEnc.Close(context.TODO())
   }()
   dataKeyOpts := options.DataKey().
   	SetMasterKey(masterKey)
   dataKeyID, err := clientEnc.CreateDataKey(context.TODO(), provider, dataKeyOpts)
   if err != nil {
   	return fmt.Errorf("create data key error %v", err)
   }
   fmt.Printf("DataKeyId [base64]: %s\n", base64.StdEncoding.EncodeToString(dataKeyID.Data))

   ClientEncryptionSettings clientEncryptionSettings = ClientEncryptionSettings.builder()
           .keyVaultMongoClientSettings(MongoClientSettings.builder()
                   .applyConnectionString(new ConnectionString(connectionString))
                   .build())
           .keyVaultNamespace(keyVaultNamespace)
           .kmsProviders(kmsProviderDetails)
           .build();
   MongoClient regularClient = MongoClients.create(connectionString);
   ClientEncryption clientEncryption = ClientEncryptions.create(clientEncryptionSettings);
   BsonBinary dataKeyId = clientEncryption.createDataKey(kmsProvider, new DataKeyOptions().masterKey(masterKeyProperties));
   String base64DataKeyId = Base64.getEncoder().encodeToString(dataKeyId.getData());
   System.out.println("DataKeyId [base64]: " + base64DataKeyId);
   clientEncryption.close();

   const client = new MongoClient(uri);
   await client.connect();
   const encryption = new ClientEncryption(client, {
     keyVaultNamespace,
     kmsProviderCredentials,
   });
   const key = await encryption.createDataKey(provider, {
     masterKey: masterKey,
   });
   console.log("DataKeyId [base64]: ", key.toString("base64"));
   await keyVaultClient.close();
   await client.close();

   Nota

   Import ClientEncryption

   Al utilizar el controlador Node.js v6.0 y posterior, debe importar ClientEncryption desde mongodb.

   Para versiones anteriores del controlador, importe ClientEncryption desde mongodb-client-encryption.

   key_vault_database = "encryption"
   key_vault_collection = "__keyVault"
   key_vault_namespace = f"{key_vault_database}.{key_vault_collection}"
   client = MongoClient(connection_string)
   client_encryption = ClientEncryption(
       kms_provider_credentials,  # pass in the kms_provider_credentials variable from the previous step
       key_vault_namespace,
       client,
       CodecOptions(uuid_representation=STANDARD),
   )
   data_key_id = client_encryption.create_data_key(provider, master_key)
   base_64_data_key_id = base64.b64encode(data_key_id)
   print("DataKeyId [base64]: ", base_64_data_key_id)

Configurar MongoClient

1. Especifique el espacio de nombres de la colección Key Vault

   Especifique encryption.__keyVault como el espacio de nombres de la colección Key Vault.

   C#

   Go

   Java (Sync)

   Node.js

   Python

   var keyVaultNamespace = CollectionNamespace.FromFullName("encryption.__keyVault");

   keyVaultNamespace := "encryption.__keyVault"

   String keyVaultNamespace = "encryption.__keyVault";

   const keyVaultNamespace = "encryption.__keyVault";

   key_vault_namespace = "encryption.__keyVault"

2. Especifica tus credenciales de cuenta en la nube

   C#

   Go

   Java (Sync)

   Node.js

   Python

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   var kmsProviders = new Dictionary<string, IReadOnlyDictionary<string, object>>();
   var provider = "gcp";
   var gcpKmsOptions = new Dictionary<string, object>
   {
      { "privateKey", "<Your GCP Private Key>" },
      { "email", "<Your GCP Email>" },
   };
   kmsProviders.Add(provider, gcpKmsOptions);

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   kmsProviders := map[string]map[string]interface{}{
   	"gcp": {
   		"email":      "<Your GCP Email>",
   		"privateKey": "<Your GCP Private Key>",
   	},
   }

   Tip

   Cuenta de servicio adjunta

   Si está utilizando una cuenta de servicio adjunta, puede permitir que la autentique automáticamente en su GCP KMS.

   Para autenticarse automáticamente, asigne un mapa vacío en lugar de uno que contenga sus credenciales de GCP, como se muestra en el siguiente código:

   String kmsProvider = "gcp";
   Map<String, Map<String, Object>> kmsProviders = new HashMap<String, Map<String, Object>>();
   Map<String, Object> providerDetails = new HashMap<>();
   kmsProviders.put(kmsProvider, providerDetails);

   Continúe con el siguiente paso de la guía después de agregar este código.

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   String kmsProvider = "gcp";
   Map<String, Map<String, Object>> kmsProviders = new HashMap<String, Map<String, Object>>();
   Map<String, Object> providerDetails = new HashMap<>();
   providerDetails.put("email", "<Your GCP Email Address>");
   providerDetails.put("privateKey", "<Your GCP Private Key>");
   kmsProviders.put(kmsProvider, providerDetails);

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   const kmsProviders = {
     gcp: {
       email: "<Your GCP Email>",
       privateKey: "<Your GCP Private Key>",
     },
   };

   A menos que esté utilizando una cuenta de servicio adjunta, agregue las credenciales de la cuenta de servicio a su cliente habilitado para CSFLE, como se muestra en el siguiente ejemplo de código:

   provider = "gcp"
   kms_providers = {
       "gcp": {"email": "<your GCP email>", "privateKey": "<your GCP private key>"}
   }

3. Cree un esquema de cifrado para su colección

   Tip

   Agregue su ID de base de clave de cifrado de datos64

   Asegúrate de actualizar el siguiente código para incluir tu ID de64 DEK Base. Recibiste este valor en el paso "Generar tu clave de cifrado de datos" de esta guía.

   C#

   Go

   Java (Sync)

   Node.js

   Python

   var keyId = "<Your base64 DEK ID here>";
   var schema = new BsonDocument
   {
      { "bsonType", "object" },
      {
          "encryptMetadata",
          new BsonDocument("keyId", new BsonArray(new[] { new BsonBinaryData(Convert.FromBase64String(keyId), BsonBinarySubType.UuidStandard) }))
      },
      {
          "properties",
          new BsonDocument
          {
              {
                  "ssn", new BsonDocument
                  {
                      {
                          "encrypt", new BsonDocument
                          {
                              { "bsonType", "int" },
                              { "algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" }
                          }
                      }
                  }
              },
              {
                  "bloodType", new BsonDocument
                  {
                      {
                          "encrypt", new BsonDocument
                          {
                              { "bsonType", "string" },
                              { "algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random" }
                          }
                      }
                  }
              },
              {
                  "medicalRecords", new BsonDocument
                  {
                      {
                          "encrypt", new BsonDocument
                          {
                              { "bsonType", "array" },
                              { "algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random" }
                          }
                      }
                  }
              },
              {
                  "insurance", new BsonDocument
                  {
                      { "bsonType", "object" },
                      {
                          "properties", new BsonDocument
                          {
                              {
                                  "policyNumber", new BsonDocument
                                  {
                                      {
                                          "encrypt", new BsonDocument
                                          {
                                              { "bsonType", "int" },
                                              { "algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" }
                                          }
                                      }
                                  }
                              }
                          }
                      }
                  }
              }
          }
      }
   };
   var schemaMap = new Dictionary<string, BsonDocument>();
   schemaMap.Add(dbNamespace, schema);

   dek_id := "<Your Base64 DEK ID>"
   schema_template := `{
   	"bsonType": "object",
   	"encryptMetadata": {
   		"keyId": [
   			{
   				"$binary": {
   					"base64": "%s",
   					"subType": "04"
   				}
   			}
   		]
   	},
   	"properties": {
   		"insurance": {
   			"bsonType": "object",
   			"properties": {
   				"policyNumber": {
   					"encrypt": {
   						"bsonType": "int",
   						"algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
   					}
   				}
   			}
   		},
   		"medicalRecords": {
   			"encrypt": {
   				"bsonType": "array",
   				"algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random"
   			}
   		},
   		"bloodType": {
   			"encrypt": {
   				"bsonType": "string",
   				"algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random"
   			}
   		},
   		"ssn": {
   			"encrypt": {
   				"bsonType": "int",
   				"algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
   			}
   		}
   	}
   }`
   schema := fmt.Sprintf(schema_template, dek_id)
   var schemaDoc bson.Raw
   if err := bson.UnmarshalExtJSON([]byte(schema), true, &schemaDoc); err != nil {
   	return fmt.Errorf("UnmarshalExtJSON error: %v", err)
   }
   schemaMap := map[string]interface{}{
   	dbName + "." + collName: schemaDoc,
   }

   String dekId = "<paste-base-64-encoded-data-encryption-key-id>>";
   Document jsonSchema = new Document().append("bsonType", "object").append("encryptMetadata",
           new Document().append("keyId", new ArrayList<>((Arrays.asList(new Document().append("$binary", new Document()
                   .append("base64", dekId)
                   .append("subType", "04")))))))
           .append("properties", new Document()
                   .append("ssn", new Document().append("encrypt", new Document()
                           .append("bsonType", "int")
                           .append("algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic")))
                   .append("bloodType", new Document().append("encrypt", new Document()
                           .append("bsonType", "string")
                           .append("algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random")))
                   .append("medicalRecords", new Document().append("encrypt", new Document()
                           .append("bsonType", "array")
                           .append("algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random")))
                   .append("insurance", new Document()
                           .append("bsonType", "object")
                           .append("properties",
                                   new Document().append("policyNumber", new Document().append("encrypt", new Document()
                                           .append("bsonType", "int")
                                           .append("algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"))))));
   HashMap<String, BsonDocument> schemaMap = new HashMap<String, BsonDocument>();
   schemaMap.put("medicalRecords.patients", BsonDocument.parse(jsonSchema.toJson()));

   dataKey = "<Your base64 DEK ID>";
   const schema = {
     bsonType: "object",
     encryptMetadata: {
       keyId: [new Binary(Buffer.from(dataKey, "base64"), 4)],
     },
     properties: {
       insurance: {
         bsonType: "object",
         properties: {
           policyNumber: {
             encrypt: {
               bsonType: "int",
               algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
             },
           },
         },
       },
       medicalRecords: {
         encrypt: {
           bsonType: "array",
           algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Random",
         },
       },
       bloodType: {
         encrypt: {
           bsonType: "string",
           algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Random",
         },
       },
       ssn: {
         encrypt: {
           bsonType: "int",
           algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
         },
       },
     },
   };
   var patientSchema = {};
   patientSchema[namespace] = schema;

   dek_id = b"<paste-base-64-encoded-data-encryption-key-id>"
   json_schema = {
       "bsonType": "object",
       "encryptMetadata": {"keyId": [Binary(base64.b64decode(dek_id), UUID_SUBTYPE)]},
       "properties": {
           "insurance": {
               "bsonType": "object",
               "properties": {
                   "policyNumber": {
                       "encrypt": {
                           "bsonType": "int",
                           "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
                       }
                   }
               },
           },
           "medicalRecords": {
               "encrypt": {
                   "bsonType": "array",
                   "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random",
               }
           },
           "bloodType": {
               "encrypt": {
                   "bsonType": "string",
                   "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random",
               }
           },
           "ssn": {
               "encrypt": {
                   "bsonType": "int",
                   "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
               }
           },
       },
   }
   patient_schema = {"medicalRecords.patients": json_schema}

4. Especificar la ubicación de la biblioteca compartida de cifrado automático

   C#

   Go

   Java (Sync)

   Node.js

   Python

   var mongoBinariesPath = "<Full path to your Automatic Encryption Shared Library>";
   var extraOptions = new Dictionary<string, object>()
   {
      { "cryptSharedLibPath", mongoBinariesPath },
   };

   extraOptions := map[string]interface{}{
   	"cryptSharedLibPath": "<Full path to your Automatic Encryption Shared Library>",
   }

   Map<String, Object> extraOptions = new HashMap<String, Object>();
   extraOptions.put("cryptSharedLibPath", "<Full path to your Automatic Encryption Shared Library>"));

   const extraOptions = {
     cryptSharedLibPath: "<Full path to your Automatic Encryption Shared Library>",
   };

   extra_options = {
       "cryptSharedLibPath": "<Full path to your Automatic Encryption Shared Library>"
   }

   Nota

   Opciones de cifrado automático

   Las opciones de cifrado automático proporcionan información de configuración a la biblioteca compartida de cifrado automático, que modifica el comportamiento de la aplicación al acceder a campos cifrados.

   Para obtener más información sobre la biblioteca compartida de cifrado automático, consulte la página Instalar y configurar un componente de análisis de consultas CSFLE.

5. Crear el MongoClient

   Instancia un objeto cliente de MongoDB con la siguiente configuración de cifrado automático que utiliza las variables declaradas en los pasos previos:

   C#

   Go

   Java (Sync)

   Node.js

   Python

   Controlador C# v3.0+

   Controlador de C# < v3.0

   MongoClientSettings.Extensions.AddAutoEncryption(); // .NET/C# Driver v3.0 or later only
   var clientSettings = MongoClientSettings.FromConnectionString(connectionString);
   var autoEncryptionOptions = new AutoEncryptionOptions(
       keyVaultNamespace: keyVaultNamespace,
       kmsProviders: kmsProviders,
       schemaMap: schemaMap,
       extraOptions: extraOptions
       );
   clientSettings.AutoEncryptionOptions = autoEncryptionOptions;
   var secureClient = new MongoClient(clientSettings);

   var clientSettings = MongoClientSettings.FromConnectionString(connectionString);
   var autoEncryptionOptions = new AutoEncryptionOptions(
       keyVaultNamespace: keyVaultNamespace,
       kmsProviders: kmsProviders,
       schemaMap: schemaMap,
       extraOptions: extraOptions
       );
   clientSettings.AutoEncryptionOptions = autoEncryptionOptions;
   var secureClient = new MongoClient(clientSettings);

   autoEncryptionOpts := options.AutoEncryption().
   	SetKmsProviders(kmsProviders).
   	SetKeyVaultNamespace(keyVaultNamespace).
   	SetSchemaMap(schemaMap).
   	SetExtraOptions(extraOptions)
   secureClient, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri).SetAutoEncryptionOptions(autoEncryptionOpts))
   if err != nil {
   	return fmt.Errorf("Connect error for encrypted client: %v", err)
   }
   defer func() {
   	_ = secureClient.Disconnect(context.TODO())
   }()

   MongoClientSettings clientSettings = MongoClientSettings.builder()
       .applyConnectionString(new ConnectionString(connectionString))
       .autoEncryptionSettings(AutoEncryptionSettings.builder()
           .keyVaultNamespace(keyVaultNamespace)
           .kmsProviders(kmsProviders)
           .schemaMap(schemaMap)
           .extraOptions(extraOptions)
           .build())
       .build();
   MongoClient mongoClientSecure = MongoClients.create(clientSettings);

   const secureClient = new MongoClient(connectionString, {
     autoEncryption: {
       keyVaultNamespace,
       kmsProviders,
       schemaMap: patientSchema,
       extraOptions: extraOptions,
     },
   });

   fle_opts = AutoEncryptionOpts(
       kms_providers, key_vault_namespace, schema_map=patient_schema, **extra_options
   )
   secureClient = MongoClient(connection_string, auto_encryption_opts=fle_opts)

Insertar un documento con campos cifrados

Utilice su instancia MongoClient habilitada para CSFLE para insertar un documento con campos cifrados en el espacio de nombres medicalRecords.patients utilizando el siguiente fragmento de código:

var sampleDocFields = new BsonDocument
{
    { "name", "Jon Doe" },
    { "ssn", 145014000 },
    { "bloodType", "AB-" },
    {
        "medicalRecords", new BsonArray
        {
            new BsonDocument("weight", 180),
            new BsonDocument("bloodPressure", "120/80")
        }
    },
    {
        "insurance", new BsonDocument
        {
            { "policyNumber", 123142 },
            { "provider", "MaestCare" }
        }
    }
};
// Construct an auto-encrypting client
var secureCollection = secureClient.GetDatabase(db).GetCollection<BsonDocument>(coll);
// Insert a document into the collection
secureCollection.InsertOne(sampleDocFields);

test_patient := map[string]interface{}{
	"name":      "Jon Doe",
	"ssn":       241014209,
	"bloodType": "AB+",
	"medicalRecords": []map[string]interface{}{{
		"weight":        180,
		"bloodPressure": "120/80",
	}},
	"insurance": map[string]interface{}{
		"provider":     "MaestCare",
		"policyNumber": 123142,
	},
}
if _, err := secureClient.Database(dbName).Collection(collName).InsertOne(context.TODO(), test_patient); err != nil {
	return fmt.Errorf("InsertOne error: %v", err)
}

ArrayList<Document> medicalRecords = new ArrayList<>();
medicalRecords.add(new Document().append("weight", "180"));
medicalRecords.add(new Document().append("bloodPressure", "120/80"));
Document insurance = new Document()
.append("policyNumber", 123142)
.append("provider",  "MaestCare");
Document patient = new Document()
    .append("name", "Jon Doe")
    .append("ssn", 241014209)
    .append("bloodType", "AB+")
    .append("medicalRecords", medicalRecords)
    .append("insurance", insurance);
mongoClientSecure.getDatabase(recordsDb).getCollection(recordsColl).insertOne(patient);

try {
  const writeResult = await secureClient
    .db(db)
    .collection(coll)
    .insertOne({
      name: "Jon Doe",
      ssn: 241014209,
      bloodType: "AB+",
      medicalRecords: [{ weight: 180, bloodPressure: "120/80" }],
      insurance: {
        policyNumber: 123142,
        provider: "MaestCare",
      },
    });
} catch (writeError) {
  console.error("writeError occurred:", writeError);
}

def insert_patient(
    collection, name, ssn, blood_type, medical_records, policy_number, provider
):
    insurance = {"policyNumber": policy_number, "provider": provider}
    doc = {
        "name": name,
        "ssn": ssn,
        "bloodType": blood_type,
        "medicalRecords": medical_records,
        "insurance": insurance,
    }
    collection.insert_one(doc)
medical_record = [{"weight": 180, "bloodPressure": "120/80"}]
insert_patient(
    secureClient.medicalRecords.patients,
    "Jon Doe",
    241014209,
    "AB+",
    medical_record,
    123142,
    "MaestCare",
)

Cuando inserta un documento, su cliente compatible con CSFLE cifra los campos de su documento de forma que se parece a lo siguiente:

{
  "_id": { "$oid": "<_id of your document>" },
  "name": "Jon Doe",
  "ssn": {
    "$binary": "<cipher-text>",
    "$type": "6"
  },
  "bloodType": {
    "$binary": "<cipher-text>",
    "$type": "6"
  },
  "medicalRecords": {
    "$binary": "<cipher-text>",
    "$type": "6"
  },
  "insurance": {
    "provider": "MaestCare",
    "policyNumber": {
      "$binary": "<cipher-text>",
      "$type": "6"
    }
  }
}

Recupere su documento con campos cifrados

Recupere el documento con campos cifrados que insertó en el paso Insertar un documento con campos cifrados de esta guía.

Para mostrar la funcionalidad de CSFLE, el siguiente fragmento de código consulta su documento con un cliente configurado para CSFLE automático, así como con un cliente que no está configurado para CSFLE automático.

Console.WriteLine("Finding a document with regular (non-encrypted) client.");
var filter = Builders<BsonDocument>.Filter.Eq("name", "Jon Doe");
var regularResult = regularCollection.Find(filter).Limit(1).ToList()[0];
Console.WriteLine($"\n{regularResult}\n");
Console.WriteLine("Finding a document with encrypted client");
var ssnFilter = Builders<BsonDocument>.Filter.Eq("name", "Jon Doe");
var secureResult = secureCollection.Find(ssnFilter).Limit(1).First();
Console.WriteLine($"\n{secureResult}\n");

fmt.Println("Finding a document with regular (non-encrypted) client.")
var resultRegular bson.M
err = regularClient.Database(dbName).Collection(collName).FindOne(context.TODO(), bson.D{{"name", "Jon Doe"}}).Decode(&resultRegular)
if err != nil {
	panic(err)
}
outputRegular, err := json.MarshalIndent(resultRegular, "", "    ")
if err != nil {
	panic(err)
}
fmt.Printf("%s\n", outputRegular)
fmt.Println("Finding a document with encrypted client")
var resultSecure bson.M
err = secureClient.Database(dbName).Collection(collName).FindOne(context.TODO(), bson.D{{"name", "Jon Doe"}}).Decode(&resultSecure)
if err != nil {
	panic(err)
}
outputSecure, err := json.MarshalIndent(resultSecure, "", "    ")
if err != nil {
	panic(err)
}
fmt.Printf("%s\n", outputSecure)

System.out.println("Finding a document with regular (non-encrypted) client.");
Document docRegular = mongoClientRegular.getDatabase(recordsDb).getCollection(recordsColl).find(eq("name", "Jon Doe")).first();
System.out.println(docRegular.toJson());
System.out.println("Finding a document with encrypted client");
Document docSecure = mongoClientSecure.getDatabase(recordsDb).getCollection(recordsColl).find(eq("name", "Jon Doe")).first();
System.out.println(docSecure.toJson());

console.log("Finding a document with regular (non-encrypted) client.");
console.log(
  await regularClient.db(db).collection(coll).findOne({ name: /Jon/ })
);
console.log("Finding a document with encrypted client");
console.log(
  await secureClient.db(db).collection(coll).findOne({ name: /Jon/ })
);

print("Finding a document with regular (non-encrypted) client.")
result = regularClient.medicalRecords.patients.find_one({"name": "Jon Doe"})
pprint.pprint(result)
print("Finding a document with encrypted client")
pprint.pprint(secureClient.medicalRecords.patients.find_one({"name": "Jon Doe"}))

La salida del fragmento de código anterior debería verse así:

Finding a document with regular (non-encrypted) client.
{
  _id: new ObjectId("629a452e0861b3130887103a"),
  name: 'Jon Doe',
  ssn: new Binary(Buffer.from("0217482732d8014cdd9ffdd6e2966e5e7910c20697e5f4fa95710aafc9153f0a3dc769c8a132a604b468732ff1f4d8349ded3244b59cbfb41444a210f28b21ea1b6c737508d9d30e8baa30c1d8070c4d5e26", "hex"), 6),
  bloodType: new Binary(Buffer.from("0217482732d8014cdd9ffdd6e2966e5e79022e238536dfd8caadb4d7751ac940e0f195addd7e5c67b61022d02faa90283ab69e02303c7e4001d1996128428bf037dea8bbf59fbb20c583cbcff2bf3e2519b4", "hex"), 6),
  'key-id': 'demo-data-key',
  medicalRecords: new Binary(Buffer.from("0217482732d8014cdd9ffdd6e2966e5e790405163a3207cff175455106f57eef14e5610c49a99bcbd14a7db9c5284e45e3ee30c149354015f941440bf54725d6492fb3b8704bc7c411cff6c868e4e13c58233c3d5ed9593eca4e4d027d76d3705b6d1f3b3c9e2ceee195fd944b553eb27eee69e5e67c338f146f8445995664980bf0", "hex"), 6),
  insurance: {
    policyNumber: new Binary(Buffer.from("0217482732d8014cdd9ffdd6e2966e5e79108decd85c05be3fec099e015f9d26d9234605dc959cc1a19b63072f7ffda99db38c7b487de0572a03b2139ac3ee163bcc40c8508f366ce92a5dd36e38b3c742f7", "hex"), 6),
    provider: 'MaestCare'
  }
}
Finding a document with encrypted client
{
  _id: new ObjectId("629a452e0861b3130887103a"),
  name: 'Jon Doe',
  ssn: 241014209,
  bloodType: 'AB+',
  'key-id': 'demo-data-key',
  medicalRecords: [ { weight: 180, bloodPressure: '120/80' } ],
  insurance: { policyNumber: 123142, provider: 'MaestCare' }
}