Criptografia automática no nível do campo do lado do cliente

Instalar libmongocrypt

Isso pode ser feito de duas maneiras.

• Adicione a joia libmongocrypt-helper para o seu Gemfile ou

• Baixe o libmongocrypt arquivo de versão , extraia a versão que corresponde ao seu sistema operacional e defina a LIBMONGOCRYPT_PATH variável de ambiente adequadamente.

Instalar a biblioteca compartilhada de criptografia automática (driver Ruby 2.19+)

Se você usar a versão 2.19 do driver Ruby e superior, a biblioteca compartilhada de criptografia automática deverá ser instalada seguindo as instruções na página Biblioteca compartilhada de criptografia automática para Queryable Encryption no manual do servidor MongoDB.

As etapas necessárias são as seguintes:

1. Navegue até o centro de download do MongoDB

2. Na lista suspensa Versão, selecione x.y.z (current) (a versão atual mais recente).

3. Na lista suspensa Plataforma, selecione sua plataforma.

4. Na lista suspensa Pacote, selecione crypt_shared.

5. Clique em Baixar.

Depois de extraída, certifique-se de que o caminho completo para a biblioteca esteja configurado dentro do seu mongoid.yml da seguinte forma:

development:
  clients:
    default:
      options:
        auto_encryption_options:
          extra_options:
            crypt_shared_lib_path: '/path/to/mongo_crypt_v1.so'

Instale o mongocryptd (driver Ruby 2.18 ou anterior)

Se você estiver usando uma versão mais antiga do driver Ruby mongocryptd precisará ser instalado manualmente. 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.

Adicione ffi ao seu Gemfile

O driver Ruby do MongoDB usa a joia ffi para chamar funções de libmongocrypt. Como este gem não é uma dependência do driver, ele precisará ser adicionado manualmente ao seu Gemfile:

gem 'ffi'

Limitações conhecidas

• O MongoDB CSFLE tem algumas limitações descritas na página Limitações de CSFLE no manual do servidor MongoDB. Essas limitações também se aplicam ao Mongoid.

• O Mongoid não suporta criptografia de relacionamentos embeds_many .

• Se você usar a opção :key_name_field , o campo deverá ser criptografado usando algoritmo não determinístico. Para criptografar seu campo deterministicamente, você deve especificar a opção :key_id .

chave mestra do cliente

A chave mestra do cliente é a chave que você usa para criptografar suas chaves de criptografia de dados. O MongoDB criptografa automaticamente as chaves de criptografia de dados usando a CMK especificada durante a criação da chave de criptografia de dados.

O CMK é a chave mais sensível no CSFLE. Se a sua CMK estiver comprometida, todos os seus dados criptografados poderão ser descriptografados.

O MongoDB CSFLE suporta os seguintes fornecedores de Key Management System (KMS):

• KMS do Amazon Web Services

• Azure Key Vault

• KMS do Google Cloud Platform

• Qualquer sistema de gerenciamento de chaves compatível com KMIP

• Provedor de chaves locais (somente para testes)

Data Encryption Keys

As chaves de criptografia de dados podem ser criadas usando a tarefa db:mongoid:encryption:create_data_key Rake . Por padrão, eles são armazenados no mesmo cluster que o banco de dados. No entanto, pode ser uma boa ideia armazenar as chaves separadamente. Isso pode ser feito especificando um cliente de cofre de chave em mongoid.yml:

development:
  clients:
    key_vault:
      uri: mongodb+srv://user:pass@anothercluster.mongodb.net/blog_development?retryWrites=true&w=majority
    default:
      uri: mongodb+srv://user:pass@yourcluster.mongodb.net/blog_development?retryWrites=true&w=majority
      options:
        auto_encryption_options:
          key_vault_client: :key_vault # Client to connect to key vault
          # ...

Rotação das chaves de criptografia

Você pode girar chaves de encriptação usando o método rewrap_many_data_key do driver Ruby. Esse método descriptografa automaticamente várias chaves de encriptação de dados e as criptografa novamente usando uma CMK especificada. Em seguida, ele atualiza as chaves giradas na key vault collection. Este método permite girar chaves de encriptação com base em dois argumentos opcionais:

• Um filtro utilizado para especificar quais chaves devem ser rotacionadas. Se nenhuma chave de dados corresponder ao filtro fornecido, nenhuma chave será girada. Omita o filtro para rotacionar todas as chaves na sua Key Vault Collection.

• Um objeto que representa um novo CMK. Omitir este objeto para girar as chaves de dados usando seus CMKs atuais.

Aqui está um exemplo de rotação de chaves usando o Amazon Web Services KMS:

# Create a key vault client
key_vault_client = Mongo::Client.new('mongodb+srv://user:pass@yourcluster.mongodb.net')
# Or, if you declared the key value client in mongoid.yml, use it
key_vault_client = Mongoid.client(:key_vault)
# Create the encryption object
encryption = Mongo::ClientEncryption.new(
  key_vault_client,
  key_vault_namespace: 'encryption.__keyVault',
  kms_providers: {
    aws: {
      "accessKeyId": "<IAM User Access Key ID>",
      "secretAccessKey": "<IAM User Secret Access Key>"
    }
  }
)
encryption.rewrap_many_data_key(
  {}, # We want to rewrap all keys
  {
    provider: 'aws',
    master_key: {
      region: 'us-east-2',
      key: 'arn:aws:kms:us-east-2:...'
    }
  }
)

Adicionando criptografia automática a um projeto existente

O CSFLE automático do MongoDB suporta criptografia no local. Você pode ativar a criptografia para seu banco de dados existente e ainda poderá ler dados não criptografados. Todos os dados gravados no banco de dados serão criptografados. No entanto, assim que a criptografia estiver ativada, todas as operações de query usarão dados criptografados:

# We assume that there are two documents in the database, one created without
# encryption enabled, and one with encryption.
# We can still read both.
Patient.all.to_a
# =>
# [#<Patient _id: 644937ac46ebfd02468e58c8, category: "ER", passport_id: "DE-1257", blood_type: "AB+", ssn: 123456>,
# #<Patient _id: 644937c946ebfd029309b912, category: "ER", passport_id: "AT-1545", blood_type: "AB+", ssn: 987654>]
# But when we query, we can see only the latter one.
Patient.where(blood_type: 'AB+').to_a
# => [#<Patient _id: 644937c946ebfd029309b912, category: "ER", passport_id: "AT-1545", blood_type: "AB+", ssn: 987654>]

Se você deseja criptografar o banco de dados existente, isso pode ser feito lendo e write back todos os dados, mesmo sem nenhuma alteração. Se você decidir fazer isso, tenha em mente o seguinte:

• Valide a integridade dos dados existentes para obter uma fidelidade consistente. O CSFLE é sensível ao tipo - por exemplo, você não pode armazenar números inteiros em um campo declarado como String.

• Para strings, certifique-se de que os valores vazios sejam sempre strings vazias ou apenas não estejam definidos, mas não nil (o CSFLE não é compatível com o null nativo).

• Esta operação requer tempo de inatividade do aplicativo.