Criptografia do lado do cliente
Nesta página
Novidade no MongoDB 4.2, a criptografia do lado do cliente permite que administradores e desenvolvedores criptografem campo específicos em documento MongoDB antes de inseri-los no reconhecimento de data center.
Com a criptografia do lado do cliente, os desenvolvedores podem criptografar campos do lado do cliente sem nenhuma configuração ou diretiva do lado do servidor. A criptografia do lado do cliente oferece suporte a cargas de trabalho em que os aplicativos devem garantir que partes não autorizadas, incluindo administradores de servidores, não possam ler os dados criptografados.
Aviso
Habilitar a criptografia do lado do cliente reduz o tamanho máximo do lote de gravação e pode ter um impacto negativo no desempenho.
Instalação
A criptografia do lado do cliente requer a instalação de pacotes adicionais.
libmongocrypt
A libmongocrypt é uma biblioteca C utilizada pelo condutor para encriptação do lado do cliente. Para usar a criptografia do lado do cliente, você deve instalar a biblioteca libmongocrypt na máquina que executa seu programa Ruby.
A maneira mais fácil de instalar esta biblioteca é instalar o libmongocrypt-helper da seguinte forma:
gem install libmongocrypt-helper --pre
O número da versão do libmongocrypt-helper é a versão do libmongocrypt incluído, seguido pelo número da versão, por exemplo 1.3.2.r1. Como o Ruby considera que quaisquer letras no número da versão indicam uma versão de pré-lançamento, o sinalizador --pre é necessário.
O driver carregará automaticamente o libmongocrypt-helper - nenhuma configuração adicional é necessária.
Observação
Atualmente, o libmongocrypt-helper suporta apenas sistemas operacionais Linux.
Como alternativa, você pode baixar uma distribuição binária pré-desenvolvida do libmongocrypt e colocar manualmente o objeto compartilhado necessário no seu computador, da seguinte forma:
Baixe um tarball de todas as variações da libmongocrypt aqui.
Extraia o arquivo que você baixou. Você verá uma lista de diretórios, cada um correspondente a um sistema operacional. Encontre o diretório que corresponde ao seu sistema operacional e abra-o.
Dentro dessa pasta, abra a pasta chamada "nocrypto". Na pasta lib ou lib64, você encontrará o arquivo libmongocrypt.so ou libmongocrypt.dylib ou libmongocrypt.DL, dependendo do seu sistema operacional.
Mova esse arquivo para onde você quiser mantê-lo em sua máquina. Você pode excluir os outros arquivos incluídos no tarball.
Para compilar o binário a partir da origem:
Siga as instruções no README no repositório libmongocrypt Github do.
Depois de ter o binário libmongocrypt em sua máquina, especifique o caminho para o binário usando a variável de ambiente BIMONGOCRYPT_PATH. É recomendável adicionar essa variável aos seus arquivos rc. Por exemplo:
export LIBMONGOCRYPT_PATH=/path/to/your/libmongocrypt.so
Observação
O binário referenciado nesta seção pode ser uma versão de pré-lançamento do libmongocrypt que não é recomendado para ambientes de produção.
Biblioteca compartilhada de criptografia automática
A Automatic Encryption Shared Library é uma biblioteca dinâmica que permite que seu aplicativo cliente execute a criptografia automática. Ele é necessário apenas para a criptografia automática, que é um recurso somente para empresas. Se você pretende apenas usar criptografia explícita, pode pular esta etapa. A biblioteca compartilhada de criptografia automática oferece a mesma funcionalidade que o mongocryptd (veja abaixo), mas não exige que você inicie outro processo para executar a criptografia automática.
Para obter instruções de instalação, consulte o manual do MongoDB.
Quando a criptografia automática estiver habilitada, o libmongocrypt procurará a biblioteca compartilhada no caminho da biblioteca do sistema ou tentará carregar a biblioteca de um local específico se a opção :crypt_shared_lib_path for fornecida ao criar um cliente. Se a biblioteca puder ser carregada, o driver não tentará gerar o daemon mongocryptd. O daemon ainda será gerado se a biblioteca compartilhada não puder ser encontrada.
Também é possível exigir o uso da biblioteca compartilhada passando a opção crypt_shared_lib_required: true ao criar um cliente. Neste caso, um erro será gerado se a biblioteca compartilhada não puder ser carregada.
Observação
Todos os objetos Mongo::Client no mesmo processo devem usar a mesma configuração :crypt_shared_lib_path, pois é um erro carregar mais de uma biblioteca dinâmica crypt_Shared simultaneamente em um único processo do sistema operacional.
mongocryptd
O Mongocryptd é uma alternativa à biblioteca compartilhada de criptografia automática. O Mongocryptd é um daemon que informa ao driver quais campos criptografar em uma determinada operação. Ele é necessário apenas para a criptografia automática, que é um recurso somente para empresas. Se você pretende apenas usar criptografia explícita, pode pular esta etapa.
O Mongocryptd vem pré-embalado com compilações empresariais do servidor MongoDB (versões 4.2 e mais recentes). Para obter instruções de instalação, consulte o manual do MongoDB.
Para configurar o mongocryptd (por exemplo, em qual porta ele escuta ou o caminho usado para gerar o daemon), é necessário passar opções diferentes para o Mongo::Client que executa a criptografia automática. Consulte a seção :extra_options deste tutorial para obter mais informações.
Criptografia automática
A criptografia automática é um recurso que permite aos usuários configurar uma instância do Mongo::Client para sempre criptografar campos específicos do documento ao executar operações do banco de dados. Depois que o Mongo::Client for configurado, ele criptografará automaticamente qualquer campo que exija criptografia antes de gravá-lo no banco de dados e descriptografará automaticamente esses campos ao lê-los.
A criptografia do lado do cliente implementa a criptografia de envelope, que é a prática de criptografar dados com uma chave de dados, que, por sua vez, é criptografada usando uma chave mestre. Assim, usar a criptografia do lado do cliente com o MongoDB envolve três etapas principais:
Criar uma chave mestre
Criar uma chave de dados (e criptografá-la usando a chave mestre)
Criptografar dados usando a chave de dados
O exemplo abaixo demonstra como seguir essas etapas com uma chave mestre local para executar a criptografia automática.
Observação
A criptografia automática é um recurso somente empresarial que se aplica somente a operações em uma collection. A criptografia automática não é suportada para operações em um banco de dados ou visualização, e as operações que não forem ignoradas resultarão em erro (consulte a lista de permissões de criptografia automática ). Para ignorar a criptografia automática em todas as operações, defina bypass_auto_encryption como true em auto_encryption_options.
Observação
A criptografia automática exige que o usuário autenticado tenha a ação de privilégio listar Coleções.
Observação
Ao usar a criptografia automática e uma instância Mongo::Client configurada com :auto_encryption_options tiver um tamanho de pool de conexões limitado (ou seja, um :max_pool_size diferente de zero , que é a configuração padrão), uma instância Mongo::Client interna separada é criada se alguma das seguintes afirmações for verdadeira:
auto_encryption_options[:key_vault_client]não é passado.auto_encryption_options[:bypass_automatic_encryption]não é passado ou falso.
Se uma instância Mongo::Client interna for criada, ela será configurada com as mesmas opções que o cliente pai, exceto que :min_pool_size está definido como 0 e :auto_encryption_options é omitido.
require 'mongo' ##################################### # Step 1: Create a local master key # ##################################### # A local master key is a 96-byte binary blob. local_master_key = SecureRandom.random_bytes(96) # => "\xB2\xBE\x8EN\xD4\x14\xC2\x13\xC3..." ############################# # Step 2: Create a data key # ############################# kms_providers = { local: { key: local_master_key } } # The key vault client is a Mongo::Client instance connected to the collection # that will store your data keys. key_vault_client = Mongo::Client.new(['localhost:27017']) # Use an instance of Mongo::ClientEncryption to create a new data key client_encryption = Mongo::ClientEncryption.new( key_vault_client, key_vault_namespace: 'encryption.__keyVault', kms_providers: kms_providers ) data_key_id = client_encryption.create_data_key('local') # => <BSON::Binary... type=ciphertext...> ####################################################### # Step 3: Configure Mongo::Client for auto-encryption # ####################################################### # Create a schema map, which tells the Mongo::Client which fields to encrypt schema_map = { 'encryption_db.encryption_coll': { properties: { encrypted_field: { encrypt: { keyId: [data_key_id], bsonType: "string", algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" } } }, bsonType: "object" } } # Configure the client for automatic encryption client = Mongo::Client.new( ['localhost:27017'], auto_encryption_options: { key_vault_namespace: 'encryption.__keyVault', kms_providers: kms_providers, schema_map: schema_map }, database: 'encryption_db', ) collection = client['encryption_coll'] collection.drop # Make sure there is no data in the collection # The string "sensitive data" will be encrypted and stored in the database # as ciphertext collection.insert_one(encrypted_field: 'sensitive data') # The data is decrypted before being returned to the user collection.find(encrypted_field: 'sensitive data').first['encrypted_field'] # => "sensitive data" # A client with no auto_encryption_options is unable to decrypt the data client_no_encryption = Mongo::Client.new( ['localhost:27017'], database: 'encryption_db', ) client_no_encryption['encryption_coll'].find.first['encrypted_field'] # => <BSON::Binary... type=ciphertext...>
O exemplo acima demonstra o uso da criptografia automática com uma chave mestre local. Para obter mais informações sobre como usar outros serviços de gerenciamento de chaves para criar uma chave mestre e criar chaves de dados, consulte as seguintes seções deste tutorial:
Criptografia explícita
A criptografia explícita é um recurso que permite aos usuários criptografar e descriptografar partes individuais de dados, como strings, números inteiros ou símbolos. A criptografia explícita é um recurso da comunidade e não requer uma compilação empresarial do MongoDB Server para ser usada. Para executar todas as operações explícitas de criptografia e descriptografia, use uma instância da classe ClientEncryption.
A criptografia do lado do cliente implementa a criptografia de envelope, que é a prática de criptografar dados com uma chave de dados, que, por sua vez, é criptografada usando uma chave mestre. Assim, usar a criptografia do lado do cliente com o MongoDB envolve três etapas principais:
Criar uma chave mestre
Criar uma chave de dados (e criptografá-la usando a chave mestre)
Criptografar dados usando a chave de dados
O exemplo abaixo demonstra como seguir essas etapas com uma chave mestre local para executar a criptografia explícita.
require 'mongo' ##################################### # Step 1: Create a local master key # ##################################### # A local master key is a 96-byte binary blob. local_master_key = SecureRandom.random_bytes(96) # => "\xB2\xBE\x8EN\xD4\x14\xC2\x13\xC3..." ############################# # Step 2: Create a data key # ############################# kms_providers = { local: { key: local_master_key } } # The key vault client is a Mongo::Client instance connected to the collection # that will store your data keys. key_vault_client = Mongo::Client.new(['localhost:27017']) # Use an instance of Mongo::ClientEncryption to create a new data key client_encryption = Mongo::ClientEncryption.new( key_vault_client, key_vault_namespace: 'encryption.__keyVault', kms_providers: kms_providers ) data_key_id = client_encryption.create_data_key('local') # => <BSON::Binary... type=ciphertext...> ##################################################### # Step 3: Encrypt a string with explicit encryption # ##################################################### # The value to encrypt value = 'sensitive data' # Encrypt the value encrypted_value = client_encryption.encrypt( 'sensitive data', { key_id: data_key_id, algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" } ) # Create the client you will use to read and write the data to MongoDB client = Mongo::Client.new( ['localhost:27017'], database: 'encryption_db', ) collection = client['encryption_coll'] collection.drop # Make sure there is no data in the collection # Insert the encrypted value into the collection collection.insert_one(encrypted_field: encrypted_value) # Use the client to read the encrypted value from the database, then # use the ClientEncryption object to decrypt it find_result = collection.find(encrypted_field: encrypted_value).first['encrypted_field'] # => <BSON::Binary...> (the find result is encrypted) unencrypted_result = client_encryption.decrypt(find_result) # => "sensitive data"
O exemplo acima demonstra o uso da criptografia explícita com uma chave mestre local. Para obter mais informações sobre como usar outros serviços de gerenciamento de chaves para criar uma chave mestre e criar chaves de dados, consulte as seguintes seções deste tutorial:
Criando uma chave mestre
Tanto a criptografia automática quanto a criptografia explícita exigem uma chave mestre de criptografia. Essa chave mestre é usada para criptografar chaves de dados, que, por sua vez, são usadas para criptografar os dados do usuário. A chave mestre pode ser gerada de duas maneiras: criando uma chave local ou criando uma chave em um serviço de gerenciamento de chaves. Atualmente, o driver Ruby é compatível com o Amazon Web Services Key Management Service (KMS), o Azure Key Vault e o GCP Key Management Service (GCP KMS).
Chave mestra local
Uma chave mestre local é uma string binária de 96 bytes. Ele deve ser mantido em sua máquina como uma variável de ambiente ou em um arquivo de texto.
Aviso
Usar uma chave mestra local não é seguro e não é recomendado se você planeja usar a criptografia do lado do cliente na produção.
Execute o seguinte código para gerar uma chave mestre local usando Ruby:
local_master_key = SecureRandom.random_bytes(96) # => "\xB2\xBE\x8EN\xD4\x14\xC2\x13\xC3..." (a binary blob)
Chave mestra remota
É recomendável usar um KMS remoto para criar e armazenar sua chave mestre. Para fazer isso, siga as etapas de "Configurar uma chave mestre remota" na documentação de criptografia do lado do cliente do MongoDB.
Para obter mais informações sobre como criar uma chave mestre, consulte a seção Criar uma chave mestre no manual do MongoDB.
Criando uma chave de dados
Após criar uma chave mestre, crie uma chave de dados chamando o método #create_data_key em uma instância da classe Mongo::ClientEncryption . Esse método gera uma nova chave de dados e a insere na key vault collection, que é a collection do MongoDB na qual você escolhe armazenar suas chaves de dados. O método #create_data_key retorna o ID da chave de dados recém-criada na forma de um objeto BSON::Binary.
Criar uma chave de dados usando uma chave mestre local
Se você criou uma chave mestre local, poderá usá-la para gerar uma nova chave de dados com o seguinte trecho de código:
Aviso
Usar uma chave mestra local não é seguro e não é recomendado se você planeja usar a criptografia do lado do cliente na produção.
# A Mongo::Client instance that will be used to connect to the key vault # collection. Replace the server address with the address of the MongoDB # server where you would like to store your key vault collection. key_vault_client = Mongo::Client.new(['localhost:27017']) client_encryption = Mongo::ClientEncryption.new( key_vault_client, # Replace with the database and collection names for your key vault collection key_vault_namespace: 'encryption.__keyVault', kms_providers: { local: { key: local_master_key } } ) data_key_id = client_encryption.create_data_key('local') # => <BSON::Binary... type=ciphertext...>
Consulte a seção Chave mestre local para obter mais informações sobre como gerar uma nova chave mestre local.
Criar uma chave de dados usando uma chave mestre remota
Se você tiver criado uma chave mestra do AWS KMS, anote o ID da chave de acesso e a chave de acesso secreta do usuário do IAM que tem permissões para usar a chave. Além disso, anote a região da Amazon Web Services e o Número de Recurso da Amazon (ARN) da sua chave mestra. Você usará essas informações para gerar uma chave de dados.
Se você tiver criado uma chave mestra do Azure, anote a ID do locatário, a ID do cliente e o segredo do cliente do aplicativo que tem permissões para usar a chave. Além disso, anote o nome da chave, a versão da chave (se houver) e o endpoint do key vault da sua chave mestra. Você usará essas informações para gerar uma chave de dados.
Se você criou uma chave mestra GCP KMS, anote o e-mail e a chave privada, e o segredo do cliente do aplicativo que tem permissões para usar a chave. Além disso, anote a ID do projeto, a localização, o chaveiro, o nome da chave e a versão da chave (se houver) para sua chave mestre. Você usará essas informações para gerar uma chave de dados.
Observe que a chave privada do GCP pode estar em formatos diferentes. O driver Ruby suporta chave privada RSA codificada por DER como cadeia de caracteres codificada base64. Para MRI Ruby, o driver também suporta chave privada RSA codificada por PEM.
Se você criou uma chave mestre usando um servidor de gerenciamento de chaves compatível com o Protocolo de Interoperabilidade de Gerenciamento de Chaves (KMIP), anote o host e a porta do servidor, e o ID da chave. Você usará essas informações para gerar uma chave de dados. Talvez você também precise de certificados de autoridade de certificação, bem como de seu certificado de cliente e chave privada para autenticar no servidor KMIP.
# A Mongo::Client instance that will be used to connect to the key vault # collection. Replace the server address with the address of the MongoDB # server where you would like to store your key vault collection. key_vault_client = Mongo::Client.new(['localhost:27017']) client_encryption = Mongo::ClientEncryption.new( key_vault_client, # Replace with the database and collection names for your key vault collection key_vault_namespace: 'encryption.__keyVault', kms_providers: { aws: { access_key_id: 'IAM-ACCESS-KEY-ID', secret_access_key: 'IAM-SECRET-ACCESS-KEY' }, azure: { tenant_id: 'AZURE-TENANT-ID', client_id: 'AZURE-CLIENT-ID', client_secret: 'AZURE-CLIENT-SECRET' }, gcp: { email: 'GCP-EMAIL', # :private_key value should be GCP private key as base64 encoded # DER RSA private key, or PEM RSA private key, if you are using MRI Ruby. private_key: 'GCP-PRIVATE-KEY', }, kmip: { # KMIP server endpoint may include port. endpoint: 'KMIP-SERVER-HOST' }, # TLS options to connect to KMIP server. kms_tls_options: { kmip: { ssl_ca_cert: 'PATH-TO-CA-FILE', ssl_cert: 'PATH-TO-CLIENT-CERT-FILE', ssl_key: 'PATH-TO-CLIENT-KEY-FILE' } } } ) aws_data_key_id = client_encryption.create_data_key( 'aws', { master_key: { region: 'REGION-OF-YOUR-MASTER-KEY', key: 'ARN-OF-YOUR-MASTER-KEY' } } ) # => <BSON::Binary... type=ciphertext...> azure_data_key_id = client_encryption.create_data_key( 'azure', { master_key: { key_vault_endpoint: 'AZURE-KEY-VAULT-ENDPOINT', key_name: 'AZURE-KEY-NAME' } } ) # => <BSON::Binary... type=ciphertext...> gcp_data_key_id = client_encryption.create_data_key( 'gcp', { master_key: { project_id: 'GCP-PROJECT-ID', location: 'GCP-LOCATION', key_ring: 'GCP-KEY-RING', key_name: 'GCP-KEY-NAME', } } ) # => <BSON::Binary... type=ciphertext...>
Consulte a seção Chave mestre remota deste tutorial para obter mais informações sobre como gerar uma nova chave mestre remota e encontrar as informações necessárias para criar chaves de dados.
Para obter mais informações sobre como criar uma chave de dados, consulte a seção Criar uma chave de criptografia de dados no manual do MongoDB.
Para obter uma lista de possíveis opções do KMS TLS, consulte Criar referência do cliente. O construtor Mongo::ClientEncryption aceita as mesmas opções ssl_ que Mongo::Client.
Opções de criptografia automática
A criptografia automática pode ser configurada em um Mongo::Client utilizando a auto_encryption_options opção Hash. Esta seção fornece uma visão geral dos campos dentro do auto_encryption_options e explica como escolher seus valores.
:key_vault_client
O cofre do cliente de chaves é uma instância do Mongo::Client que será utilizada para se conectar à collection do MongoDB que contém suas chaves de dados de criptografia. Por exemplo, se o seu cofre de chaves foi hospedado em uma instância MongoDB em localhost:30000 :
key_vault_client = Mongo::Client.new(['localhost:30000']) Mongo::Client.new(['localhost:27017], auto_encryption_options: { key_vault_client: key_vault_client, # ... (Fill in other options here) } )
Se suas chaves de dados forem armazenadas na mesma instância do MongoDB que armazena seus dados criptografados, você poderá deixar essa opção em branco, e o cliente de nível superior será usado para inserir e buscar chaves de dados.
:key_vault_namespace
O namespace do cofre de chaves é um String no formato "database_name.collection_name", onde database_name e collection_name são o nome do reconhecimento de data center e da collection na qual você gostaria de armazenar suas chaves de dados. Por exemplo, se suas chaves de dados estiverem armazenadas no reconhecimento de data center encryption na collection __keyVault :
Mongo::Client.new(['localhost:27017], auto_encryption_options: { key_vault_namespace: 'encryption.__keyVault', # ... (Fill in other options here) } )
Não há nenhum namespace de cofre de chave padrão, e essa opção deve ser fornecida.
:kms_providers
Um hash que contém nomes de provedores KMS como chaves e opções de provedores como valores.
Mongo::Client.new(['localhost:27017], auto_encryption_options: { key_vault_namespace: 'encryption.__keyVault', kms_providers: { aws: { access_key_id: 'IAM-ACCESS-KEY-ID', secret_access_key: 'IAM-SECRET-ACCESS-KEY' }, azure: { tenant_id: 'AZURE-TENANT-ID', client_id: 'AZURE-CLIENT-ID', client_secret: 'AZURE-CLIENT-SECRET' }, gcp: { email: 'GCP-EMAIL', # :private_key value should be GCP private key as base64 encoded # DER RSA private key, or PEM RSA private key, if you are using MRI Ruby. private_key: 'GCP-PRIVATE-KEY', }, kmip: { # KMIP server endpoint may include port. endpoint: 'KMIP-SERVER-HOST' }, # TLS options to connect to KMIP server. kms_tls_options: { kmip: { ssl_ca_cert: 'PATH-TO-CA-FILE', ssl_cert: 'PATH-TO-CLIENT-CERT-FILE', ssl_key: 'PATH-TO-CLIENT-KEY-FILE' } } } } )
O cliente pode recuperar credenciais da Amazon Web Services do ambiente ou dos endpoints de metadados EC2 ou ECS. Para recuperar credenciais automaticamente, especifique um Hash vazio como opções de provedor de KMS para AWS:
Mongo::Client.new(['localhost:27017'], auto_encryption_options: { key_vault_namespace: 'encryption.__keyVault', kms_providers: { aws: {} } } )
Consulte "Recuperando credenciais automaticamente" para obter informações mais detalhadas sobre a recuperação de credenciais.
O cliente pode recuperar credenciais do GCP dos endpoints de metadados do Google Compute Engine. Para recuperar credenciais automaticamente, especifique um Hash vazio como opções de provedor de KMS para GCP:
Mongo::Client.new(['localhost:27017'], auto_encryption_options: { key_vault_namespace: 'encryption.__keyVault', kms_providers: { gcp: {} } } )
:kms_tls_options
Um Hash que contém nomes de fornecedores KMP como chaves e opções de TLS para se conectar a provedores correspondentes.
Mongo::Client.new(['localhost:27017], auto_encryption_options: { key_vault_namespace: 'encryption.__keyVault', kms_providers: { kmip: { endpoint: 'KMIP-SERVER-HOST' } }, kms_tls_options: { kmip: { ssl_ca_cert: 'PATH-TO-CA-FILE', ssl_cert: 'PATH-TO-CLIENT-CERT-FILE', ssl_key: 'PATH-TO-CLIENT-KEY-FILE' } } } )
:schema_map
Um mapa de esquema é um Hash com informações sobre quais campos criptografar e descriptografar automaticamente.
O trecho de código na parte superior deste tutorial demonstra a criação de um mapa de esquema usando um Ruby Hash. Embora isso funcione, os mapas de esquema podem ficar bem grandes e pode ser desajeitado incluí-los em seu código Ruby. Em vez disso, é recomendável armazená-los em um arquivo JSON (JavaScript objeto Notation) separado.
Antes de criar o arquivo JSON, codifique em Base64 o UUID da sua chave de dados.
Base64.encode64(data_key_id.data) # => "sr6OTtQUwhPD..." (a base64-encoded string)
Em seguida, crie um novo arquivo JSON contendo seu mapa de esquema no formato definido pela sintaxe padrão do JSON schema rascunho 4 . Você pode ler mais sobre como formatar seu mapa de esquema na seção Regras de criptografia automática do manual MongoDB.
{ "encryption_db.encryption_coll": { "properties": { "encrypted_field": { "encrypt": { "keyId": [{ "$binary": { "base64": "YOUR-BASE64-ENCODED-DATA-KEY-ID", "subType": "04" } }], "bsonType": "string", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" } } }, "bsonType": "object" } }
Quando você pretende usar seu mapa de esquema, converta-o para um Ruby Hash usando o módulo BSON::ExtJSON na joia Ruby bson .
schema_map = BSON::ExtJSON.parse(File.read('/path/to/your/file.json')) # => { 'encryption_db.encryption_coll' => { ... } } Mongo::Client.new(['localhost:27017], auto_encryption_options: { schema_map: schema_map, # ... (Fill in other options here) } )
Observação
Também é possível fornecer um mapa de esquema como validador em uma collection MongoDB. Isto é denominado "mapa de esquema remoto", enquanto fornecer o mapa de esquema como uma opção no Mongo::Client é chamado de "mapa de esquema local."
Fornecer um mapa de esquema local oferece mais segurança do que confiar em JSON schemas obtidos do servidor. Ele protege contra um servidor malicioso anunciando um JSON schema falso, que pode induzir o cliente a enviar dados não criptografados que devem ser criptografados.
Consulte Aplicação de criptografia em nível de campo do lado do servidor no manual do MongoDB para obter mais informações sobre como usar o mapa de esquema para criar um validador de JSON schema em sua coleção.
:schema_map_path
Também é possível carregar o mapa do esquema de um arquivo. Prepare o mapa do esquema conforme descrito acima, salve-o no arquivo e, em seguida, passe o caminho para o arquivo usando a opção :schema_map_path .
Mongo::Client.new(['localhost:27017], auto_encryption_options: { schema_map_path: '/path/to/your/file.json', # ... (Fill in other options here) } )
:bypass_auto_encryption
A opção :bypass_auto_encryption é um Boolean que especifica se o Mongo::Client deve ignorar a criptografia ao gravar no reconhecimento de data center. Se :bypass_auto_encryption for true, o cliente ainda executará a descriptografia automática de quaisquer dados criptografados anteriormente.
Mongo::Client.new(['localhost:27017], auto_encryption_options: { bypass_auto_encryption: true, # ... (Fill in other options here) } )
:extra_options
:extra_options é um Hash de opções relacionadas à criação de mongocryptd. Cada opção neste Hash tem um valor padrão, portanto, só é necessário fornecer as opções cujos padrões você deseja substituir.
:mongocryptd_spawn_args- Este é umArray<String>contendo argumentos para gerar o mongocryptd. O driver Ruby passará esses argumentos para o mongocryptd ao gerar o daemon. Os possíveis argumentos são:"--idleShutdownTimeoutSecs"- O número de segundos que o mongocryptd deve permanecer inativo antes de se desligar. O valor padrão é 60."--port"- A porta na qual o mongocryptd escutará as conexões. O padrão é 27020.
:mongocryptd_uri- O URI que o driver usará para se conectar ao mongocryptd. Por padrão, é"mongodb://localhost:27020".:mongocryptd_spawn_path- O caminho para o executável mongocryptd. O padrão é"mongocryptd".:mongocryptd_bypass_spawn- UmBooleanindicando se o driver deve ignorar a criação de mongocryptd.
Por exemplo, se você deseja executar o mongocryptd na porta 30000, forneça extra_options da seguinte forma:
Mongo::Client.new(['localhost:27017], auto_encryption_options: { extra_options: { mongocryptd_spawn_args: ['--port=30000'], mongocryptd_uri: 'mongodb://localhost:30000', } # ... (Fill in other options here) } )
Aviso
O conteúdo de :extra_options está sujeito a alterações em versões futuras da API de criptografia do lado do cliente.