Classe: Mongo::Crypt::ExplicitEncrypter Private

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Definido em:
lib/mongo/crypt/explicit_encrypter.rb

Visão geral

Esta classe faz parte de uma API privada. Evite usar essa classe, se possível, pois ela pode ser removida ou alterada no futuro.

Um ExplicitEncrypter é um objeto que executa operações de criptografia explícitas e lida com todas as opções associadas e variáveis de instância.

Recolhimento do Resumo do método de instância

Detalhes do construtor

#initialize(key_vault_client, key_vault_namespace, kms_providers, kms_tls_options, timeout_ms = nil, key_expiration_ms = nil) ⇒ ExplicitEncrypter

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Crie um novo objeto ExplicitEncrypter.

Parâmetros:

  • key_vault_client (Mongo::Client) —

    Uma instância do Mongo::Client para se conectar à coleção de cofre de chaves.

  • key_vault_namespace (string) —

    O namespace da coleção do cofre de chaves no formato "db_name.collection_name".

  • kms_providers (Criptografia::KMS::Credenciais) —

    Um hash de informações de configuração do KMS.

  • kms_tls_options (Hash) —

    Opções de TLS para se conectar a provedores de KMS. As chaves do hash devem ser nomes de provedor KSM; Os valores devem ser hashes de opções de conexão TLS . As opções são equivalentes às opções de conexão TLS do Mongo::Client.

  • timeout_ms (Inteiro | nulo) (padrão para: nil) —

    Tempo limite para cada operação executada neste objeto.

  • key_expiration_ms (Inteiro | nulo) (padrão para: nil) —

    A duração do cache da chave de criptografia de dados, em milissegundos. Um valor de 0 significa que o cache nunca expira. Quando nil, o padrão de libmongocrypt de 60000 é usado.



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 43

def inicializar(
  key_vault_client, key_vault_namespace, kms_providers, kms_tls_options,
  timeout_ms = nada, key_expiration_ms = nada
)
  Criptografar.validate_ffi!
  @crypt_handle = Lidar.Novo(
    kms_providers,
    kms_tls_options,
    explicitamente_encryption_only: true,
    key_expiration_ms: key_expiration_ms
  )
  @encryption_io = EncryptionIO.Novo(
    key_vault_client: key_vault_client,
    metadata_client: nada,
    key_vault_namespace: key_vault_namespace
  )
  @timeout_ms = timeout_ms
end

Detalhes do método de instância

#add_key_alt_name(ID, key_alt_name) ➤ BSON::Document | nada

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adiciona um key_alt_name para a chave na key vault collection com o ID fornecido.

Parâmetros:

  • id (BSON::Binary) —

    ID da chave para adicionar o novo nome alternativo da chave.

  • key_alt_name (string) —

    Novo nome alternativo da chave para adicionar.

Retorna:

  • (BSON::Document | nil) —

    Documento que descreve a chave identificada antes de adicionar o nome alternativo da chave ou nulo se não houver essa chave.



218
219
220
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 218

def add_key_alt_name(id, key_alt_name)
  @encryption_io.add_key_alt_name(id, key_alt_name, timeout_ms: @timeout_ms)
end

#create_and_insert_data_key(master_key_document, key_alt_names, key_material = nil) ➤ BSON::Binary

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Gera uma chave de dados usada para criptografia/descriptografia e armazena essa chave na coleção KMS. A chave gerada é criptografada com a chave mestre KMS.

Parâmetros:

  • master_key_document (Mongo::Crypt::KMS::MasterKeyDocument) —

    O documento de chave mestra que contém parâmetros de chave mestra de criptografia.

  • key_alt_names (Array<String> | nil) —

    Uma array opcional de strings especificando nomes alternativos para a nova chave de dados.

  • key_material (string | nil) (padrão para: nil) —

    96 bytes opcionais para utilizar como material de chave personalizado para a chave de dados que está sendo criada. Se a opção key_material for fornecida, o material da chave personalizada será usado para criptografar e descriptografar dados.

Retorna:

  • (BSON::Binary) —

    O 16bytes UUID da nova chave de dados como um objeto BSON::Binary com tipo :uuid.



77
78
79
80
81
82
83
84
85
86
87
88
89
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 77

def create_and_insert_data_key(master_key_document, key_alt_names, key_material = nada)
  data_key_document = Criptografar::DataKeyContext.Novo(
    @crypt_handle,
    @encryption_io,
    master_key_document,
    key_alt_names,
    key_material
  ).run_state_machine(timeout_holder)

  @encryption_io.insert_data_key(
    data_key_document, timeout_ms: timeout_holder.remaining_timeout_ms!
  ).insert_id
end

#descriptografar(valor) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Descriptografa um valor que já foi criptografado

Parâmetros:

  • valor (BSON::Binary) —

    Um objeto binário BSON do subtipo 6 (texto cifrado) que será descriptografado

