Use o Queryable Encryption com o KMIP

kmsProviderCredentials = {  kmip: {    endpoint: process.env["KMIP_KMS_ENDPOINT"], // Your KMIP KMS endpoint  },};

var kmsProviderCredentials = new Dictionary<string, IReadOnlyDictionary<string, object>>();var kmsOptions = new Dictionary<string, object>{    { "endpoint", _appSettings["Kmip:KmsEndpoint"] } // Your KMIP KMS endpoint};kmsProviderCredentials.Add(kmsProvider, kmsOptions);

kmsProviderCredentials := map[string]map[string]interface{}{	"kmip": {		"endpoint": os.Getenv("KMIP_KMS_ENDPOINT"), // KMIP KMS endpoint	},}

Map<String, Object> kmsProviderDetails = new HashMap<>();kmsProviderDetails.put("endpoint", getEnv("KMIP_KMS_ENDPOINT")); // Your KMIP KMS endpoint
Map<String, Map<String, Object>> kmsProviderCredentials = new HashMap<String, Map<String, Object>>();kmsProviderCredentials.put("kmip", kmsProviderDetails);

kmsProviders = {  kmip: {    endpoint: process.env.KMIP_KMS_ENDPOINT, // Your KMIP KMS endpoint  },};

kms_provider_credentials = {    "kmip": {        "endpoint": os.environ['KMIP_KMS_ENDPOINT'] # Your KMIP KMS endpoint    }}

customerMasterKeyCredentials = {};

var customerMasterKeyCredentials = new BsonDocument();

customerMasterKey := map[string]string{}

BsonDocument customerMasterKeyCredentials = new BsonDocument();

customerMasterKeyCredentials = {};

customer_master_key_credentials = {}

const autoEncryptionOptions = {  keyVaultNamespace: keyVaultNamespace,  kmsProviders: kmsProviderCredentials,  tlsOptions,};

var extraOptions = new Dictionary<string, object>{    { "cryptSharedLibPath", _appSettings["CryptSharedLibPath"] } // Path to your Automatic Encryption Shared Library};
var autoEncryptionOptions = new AutoEncryptionOptions(    keyVaultNamespace,    kmsProviderCredentials,    extraOptions: extraOptions,    tlsOptions: tlsOptions);

cryptSharedLibraryPath := map[string]interface{}{	"cryptSharedLibPath": os.Getenv("SHARED_LIB_PATH"), // Path to your Automatic Encryption Shared Library}
autoEncryptionOptions := options.AutoEncryption().	SetKeyVaultNamespace(keyVaultNamespace).	SetKmsProviders(kmsProviderCredentials).	SetExtraOptions(cryptSharedLibraryPath).	SetTLSConfig(tlsConfig)

Map<String, Object> extraOptions = new HashMap<String, Object>();extraOptions.put("cryptSharedLibPath", getEnv("SHARED_LIB_PATH")); // Path to your Automatic Encryption Shared Library
AutoEncryptionSettings autoEncryptionSettings = AutoEncryptionSettings.builder()        .keyVaultNamespace(keyVaultNamespace)        .kmsProviders(kmsProviderCredentials)        .extraOptions(extraOptions)        .build();

const extraOptions = {  cryptSharedLibPath: process.env.SHARED_LIB_PATH, // Path to your Automatic Encryption Shared Library};
const autoEncryptionOptions = {  keyVaultNamespace,  kmsProviders,  extraOptions,  tlsOptions,};

auto_encryption_opts = AutoEncryptionOpts(    kms_provider_credentials,    key_vault_namespace,    crypt_shared_lib_path=os.environ['SHARED_LIB_PATH'], # Path to your Automatic Encryption Shared Library    kms_tls_options=tls_options)

const encryptedClient = Mongo(uri, autoEncryptionOptions);

MongoClientSettings.Extensions.AddAutoEncryption(); // .NET/C# Driver v3.0 or later onlyvar clientSettings = MongoClientSettings.FromConnectionString(uri);clientSettings.AutoEncryptionOptions = qeHelpers.GetAutoEncryptionOptions(    keyVaultNamespace,    kmsProviderCredentials);var encryptedClient = new MongoClient(clientSettings);

encryptedClient, err := mongo.Connect(	context.TODO(),	options.Client().ApplyURI(uri).SetAutoEncryptionOptions(autoEncryptionOptions),)if err != nil {	panic(fmt.Sprintf("Unable to connect to MongoDB: %v\n", err))}defer func() {	_ = encryptedClient.Disconnect(context.TODO())}()

MongoClientSettings clientSettings = MongoClientSettings.builder()        .applyConnectionString(new ConnectionString(uri))        .autoEncryptionSettings(autoEncryptionSettings)        .build();
try (MongoClient encryptedClient = MongoClients.create(clientSettings)) {

const encryptedClient = new MongoClient(uri, {  autoEncryption: autoEncryptionOptions,});

encrypted_client = MongoClient(    uri, auto_encryption_opts=auto_encryption_options)

const encryptedFieldsMap = {  encryptedFields: {    fields: [      {        path: "patientRecord.ssn",        bsonType: "string",        queries: { queryType: "equality" },      },      {        path: "patientRecord.billing",        bsonType: "object",      },    ],  },};

var encryptedFields = new BsonDocument{    {        "fields", new BsonArray        {            new BsonDocument            {                { "keyId", BsonNull.Value },                { "path", "record.ssn" },                { "bsonType", "string" },                { "queries", new BsonDocument("queryType", "equality") }            },            new BsonDocument            {                { "keyId", BsonNull.Value },                { "path", "record.billing" },                { "bsonType", "object" }            }        }    }};

encryptedFieldsMap := bson.M{	"fields": []bson.M{		bson.M{			"keyId":    nil,			"path":     "patientRecord.ssn",			"bsonType": "string",			"queries": []bson.M{				{					"queryType": "equality",				},			},		},		bson.M{			"keyId":    nil,			"path":     "patientRecord.billing",			"bsonType": "object",		},	},}

BsonDocument encryptedFieldsMap = new BsonDocument().append("fields",        new BsonArray(Arrays.asList(                new BsonDocument()                        .append("keyId", new BsonNull())                        .append("path", new BsonString("patientRecord.ssn"))                        .append("bsonType", new BsonString("string"))                        .append("queries", new BsonDocument()                                .append("queryType", new BsonString("equality"))),                new BsonDocument()                        .append("keyId", new BsonNull())                        .append("path", new BsonString("patientRecord.billing"))                        .append("bsonType", new BsonString("object")))));

const encryptedFieldsMap = {  encryptedFields: {    fields: [      {        path: "patientRecord.ssn",        bsonType: "string",        queries: { queryType: "equality" },      },      {        path: "patientRecord.billing",        bsonType: "object",      },    ],  },};

encrypted_fields_map = {    "fields": [        {            "path": "patientRecord.ssn",            "bsonType": "string",            "queries": [{"queryType": "equality"}]        },        {            "path": "patientRecord.billing",            "bsonType": "object",        }    ]}

const clientEncryption = encryptedClient.getClientEncryption()

var clientEncryptionOptions = new ClientEncryptionOptions(    keyVaultClient: keyVaultClient,    keyVaultNamespace: keyVaultNamespace,    kmsProviders: kmsProviderCredentials);var clientEncryption = new ClientEncryption(clientEncryptionOptions);

clientEncryptionOpts := options.ClientEncryption().	SetKeyVaultNamespace(keyVaultNamespace).	SetKmsProviders(kmsProviderCredentials)
clientEncryption, err := mongo.NewClientEncryption(encryptedClient, clientEncryptionOpts)if err != nil {	panic(fmt.Sprintf("Unable to create a ClientEncryption instance due to the following error: %s\n", err))}

ClientEncryptionSettings clientEncryptionSettings = ClientEncryptionSettings.builder()        .keyVaultMongoClientSettings(MongoClientSettings.builder()                .applyConnectionString(new ConnectionString(uri))                .build())        .keyVaultNamespace(keyVaultNamespace)        .kmsProviders(kmsProviderCredentials)        .build();ClientEncryption clientEncryption = ClientEncryptions.create(clientEncryptionSettings);

const clientEncryption = new ClientEncryption(encryptedClient, autoEncryptionOptions);

client_encryption = ClientEncryption(    kms_providers=kms_provider_credentials,    key_vault_namespace=key_vault_namespace,    key_vault_client=encrypted_client,    codec_options=CodecOptions(uuid_representation=STANDARD))

await clientEncryption.createEncryptedCollection(  encryptedDatabaseName,  encryptedCollectionName,  {    provider: kmsProviderName,    createCollectionOptions: encryptedFieldsMap,    masterKey: customerMasterKeyCredentials,  });

using MongoDB.Bson;using MongoDB.Bson.Serialization.Attributes;
[BsonIgnoreExtraElements]public class Patient{    public ObjectId Id { get; set; }    public string Name { get; set; }    public PatientRecord Record { get; set; }}

public class PatientRecord{    public string Ssn { get; set; }    public PatientBilling Billing { get; set; }}

public class PatientBilling{    public string CardType { get; set; }    public long CardNumber { get; set; }}

var patientDatabase = encryptedClient.GetDatabase(encryptedDatabaseName);patientDatabase.DropCollection(encryptedCollectionName); // Ensure the collection is dropped before creating a new onetry{    var createCollectionOptions = new CreateCollectionOptions<Patient>    {        EncryptedFields = encryptedFields    };
    clientEncryption.CreateEncryptedCollection(patientDatabase,        encryptedCollectionName,        createCollectionOptions,        kmsProviderName,        customerMasterKeyCredentials);}catch (Exception e){    throw new Exception("Unable to create encrypted collection due to the following error: " + e.Message);}

type PatientDocument struct {	PatientName   string        `bson:"patientName"`	PatientID     int32         `bson:"patientId"`	PatientRecord PatientRecord `bson:"patientRecord"`}

type PatientRecord struct {	SSN     string      `bson:"ssn"`	Billing PaymentInfo `bson:"billing"`}

type PaymentInfo struct {	Type   string `bson:"type"`	Number string `bson:"number"`}

createCollectionOptions := options.CreateCollection().SetEncryptedFields(encryptedFieldsMap)_, _, err =	clientEncryption.CreateEncryptedCollection(		context.TODO(),		encryptedClient.Database(encryptedDatabaseName),		encryptedCollectionName,		createCollectionOptions,		kmsProviderName,		customerMasterKey,	)

CreateCollectionOptions createCollectionOptions = new CreateCollectionOptions().encryptedFields(encryptedFieldsMap);
CreateEncryptedCollectionParams encryptedCollectionParams = new CreateEncryptedCollectionParams(kmsProviderName);encryptedCollectionParams.masterKey(customerMasterKeyCredentials);
try {    clientEncryption.createEncryptedCollection(            encryptedClient.getDatabase(encryptedDatabaseName),            encryptedCollectionName,            createCollectionOptions,            encryptedCollectionParams);} catch (Exception e) {    throw new Exception("Unable to create encrypted collection due to the following error: " + e.getMessage());}

await clientEncryption.createEncryptedCollection(  encryptedDatabase,  encryptedCollectionName,  {    provider: kmsProviderName,    createCollectionOptions: encryptedFieldsMap,    masterKey: customerMasterKeyCredentials,  });

client_encryption.create_encrypted_collection(    encrypted_client[encrypted_database_name],    encrypted_collection_name,    encrypted_fields_map,    kms_provider_name,    customer_master_key_credentials,)