Use o Queryable Encryption com o KMIP
Nesta página
Visão geral
Este guia mostra como criar uma aplicação que implementa o MongoDB Queryable Encryption para criptografar e descriptografar automaticamente os campos do documento e usar um provedor de chaves compatível com o Key Management Interoperability Protocol (KMIP) para gerenciamento de chaves.
Depois de concluir as etapas deste guia, você deverá ter:
Uma chave mestra do cliente gerenciada por um fornecedor de chaves compatívelcom KMIP
Uma aplicação cliente funcional que insere documentos com campos criptografados usando sua Chave Mestre do Cliente
Dica
chave mestra do cliente
Para saber mais sobre a chave mestra do cliente, leia a documentação Keys and Key Vaults .
Antes de começar
Para concluir e executar o código neste guia, você precisa configurar seu ambiente de desenvolvimento, como mostrado na página Requisitos de instalação.
Dica
Veja: Aplicação Completa
Para ver o código completo desse aplicativo de amostra, selecione a aba correspondente à sua linguagem de programação e siga o link fornecido. Cada repositório de aplicativo de amostra inclui um arquivo README.md
que você pode utilizar para saber como configurar seu ambiente e executar o aplicativo.
Configurar o KMS
Configure seu provedor de chaves compatível com KMIP
Para conectar um cliente de driver MongoDB ao seu fornecedor de chaves compatível com KMIP , você deve configurar seu provedor de chaves compatível com KMIPpara que ele aceite o certificado TLS do seu cliente.
Consulte a documentação do seu provedor de chaves compatível com KMIPpara obter informações sobre como aceitar seu certificado de cliente.
Especifique seus certificados
Seu cliente deve se conectar ao seu provedor de chaves compatível com KMIPpor meio de TLS e apresentar um certificado de cliente que seu provedor de chaves compatível com KMIPaceite:
const tlsOptions = { kmip: { tlsCAFile: process.env["KMIP_TLS_CA_FILE"], // Path to your TLS CA file tlsCertificateKeyFile: process.env["KMIP_TLS_CERT_FILE"], // Path to your TLS certificate key file }, };
var tlsOptions = new Dictionary<string, SslSettings>(); var sslSettings = new SslSettings(); var clientCertificate = new X509Certificate2(_appSettings["Kmip:TlsCertP12"]!); // Full path to your client certificate p12 file sslSettings.ClientCertificates = new[] { clientCertificate }; tlsOptions.Add("kmip", sslSettings);
Importante
Seu certificado de cliente deve estar no12 formato pcks . Você pode converter seu certificado usando OpenSSL com o seguinte comando:
openssl pcks12 -export -out "<new pcks12 certificate>" -in "<certificate to convert>" \ -name "<new certificate name>" -password "<new certificate password>"
tlsOpts := map[string]interface{}{ "tlsCertificateKeyFile": os.Getenv("KMIP_TLS_CERT_ECDSA_FILE"), // Path to your client certificate file "tlsCAFile": os.Getenv("KMIP_TLS_CA_ECDSA_FILE"), // Path to your KMIP certificate authority file } kmipConfig, err := options.BuildTLSConfig(tlsOpts) if err != nil { panic(fmt.Sprintf("Unable to retrieve certificates from your environment: %s\n", err)) } tlsConfig := map[string]*tls.Config{ "kmip": kmipConfig, }
Configure as seguintes opções de máquina virtual para especificar o keystore e o armazenamento confiável que contêm seus certificados KMIP TLS e adicioná-los ao comando que você usa para iniciar seu aplicativo Java:
-Djavax.net.ssl.enabled=true -Djavax.net.ssl.keyStoreType=pkcs12 -Djavax.net.ssl.keyStore=REPLACE-WITH-PATH-TO-PKC-KEYSTORE -Djavax.net.ssl.keyStorePassword=REPLACE-WITH-KEYSTORE-PASSWORD -Djavax.net.ssl.trustStoreType=jks -Djavax.net.ssl.trustStore=REPLACE-WITH-PATH-TO-TRUSTSTORE -Djavax.net.ssl.trustStorePassword=REPLACE-WITH-TRUSTSTORE-PASSWORD
Observação
Configurar cliente com SSLContext
Se você preferir configurar seu aplicativo cliente usando um contexto SSL, use o comando kmsProviderSslContextMap método.
const tlsOptions = { kmip: { tlsCAFile: process.env.KMIP_TLS_CA_FILE, // Path to your TLS CA file tlsCertificateKeyFile: process.env.KMIP_TLS_CERT_FILE, // Path to your TLS certificate key file }, };
tls_options = { "kmip": { "tlsCAFile": os.environ['KMIP_TLS_CA_FILE'], # Path to your TLS CA file "tlsCertificateKeyFile": os.environ['KMIP_TLS_CERT_FILE'] # Path to your TLS certificate key file } }
Criar o aplicativo
Atribua variáveis ao seu aplicativo
Os exemplos de código neste tutorial usam as seguintes variáveis para executar o fluxo de trabalho com Queryable Encryption:
kmsProviderName - O KMS que você está usando para armazenar sua Chave Mestre do Cliente. Defina esta variável como
"kmip"
para este tutorial.uri - URI de conexão do sistema do MongoDB. Defina seu URI de conexão na variável de ambiente
MONGODB_URI
ou substitua o valor diretamente.keyVaultDatabaseName - O banco de dados no MongoDB onde suas chaves de criptografia de dados (DEKs) serão armazenadas. Defina esta variável como
"encryption"
.keyVaultCollectionName - A collection no MongoDB onde seus DEKs serão armazenados. Configure esta variável para
"__keyVault"
.keyVaultNamespace - O namespace no MongoDB onde seus DEKs serão armazenados. Defina esta variável para os valores das variáveis
keyVaultDatabaseName
ekeyVaultCollectionName
, separados por um período.encryptedDatabaseName - O banco de dados no MongoDB em que seus dados criptografados serão armazenados. Defina esta variável como
"medicalRecords"
.encryptionCollectionName - A coleção no MongoDB onde seus dados criptografados serão armazenados. Defina esta variável como
"patients"
.
Você pode declarar essas variáveis usando o seguinte código:
// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local" const kmsProviderName = "<Your KMS Provider Name>"; const uri = process.env.MONGODB_URI; // Your connection URI const keyVaultDatabaseName = "encryption"; const keyVaultCollectionName = "__keyVault"; const keyVaultNamespace = `${keyVaultDatabaseName}.${keyVaultCollectionName}`; const encryptedDatabaseName = "medicalRecords"; const encryptedCollectionName = "patients";
kmsProviderName - O KMS que você está usando para armazenar sua chave mestre do cliente. Defina este valor como
"kmip"
para este tutorial.keyVaultDatabaseName - O reconhecimento de data center no MongoDB onde seu diretório de dados (DEKs) serão armazenadas. Defina o valor de
keyVaultDatabaseName
para"encryption"
.keyVaultCollectionName - A collection no MongoDB onde seus DEKs serão armazenados. Defina o valor de
keyVaultCollectionName
para"__keyVault"
.keyVaultNamespace - O namespace no MongoDB onde seus DEKs serão armazenados. Defina
keyVaultNamespace
para um novo objetoCollectionNamespace
cujo nome são os valores das variáveiskeyVaultDatabaseName
ekeyVaultCollectionName
, separados por um ponto.encryptionDatabaseName - O reconhecimento de data center no MongoDB onde seus dados criptografados serão armazenados. Defina o valor de
encryptedDatabaseName
para"medicalRecords"
.encryptionCollectionName - A collection no MongoDB onde seus dados criptografados serão armazenados. Defina o valor de
encryptedCollectionName
para"patients"
.uri - URI de conexão de implantação do MongoDB. Defina seu URI de conexão no arquivo
appsettings.json
ou substitua o valor diretamente.
Você pode declarar essas variáveis usando o seguinte código:
// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local" const string kmsProviderName = "<your KMS provider name>"; const string keyVaultDatabaseName = "encryption"; const string keyVaultCollectionName = "__keyVault"; var keyVaultNamespace = CollectionNamespace.FromFullName($"{keyVaultDatabaseName}.{keyVaultCollectionName}"); const string encryptedDatabaseName = "medicalRecords"; const string encryptedCollectionName = "patients"; var appSettings = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); var uri = appSettings["MongoDbUri"];
kmsProviderName - O KMS que você está usando para armazenar sua Chave Mestre do Cliente. Defina esta variável como
"kmip"
para este tutorial.uri - URI de conexão do sistema do MongoDB. Defina seu URI de conexão na variável de ambiente
MONGODB_URI
ou substitua o valor diretamente.keyVaultDatabaseName - O banco de dados no MongoDB onde suas chaves de criptografia de dados (DEKs) serão armazenadas. Defina esta variável como
"encryption"
.keyVaultCollectionName - A collection no MongoDB onde seus DEKs serão armazenados. Configure esta variável para
"__keyVault"
.keyVaultNamespace - O namespace no MongoDB onde seus DEKs serão armazenados. Defina esta variável para os valores das variáveis
keyVaultDatabaseName
ekeyVaultCollectionName
, separados por um período.encryptedDatabaseName - O banco de dados no MongoDB em que seus dados criptografados serão armazenados. Defina esta variável como
"medicalRecords"
.encryptionCollectionName - A coleção no MongoDB onde seus dados criptografados serão armazenados. Defina esta variável como
"patients"
.
Você pode declarar essas variáveis usando o seguinte código:
// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local" kmsProviderName := "<KMS provider name>" uri := os.Getenv("MONGODB_URI") // Your connection URI keyVaultDatabaseName := "encryption" keyVaultCollectionName := "__keyVault" keyVaultNamespace := keyVaultDatabaseName + "." + keyVaultCollectionName encryptedDatabaseName := "medicalRecords" encryptedCollectionName := "patients"
kmsProviderName - O KMS que você está usando para armazenar sua Chave Mestre do Cliente. Defina esta variável como
"kmip"
para este tutorial.uri - URI de conexão do sistema do MongoDB. Defina seu URI de conexão na variável de ambiente
MONGODB_URI
ou substitua o valor diretamente.keyVaultDatabaseName - O banco de dados no MongoDB onde suas chaves de criptografia de dados (DEKs) serão armazenadas. Defina esta variável como
"encryption"
.keyVaultCollectionName - A collection no MongoDB onde seus DEKs serão armazenados. Configure esta variável para
"__keyVault"
.keyVaultNamespace - O namespace no MongoDB onde seus DEKs serão armazenados. Defina esta variável para os valores das variáveis
keyVaultDatabaseName
ekeyVaultCollectionName
, separados por um período.encryptedDatabaseName - O banco de dados no MongoDB em que seus dados criptografados serão armazenados. Defina esta variável como
"medicalRecords"
.encryptionCollectionName - A coleção no MongoDB onde seus dados criptografados serão armazenados. Defina esta variável como
"patients"
.
Você pode declarar essas variáveis usando o seguinte código:
// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local" String kmsProviderName = "<KMS provider name>"; String uri = QueryableEncryptionHelpers.getEnv("MONGODB_URI"); // Your connection URI String keyVaultDatabaseName = "encryption"; String keyVaultCollectionName = "__keyVault"; String keyVaultNamespace = keyVaultDatabaseName + "." + keyVaultCollectionName; String encryptedDatabaseName = "medicalRecords"; String encryptedCollectionName = "patients";
kmsProviderName - O KMS que você está usando para armazenar sua Chave Mestre do Cliente. Defina esta variável como
"kmip"
para este tutorial.uri - URI de conexão do sistema do MongoDB. Defina seu URI de conexão na variável de ambiente
MONGODB_URI
ou substitua o valor diretamente.keyVaultDatabaseName - O banco de dados no MongoDB onde suas chaves de criptografia de dados (DEKs) serão armazenadas. Defina esta variável como
"encryption"
.keyVaultCollectionName - A collection no MongoDB onde seus DEKs serão armazenados. Configure esta variável para
"__keyVault"
.keyVaultNamespace - O namespace no MongoDB onde seus DEKs serão armazenados. Defina esta variável para os valores das variáveis
keyVaultDatabaseName
ekeyVaultCollectionName
, separados por um período.encryptedDatabaseName - O banco de dados no MongoDB em que seus dados criptografados serão armazenados. Defina esta variável como
"medicalRecords"
.encryptionCollectionName - A coleção no MongoDB onde seus dados criptografados serão armazenados. Defina esta variável como
"patients"
.
Você pode declarar essas variáveis usando o seguinte código:
// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local" const kmsProviderName = "<Your KMS Provider Name>"; const uri = process.env.MONGODB_URI; // Your connection URI const keyVaultDatabaseName = "encryption"; const keyVaultCollectionName = "__keyVault"; const keyVaultNamespace = `${keyVaultDatabaseName}.${keyVaultCollectionName}`; const encryptedDatabaseName = "medicalRecords"; const encryptedCollectionName = "patients";
kms_provider_name - O KMS que você está usando para armazenar sua Chave Mestre do Cliente. Defina esta variável como
"kmip"
para este tutorial.uri - URI de conexão do sistema do MongoDB. Defina seu URI de conexão na variável de ambiente
MONGODB_URI
ou substitua o valor diretamente.key_vault_database_name - O banco de dados no MongoDB onde suas chaves de criptografia de dados (DEKs) serão armazenadas. Defina esta variável como
"encryption"
.key_vault_collection_name - A coleção no MongoDB onde seus DEKs serão armazenados. Defina esta variável como
"__keyVault"
.key_vault_namespace - O namespace no MongoDB onde seus DEKs serão armazenados. Defina esta variável para os valores das variáveis
key_vault_database_name
ekey_vault_collection_name
, separados por um período.encryption_database_name - O banco de dados no MongoDB onde seus dados criptografados serão armazenados. Defina esta variável como
"medicalRecords"
.encryption_collection_name - A coleção no MongoDB onde seus dados criptografados serão armazenados. Defina esta variável como
"patients"
.
Você pode declarar essas variáveis usando o seguinte código:
# KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local" kms_provider_name = "<KMS provider name>" uri = os.environ['MONGODB_URI'] # Your connection URI key_vault_database_name = "encryption" key_vault_collection_name = "__keyVault" key_vault_namespace = f"{key_vault_database_name}.{key_vault_collection_name}" encrypted_database_name = "medicalRecords" encrypted_collection_name = "patients"
Importante
Permissões de namespace da coleção de cofre de chaves
A collection de cofre de chaves está no namespace encryption.__keyVault
. Certifique-se de que o trigger de banco de dados que sua aplicação usa para se conectar ao MongoDB tenha permissões de ReadWrite nesse namespace.
Dica
Variáveis de ambiente
O código de exemplo neste tutorial faz referência a variáveis de ambiente que você precisa definir. Como alternativa, você pode substituir os valores diretamente no código.
Para saber como configurar essas variáveis de ambiente, consulte o README.md incluído no aplicativo de amostra no GitHub.
Dica
Variáveis de ambiente
O código de exemplo neste tutorial faz referência a variáveis de ambiente que você precisa definir. Como alternativa, você pode substituir os valores diretamente no código.
Para saber como configurar essas variáveis de ambiente, consulte o README.md incluído no aplicativo de amostra no GitHub.
Dica
Variáveis de ambiente
O código de exemplo neste tutorial faz referência a variáveis de ambiente que você precisa definir. Como alternativa, você pode substituir os valores diretamente no código.
Para saber como configurar essas variáveis de ambiente, consulte o README.md incluído no aplicativo de amostra no GitHub.
Dica
Variáveis de ambiente
O código de exemplo neste tutorial faz referência a variáveis de ambiente que você precisa definir. Como alternativa, você pode substituir os valores diretamente no código.
Para saber como configurar essas variáveis de ambiente, consulte o README.md incluído no aplicativo de amostra no GitHub.
Dica
Variáveis de ambiente
O código de exemplo neste tutorial faz referência a variáveis de ambiente que você precisa definir. Como alternativa, você pode substituir os valores diretamente no código.
Para saber como configurar essas variáveis de ambiente, consulte o README.md incluído no aplicativo de amostra no GitHub.
Dica
Variáveis de ambiente
O código de exemplo neste tutorial faz referência a variáveis de ambiente que você precisa definir. Como alternativa, você pode substituir os valores diretamente no código.
Para saber como configurar essas variáveis de ambiente, consulte o README.md incluído no aplicativo de amostra no GitHub.
Crie sua coleção criptografada
Adicione suas credenciais KMS do fornecedor de chaves compatível com KMIP
Crie uma variável contendo o endpoint do seu provedor de chaves compatível com KMIP com a seguinte estrutura:
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 } }
Adicione suas credenciais de chave mestra do cliente
Crie um objeto vazio, conforme mostrado no exemplo de código a seguir. Isso solicita que seu fornecedor de chaves compatível com KMIPgere uma nova chave mestre do cliente.
customerMasterKeyCredentials = {};
var customerMasterKeyCredentials = new BsonDocument();
cmkCredentials := map[string]string{}
BsonDocument customerMasterKeyCredentials = new BsonDocument();
customerMasterKeyCredentials = {};
customer_master_key_credentials = {}
Definir suas opções de criptografia automática
Crie um objeto autoEncryptionOptions
que contenha as seguintes opções:
O namespace da sua coleção do Key Vault
O objeto
kmsProviderCredentials
, que contém seu endpoint KMIPO objeto
tlsOptions
que você criou na etapa Especificar seus certificados
const autoEncryptionOptions = { keyVaultNamespace: keyVaultNamespace, kmsProviders: kmsProviderCredentials, tlsOptions, };
Crie um objeto AutoEncryptionOptions
que contenha as seguintes opções:
O namespace da sua coleção do Key Vault
O objeto
kmsProviderCredentials
, que contém seu endpoint KMIPO objeto
extraOptions
, que contém o caminho para sua Biblioteca Compartilhada de Criptografia AutomáticaO objeto
tlsOptions
que você criou na etapa Especificar seus certificados
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);
Crie um objeto AutoEncryption
que contenha as seguintes opções:
O namespace da sua coleção do Key Vault
O objeto
kmsProviderCredentials
, que contém seu endpoint KMIPO objeto
cryptSharedLibraryPath
, que contém o caminho para sua Biblioteca Compartilhada de Criptografia AutomáticaO objeto
tlsConfig
que você criou na etapa Especificar seus certificados
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)
Crie um objeto AutoEncryptionSettings
que contenha as seguintes opções:
O namespace da sua coleção do Key Vault
O objeto
kmsProviderCredentials
, que contém seu endpoint KMIPO objeto
extraOptions
, que contém o caminho para sua Biblioteca Compartilhada de Criptografia Automática
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();
Crie um objeto autoEncryptionOptions
que contenha as seguintes opções:
O namespace da sua coleção do Key Vault
O objeto
kmsProviders
, que contém seu endpoint KMIPO objeto
sharedLibraryPathOptions
, que contém o caminho para sua Biblioteca Compartilhada de Criptografia AutomáticaO objeto
tlsOptions
que você criou na etapa Especificar seus certificados
const extraOptions = { cryptSharedLibPath: process.env.SHARED_LIB_PATH, // Path to your Automatic Encryption Shared Library }; const autoEncryptionOptions = { keyVaultNamespace, kmsProviders, extraOptions, tlsOptions, };
Crie um objeto AutoEncryptionOpts
que contenha as seguintes opções:
O objeto
kms_provider_credentials
, que contém seu endpoint KMIPO namespace da sua coleção do Key Vault
O caminho para sua biblioteca compartilhada de criptografia automática
O objeto
tls_options
que você criou na etapa Especificar seus certificados
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 )
Observação
Opções de criptografia automática
As opções de criptografia automática fornecem informações de configuração para a Biblioteca compartilhada de criptografia automática, que modifica o comportamento do aplicativo ao acessar campos criptografados.
Para saber mais sobre a Biblioteca Compartilhada de Criptografia Automática, consulte a página Biblioteca Compartilhada de Criptografia Automática para Queryable Encryption.
Criar um cliente para configurar uma coleção criptografada
Para criar um cliente utilizado para criptografar e descriptografar dados em sua coleção, instancie um novo MongoClient
usando seu URI de conexão e suas opções de criptografia automática.
const encryptedClient = Mongo(uri, autoEncryptionOpts);
var 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)
Especifique campos para criptografia
Para criptografar um campo, adicione-o ao esquema de criptografia. Para habilitar queries em um campo, adicione a propriedade "queries". Crie o esquema de criptografia da seguinte forma:
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", } ] }
Observação
No exemplo de código anterior, os campos "ssn" e "billing" são criptografados, mas somente o campo "ssn" pode ser consultado.
Criar a coleção
Instancie ClientEncryption
para acessar a API e obter métodos assistentes de criptografia.
const clientEncryption = encryptedClient.getClientEncryption()
var clientEncryptionOptions = new ClientEncryptionOptions( keyVaultClient: keyVaultClient, keyVaultNamespace: keyVaultNamespace, kmsProviders: kmsProviderCredentials ); var clientEncryption = new ClientEncryption(clientEncryptionOptions);
opts := options.ClientEncryption(). SetKeyVaultNamespace(keyVaultNamespace). SetKmsProviders(kmsProviderCredentials) clientEncryption, err := mongo.NewClientEncryption(encryptedClient, opts) 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) )
Crie sua coleção criptografada usando o método auxiliar de criptografia acessado por meio da classe ClientEncryption
. Este método gera automaticamente chaves de criptografia de dados para seus campos criptografados e cria a coleção criptografada:
await clientEncryption.createEncryptedCollection( encryptedDatabaseName, encryptedCollectionName, { provider: kmsProviderName, createCollectionOptions: encryptedFieldsMap, masterKey: customerMasterKeyCredentials, } );
A versão C# deste tutorial usa classes separadas como Modelo de dados Realm para representar a estrutura do documento. Adicione as seguintes classes Patient
, PatientRecord
e PatientBilling
ao seu projeto:
using MongoDB.Bson; using MongoDB.Bson.Serialization.Attributes; [ ]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; } }
Após adicionar essas classes, crie sua collection criptografada usando o método auxiliar de encryption acessado por meio da classe ClientEncryption
. Esse método gera automaticamente diretório de dados para seu campo criptografados e cria a collection criptografada:
var createCollectionOptions = new CreateCollectionOptions<Patient> { EncryptedFields = encryptedFields }; clientEncryption.CreateEncryptedCollection(patientDatabase, encryptedCollectionName, createCollectionOptions, kmsProviderName, customerMasterKeyCredentials);
Dica
Banco de dados vs. nome do banco de dados
O método que cria a coleção criptografada requer uma referência a um objeto de banco de dados em vez do nome do banco de dados. Você pode obter essa referência usando um método em seu objeto cliente.
A versão Go deste tutorial usa modelos de dados para representar a estrutura do documento. Adicione as seguintes estruturas ao seu projeto para representar os dados em sua collection:
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"` }
Após adicionar essas classes, crie sua collection criptografada usando o método auxiliar de encryption acessado por meio da classe ClientEncryption
. Esse método gera automaticamente diretório de dados para seu campo criptografados e cria a collection criptografada:
createCollectionOptions := options.CreateCollection().SetEncryptedFields(encryptedFieldsMap) _, _, err = clientEncryption.CreateEncryptedCollection( context.TODO(), encryptedClient.Database(encryptedDatabaseName), encryptedCollectionName, createCollectionOptions, kmsProviderName, customerMasterKey, )
Dica
Banco de dados vs. nome do banco de dados
O método que cria a coleção criptografada requer uma referência a um objeto de banco de dados em vez do nome do banco de dados. Você pode obter essa referência usando um método em seu objeto cliente.
Crie sua coleção criptografada usando o método auxiliar de criptografia acessado por meio da classe ClientEncryption
. Este método gera automaticamente chaves de criptografia de dados para seus campos criptografados e cria a coleção criptografada:
CreateCollectionOptions createCollectionOptions = new CreateCollectionOptions().encryptedFields(encryptedFieldsMap); CreateEncryptedCollectionParams encryptedCollectionParams = new CreateEncryptedCollectionParams(kmsProviderName); encryptedCollectionParams.masterKey(customerMasterKeyCredentials); try { clientEncryption.createEncryptedCollection( encryptedClient.getDatabase(encryptedDatabaseName), encryptedCollectionName, createCollectionOptions, encryptedCollectionParams); }
Dica
Banco de dados vs. nome do banco de dados
O método que cria a coleção criptografada requer uma referência a um objeto de banco de dados em vez do nome do banco de dados. Você pode obter essa referência usando um método em seu objeto cliente.
Observação
Importar ClientEncryption
Ao usar o driver Node.js v6.0 e posterior, você deve importar ClientEncryption
de mongodb
.
Para versões anteriores do driver, importe ClientEncryption
de mongodb-client-encryption
.
Crie sua coleção criptografada usando o método auxiliar de criptografia acessado por meio da classe ClientEncryption
. Este método gera automaticamente chaves de criptografia de dados para seus campos criptografados e cria a coleção criptografada:
await clientEncryption.createEncryptedCollection( encryptedDatabase, encryptedCollectionName, { provider: kmsProviderName, createCollectionOptions: encryptedFieldsMap, masterKey: customerMasterKeyCredentials, } );
Dica
Banco de dados vs. nome do banco de dados
O método que cria a coleção criptografada requer uma referência a um objeto de banco de dados em vez do nome do banco de dados. Você pode obter essa referência usando um método em seu objeto cliente.
Crie sua coleção criptografada usando o método auxiliar de criptografia acessado por meio da classe ClientEncryption
. Este método gera automaticamente chaves de criptografia de dados para seus campos criptografados e cria a coleção criptografada:
client_encryption.create_encrypted_collection( encrypted_client[encrypted_database_name], encrypted_collection_name, encrypted_fields_map, kms_provider_name, customer_master_key_credentials, )
Dica
Banco de dados vs. nome do banco de dados
O método que cria a coleção criptografada requer uma referência a um objeto de banco de dados em vez do nome do banco de dados. Você pode obter essa referência usando um método em seu objeto cliente.
Inserir um documento com campos criptografados
Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients
, conforme mostrado no exemplo a seguir:
const patientDocument = { patientName: "Jon Doe", patientId: 12345678, patientRecord: { ssn: "987-65-4320", billing: { type: "Visa", number: "4111111111111111", }, }, }; const encryptedCollection = encryptedClient.getDB(encryptedDatabaseName).getCollection(encryptedCollectionName); const insertResult = await encryptedCollection.insertOne(patientDocument);
Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients
, conforme mostrado no exemplo a seguir:
var patient = new Patient { Name = "Jon Doe", Id = new ObjectId(), Record = new PatientRecord { Ssn = "987-65-4320", Billing = new PatientBilling { CardType = "Visa", CardNumber = 4111111111111111 } } }; var encryptedCollection = encryptedClient.GetDatabase(encryptedDatabaseName). GetCollection<Patient>(encryptedCollectionName); encryptedCollection.InsertOne(patient);
Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients
, conforme mostrado no exemplo a seguir:
patientDocument := &PatientDocument{ PatientName: "John Doe", PatientID: 12345678, PatientRecord: PatientRecord{ SSN: "987-65-4320", Billing: PaymentInfo{ Type: "Visa", Number: "4111111111111111", }, }, } coll := encryptedClient.Database(encryptedDatabaseName).Collection(encryptedCollectionName) _, err = coll.InsertOne(context.TODO(), patientDocument) if err != nil { panic(fmt.Sprintf("Unable to insert the patientDocument: %s", err)) }
Este tutorial utiliza POJOs como modelos de dados para representar a estrutura do documento. Para configurar seu aplicativo para usar POJOs, adicione o seguinte código:
CodecProvider pojoCodecProvider = PojoCodecProvider.builder().automatic(true).build(); CodecRegistry pojoCodecRegistry = fromRegistries(getDefaultCodecRegistry(), fromProviders(pojoCodecProvider));
Para saber mais sobre POJOs Java, consulte o artigo da wikipedário Objeto Java antigo simples.
Este tutorial usa os seguintes POJOs:
Patient
PatientRecord
PatientBilling
Você pode visualizar essas classes no pacote de modelos do aplicativo Java completo.
Adicione estas classes POJO ao seu aplicativo. Em seguida, crie uma instância de um Patient
que descreva as informações pessoais de um pai. Use o cliente criptografado para inseri-lo na coleção patients
, conforme mostrado no exemplo a seguir:
MongoDatabase encryptedDb = encryptedClient.getDatabase(encryptedDatabaseName).withCodecRegistry(pojoCodecRegistry); MongoCollection<Patient> collection = encryptedDb.getCollection(encryptedCollectionName, Patient.class); PatientBilling patientBilling = new PatientBilling("Visa", "4111111111111111"); PatientRecord patientRecord = new PatientRecord("987-65-4320", patientBilling); Patient patientDocument = new Patient("Jon Doe", patientRecord); InsertOneResult result = collection.insertOne(patientDocument);
Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients
, conforme mostrado no exemplo a seguir:
const patientDocument = { patientName: "Jon Doe", patientId: 12345678, patientRecord: { ssn: "987-65-4320", billing: { type: "Visa", number: "4111111111111111", }, }, }; const encryptedCollection = encryptedClient .db(encryptedDatabaseName) .collection(encryptedCollectionName); const result = await encryptedCollection.insertOne(patientDocument);
Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients
, conforme mostrado no exemplo a seguir:
patient_document = { "patientName": "Jon Doe", "patientId": 12345678, "patientRecord": { "ssn": "987-65-4320", "billing": { "type": "Visa", "number": "4111111111111111", }, }, } encrypted_collection = encrypted_client[encrypted_database_name][encrypted_collection_name] result = encrypted_collection.insert_one(patient_document)
Consulte um campo criptografado
A amostra de código a seguir executa uma query de localização em um campo criptografado e imprime os dados descriptografados:
const findResult = await encryptedCollection.findOne({ "patientRecord.ssn": "987-65-4320", }); console.log(findResult);
var ssnFilter = Builders<Patient>.Filter.Eq("record.ssn", patient.Record.Ssn); var findResult = await encryptedCollection.Find(ssnFilter).ToCursorAsync(); Console.WriteLine(findResult.FirstOrDefault().ToJson());
var findResult PatientDocument err = coll.FindOne( context.TODO(), bson.M{"patientRecord.ssn": "987-65-4320"}, ).Decode(&findResult)
Patient findResult = collection.find( new BsonDocument() .append("patientRecord.ssn", new BsonString("987-65-4320"))) .first(); System.out.println(findResult);
const findResult = await encryptedCollection.findOne({ "patientRecord.ssn": "987-65-4320", }); console.log(findResult);
find_result = encrypted_collection.find_one({ "patientRecord.ssn": "987-65-4320" }) print(find_result)
A saída do exemplo de código anterior deve ser semelhante a esta:
{ "_id": { "$oid": "648b384a722cb9b8392df76a" }, "name": "Jon Doe", "record": { "ssn": "987-65-4320", "billing": { "type": "Visa", "number": "4111111111111111" } }, "__safeContent__": [ { "$binary": { "base64": "L1NsYItk0Sg+oL66DBj6IYHbX7tveANQyrU2cvMzD9Y=", "subType": "00" } } ] }
Aviso
Não modifique o campo __safeContent__.
O campo __safeContent__
é essencial para o Queryable Encryption. Não modifique o conteúdo deste campo.
Saiba mais
Para saber como funciona a Queryable Encryption, consulte a página Fundamentos.
Para saber mais sobre os tópicos mencionados neste guia, consulte os seguintes links:
Saiba mais sobre os componentes da Queryable Encryption na página Referência.
Saiba como funcionam as chaves mestras do cliente e as chaves de criptografia de dados na página Chaves e cofres de chaves.
Veja como os provedores de KMS gerenciam suas chaves Queryable Encryption na página Provedores de KMS.