Retorna:

  • (Objeto) —

    O valor descriptografado



203
204
205
206
207
208
209
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 203

def Descriptografar(valor)
  Criptografar::ExplicitDecryptionContext.Novo(
    @crypt_handle,
    @encryption_io,
    { v: valor }
  ).run_state_machine(timeout_holder)['v']
end

#delete_key(ID) ➤ Operação::Result

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Remove a chave com o ID fornecido da coleção de cofre de chave.

Parâmetros:

  • id (BSON::Binary) —

    ID da chave a ser excluída.

Retorna:

  • (Operação::Resultado) —

    A resposta do banco de dados para a operação delete_one que exclui a chave.



228
229
230
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 228

def delete_key(id)
  @encryption_io.delete_key(id, timeout_ms: @timeout_ms)
end

#encrypt(value, options) ➤ BSON::Binary

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Observação:

As opções :key_id e :key_alt_name são mutuamente exclusivas. Apenas um é necessário para executar a criptografia explícita.

Criptografa um valor usando a chave de encriptação e o algoritmo especificados

Parâmetros:

  • valor (Objeto) —

    O valor a ser criptografado

  • opções (Hash)

Hash de opções (opções):

  • :key_id (BSON::Binary) —

    Um objeto BSON::Binary do tipo :uuid representando o UUID da chave de criptografia conforme armazenado na coleção de cofre de chaves.

  • :key_alt_name (string) —

    O nome alternativo da chave de criptografia.

  • :algorithm (string) —

    O algoritmo usado para criptografar o valor. Algoritmos válidos são "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic", "AEAD_AES_256_CBC_HMAC_SHA_512-Random", "Indexed", "Unindexed", "Range", "String" .

  • :contention_factor (Inteiro | nulo) —

    Fator de contenção a ser aplicado se o algoritmo de criptografia estiver definido como "Indexed", "Range" ou "String". Se não for fornecido, o padrão será um valor de 0. O fator de contenção deverá ser definido somente se o algoritmo de criptografia estiver definido como "Indexed", "Range" ou "String".

  • :query_type (string | nil) —

    Tipo de query a ser aplicado se o algoritmo de criptografia estiver definido como "Indexed", "Range" ou "String". Os valores permitidos são "igualdade" (para "Indexado"), "variação" (para "Intervalo"), e "prefixo", "sufixo", "substring" (para "String").

  • :range_opts (Hash | nulo) —

    Especifica as opções de índice para um campo de Queryable Encryption que oferece suporte a "range" consultas. Obrigatório quando o algoritmo é "Intervalo".

  • :string_opts (Hash | nulo) —

    Especifica as opções de índice para um campo de Queryable Encryption que oferece suporte a "prefixo", "sufixo" ou "substring" consultas. Obrigatório quando o algoritmo é "String".

Retorna:

  • (BSON::Binary) —

    Um objeto binário BSON do subtipo 6 (texto cifrado) representando o valor criptografado

Aumenta:

  • (ArgumentError) —

    se container_factor ou query_type estiver definido e o algoritmo não for "Indexado", "Range" ou "String".



128
129
130
131
132
133
134
135
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 128

def criptografar(valor, opções)
  Criptografar::ExplicitEncryptionContext.Novo(
    @crypt_handle,
    @encryption_io,
    { v: valor },
    opções
  ).run_state_machine(timeout_holder)['v']
end

#encrypt_expression(expressão, opções) ➤ BSON::Binary

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Observação:

O algoritmo Range é apenas experimental. Não é

Observação:

As opções :key_id e :key_alt_name são mutuamente exclusivas. Apenas um é necessário para executar a criptografia explícita.

Criptografa uma expressão de correspondência ou expressão de agregação para consultar um índice de faixa.

Somente suportado quando queryType for "faixa" e algoritmo for "faixa". @note: o algoritmo faixa é apenas experimental. Não se destina ao uso público. Ele está sujeito a alterações interruptivas.

@param [ Hash ] opções

destinado ao uso público.

Exemplos:

Criptografar expressão de correspondência.

encryption.encrypt_expression(
  {'$and' =>  [{'field' => {'$gt' => 10}}, {'field' =>  {'$lt' => 20 }}]}
)

Criptografar expressão agregada.

encryption.encrypt_expression(
  {'$and' =>  [{'$gt' => ['$field', 10]}, {'$lt' => ['$field', 20]}}
)
{$and: [{$gt: [<fieldpath>, <value1>]}, {$lt: [<fieldpath>, <value2>]}]

Parâmetros:

  • expressão (Hash) —

    Expressão a ser criptografada.

  • opções (Hash) —

    um conjunto personalizável de opções

Hash de opções (opções):

  • :key_id (BSON::Binary) —

    Um objeto BSON::Binary do tipo :uuid representando o UUID da chave de criptografia conforme armazenado na coleção de cofre de chaves.

  • :key_alt_name (string) —

    O nome alternativo da chave de criptografia.

  • :algorithm (string) —

    O algoritmo utilizado para criptografar a expressão. O único valor permitido é "faixa"

  • :contention_factor (Inteiro | nulo) —

    Fator de contenção a ser aplicado Se não for fornecido, o padrão será um valor de 0.

  • query_type (string | nil) —

    Tipo de query a ser aplicada. O único valor permitido é "faixa".

  • :range_opts (Hash | nulo) —

    Especifica opções de índice para um campo de Queryable Encryption que oferece suporte a queries de "faixa". As opções permitidas são:

    • :min
    • :max
    • :trim_factor
    • :sparsity
    • :precision min, max, trim_factor, sparsity e preciso devem corresponder aos valores definidos nos encryptionFields da coleção de destino. Para double e decimal128, min/max/precision devem todos ser definidos ou todos desconfigurados.

Retorna:

  • (BSON::Binary) —

    Um objeto Binary BSON do subtipo 6 (texto cifrado) representando a expressão criptografada.

Aumenta:

  • (ArgumentError) —

    se valores não permitidos nas opções estiverem definidos.



188
189
190
191
192
193
194
195
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 188

def encryption_expression(expressão, opções)
  Criptografar::ExplicitEncryptionExpressionContext.Novo(
    @crypt_handle,
    @encryption_io,
    { v: expressão },
    opções
  ).run_state_machine(timeout_holder)['v']
end

#get_key(id) ⇒ BSON::Document | nil

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Encontra uma única chave com o ID fornecido.

Parâmetros:

  • id (BSON::Binary) —

    ID da chave a ser obtida.

Retorna:

  • (BSON::Document | nil) —

    O documento chave encontrado ou nulo se não for encontrado.



238
239
240
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 238

def get_key(id)
  @encryption_io.get_key(id, timeout_ms: @timeout_ms)
end

#get_key_by_alt_name(key_alt_name) ➤ BSON::Document | nada

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna uma chave na key vault collection com o key_alt_name fornecido.

Parâmetros:

  • key_alt_name (string) —

    Nome alternativo da chave para encontrar uma chave.

Retorna:

  • (BSON::Document | nil) —

    O documento chave encontrado ou nulo se não for encontrado.



248
249
250
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 248

def get_key_by_alt_name(key_alt_name)
  @encryption_io.get_key_by_alt_name(key_alt_name, timeout_ms: @timeout_ms)
end

#get_keys ➤ Collection::View

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna todas as chaves na key vault collection.

rubocop:disable Naming/AccessorMethodName O nome deste método é definido na especificação FLE

Retorna:



257
258
259
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 257

def get_keys
  @encryption_io.get_keys(timeout_ms: @timeout_ms)
end

#remove_key_alt_name(ID, key_alt_name) ➤ BSON::Document | nada

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Remove um key_alt_name de uma chave na key vault collection com o ID fornecido.

Parâmetros:

  • id (BSON::Binary) —

    ID da chave para remover o nome alternativo da chave.

  • key_alt_name (string) —

    Nome alternativo da chave a ser removido.

Retorna:

  • (BSON::Document | nil) —

    Documento que descreve a chave identificada antes de remover o nome alternativo da chave ou nulo se não houver essa chave.



269
270
271
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 269

def remove_key_alt_name(id, key_alt_name)
  @encryption_io.remove_key_alt_name(id, key_alt_name, timeout_ms: @timeout_ms)
end

#rewrap_many_data_key(filter, opts = {}) ➤ Crypt::RewrapManyDataKeyResult

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Descriptografa várias chaves de dados e (re)criptografa-as com uma nova master_key ou com sua master_key atual se uma nova não for fornecida.

Parâmetros:

  • filtro, filtro (Hash) —

    Filtro usado para encontrar chaves a serem atualizadas.

  • opções (Hash)

Retorna:



284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
 
# Arquivo 'lib/mongo/crypt/explicit_encrypter.rb', linha 284

def rewrap_many_data_key(filtro, filtro, opciona = {})
  validate_rewrap_options!(opciona)

  master_key_document = master_key_for_provider(opciona)

  rewrap_result = Criptografar::RewrapManyDataKeyContext.Novo(
    @crypt_handle,
    @encryption_io,
    filtro, filtro,
    master_key_document
  ).run_state_machine(timeout_holder)

  Método RewrapManyDataKeyResult.Novo(nada) se rewrap_result.nada?

  Atualizações = Updates_from_data_key_documents(rewrap_result.buscar('v'))
  RewrapManyDataKeyResult.Novo(
    @encryption_io.update_data_keys(Atualizações, timeout_ms: @timeout_ms)
  )
end