Classe: Mongo::Crypt::EncryptionIO Privado

Herda:
Objeto
  • Objeto
mostrar tudo
Definido em:
lib/mongo/crypt/encryption_io.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.

Uma classe que implementa métodos de E/S entre o driver e o servidor MongoDB ou mongocryptd.

Colapsode resumo constante

SOCKET_TIMEOUT =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

Tempo limite usado para conexão, leitura e gravação do soquete TLS. Não há um tempo limite específico escrito nas especificações. Consulte Especificação1394 para uma discussão e atualizações sobre qual deve ser esse tempo limite.

10

Recolhimento do Resumo do método de instância

Detalhes do construtor

#initialize(key_vault_namespace:, key_vault_client:, metadata_client:, cliente: nil, mongocryptd_client: nil, mongocryptd_options: {}) ➤ EncryptionIO

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:

Ao ser usado para criptografia automática, todos os argumentos são necessários. Ao ser usado para criptografia explícita, somente os argumentos key_vault_namespace e key_vault_client são necessários.

Observação:

Esta classe espera que as opções key_vault_client e key_vault_namespace não sejam nulas e estejam no formato correto.

Cria um novo objeto EncryptionIO com informações sobre como se conectar ao cofre de chaves.

Parâmetros:

  • Cliente (Mongo::Client) (padrão para: nil) —

    O cliente usado para se conectar à collection que armazena os documentos criptografados, o padrão é nulo.

  • mongocryptd_client (Mongo::Client) (padrão para: nil) —

    O cliente conectado ao mongocryptd, o padrão é nil.

  • key_vault_client (Mongo::Client) —

    O cliente conectado à coleção do cofre de chaves.

  • metadata_client (Mongo::Client | nil) —

    O cliente a ser usado para obter metadados da coleção.

  • key_vault_namespace (string) —

    O namespace do cofre de chaves no formato db_name.collection_name.

  • mongocryptd_options (Hash) (padrão para: {}) —

    Opções relacionadas ao mongocryptd.

Opções de hash (mongocryptd_options:):

  • :mongocryptd_bypass_spawn (Booleano)
  • :mongocryptd_spawn_path (string)
  • :mongocryptd_spawn_args (Array<String>) 


54
55
56
57
58
59
60
61
62
63
64
65
66
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 54

def inicializar(
  key_vault_namespace:, key_vault_client:, metadata_client:, cliente: nada, mongocryptd_client: nada, mongocryptd_options: {}
)
  validate_key_vault_client!(key_vault_client)
  validate_key_vault_namespace!(key_vault_namespace)

  @cliente = Cliente
  @mongocryptd_client = mongocryptd_client
  @key_vault_db_name, @key_vault_collection_name = key_vault_namespace.dividir('.')
  @key_vault_client = key_vault_client
  @metadata_client = metadata_client
  @opções = mongocryptd_options
end

Detalhes do método de instância

#add_key_alt_name(ID, key_alt_name, timeout_ms: nil) ➤ 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.

Adiciona um key_alt_name à array key_alt_names do documento de chave na coleção de cofre de chave com o ID fornecido.



187
188
189
190
191
192
193
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 187

def add_key_alt_name(id, key_alt_name, timeout_ms: nada)
  key_vault_collection.find_one_and_update(
    { _id: id },
    { '$addToSet' => { keyAltNames: key_alt_name } },
    timeout_ms: timeout_ms
  )
end

#collection_info(db_name, filtro, timeout_ms: nil) ⇒ array<BSON::Document>

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.

Obtenha informações da collection para uma collection que corresponda ao filtro fornecido

Parâmetros:

  • filtro, filtro (Hash)
  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o recurso não está ativado.

Retorna:

  • (Array<BSON::Document>) —

    Os documentos de informações da coleção



101
102
103
104
105
106
107
108
109
110
111
112
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 101

def collection_info(db_name, filtro, filtro, timeout_ms: nada)
  a menos que @metadata_client
    aumentar ArgumentError,
          'collection_info exige que metadata_client tenha sido passado para o construtor, mas não foi'
  end

  @metadata_client
    .Usar(db_name)
    .database
    .list_collections(filtro: filtro, filtro, deserialize_as_bson: true, timeout_ms: timeout_ms)
    .to_a
end

#delete_key(ID, timeout_ms: nil) ➤ Object

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 o documento chave com o ID fornecido da collection do cofre de chaves.



197
198
199
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 197

def delete_key(id, timeout_ms: nada)
  key_vault_collection.delete_one(_id: id, timeout_ms: timeout_ms)
end

#feed_kms(kms_context, tls_options, timeout_ms: nil) ➤ Object

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.

Obtenha informações sobre a chave de encriptação do KMS remoto e insira-as no objeto KmsContext

Parâmetros:

  • kms_context (Mongo::Crypt::KmsContext) —

    Um objeto KmsContext correspondente a uma chave de dados KMS remota. Contém informações sobre o endpoint no qual estabelecer uma conexão TLS e a mensagem a ser enviada nessa conexão.

  • tls_options. (Hash) —

    Opções de TLS para se conectar ao provedor de KMS. As opções são as mesmas que para Mongo::Client.

  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o recurso não está ativado.



165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 165

def feed_kms(kms_context, tls_options, timeout_ms: nada)
  with_ssl_socket(kms_context.endpoint, tls_options) fazer |ssl_socket|
    Tempo-limite.timeout(timeout_ms || SOCKET_TIMEOUT, Erro::SocketTimeoutError,
                    ' Aoperação de gravação do soquete atingiu o tempo limite') fazer
      ssl_socket.escrita do sistema(kms_context.mensagem)
    end

    bytes_needed = kms_context.bytes_needed
    enquanto bytes_needed > 0
      bytes = Tempo-limite.timeout(timeout_ms || SOCKET_TIMEOUT, Erro::SocketTimeoutError,
                              ' Aoperação de leitura do soquete atingiu o tempo limite') fazer
        ssl_socket.sysread(bytes_needed)
      end

      kms_context.feed(bytes)
      bytes_needed = kms_context.bytes_needed
    end
  end
end

#find_keys(filter, timeout_ms: nil) ➤ Array<BSON::Document>

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.

Faça query de chaves na coleção de cofre de chaves usando o filtro fornecido

Parâmetros:

  • filtro, filtro (Hash)
  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o recurso não está ativado.

Retorna:

  • (Array<BSON::Document>) —

    Os resultados da query



77
78
79
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 77

def find_keys(filtro, filtro, timeout_ms: nada)
  key_vault_collection.find(filtro, filtro, timeout_ms: timeout_ms).to_a
end

#get_key(ID, timeout_ms: nil) ➤ 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.

Encontra um único documento-chave com o ID fornecido.



202
203
204
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 202

def get_key(id, timeout_ms: nada)
  key_vault_collection.find(_id: id, timeout_ms: timeout_ms).primeiro
end

#get_key_by_alt_name(key_alt_name, timeout_ms: nil) ➤ 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.

Retorna um documento de chave na coleção de cofre de chave com o key_alt_name fornecido.



208
209
210
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 208

def get_key_by_alt_name(key_alt_name, timeout_ms: nada)
  key_vault_collection.find(keyAltNames: key_alt_name, timeout_ms: timeout_ms).primeiro
end

#get_keys(timeout_ms: nil) ➤ 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.

Encontra todos os documentos na key vault collection.



213
214
215
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 213

def get_keys(timeout_ms: nada)
  key_vault_collection.find(nada, timeout_ms: timeout_ms)
end

#insert_data_key(documento, timeout_ms: nil) ➤ Mongo::Operation::Insert::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.

Inserir um documento na key vault collection

Parâmetros:

  • documento (Hash)
  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o recurso não está ativado.

Retorna:



89
90
91
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 89

def insert_data_key(documento, timeout_ms: nada)
  key_vault_collection.insert_one(documento, timeout_ms: timeout_ms)
end

#mark_command(cmd, db_name: nil, timeout_ms: nil) ⇒ Hash

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.

Envie o comando para mongocryptd para ser marcado com marcações de intenção de criptografia

Parâmetros:

  • cmd (Hash)
  • :db_name (string | nil) —

    O banco de dados no qual o comando está sendo executado. Quando fornecido, o comando é enviado para mongocryptd usando este banco de dados para que o namespace no comando corresponda ao namespace em encryptionInformation.

  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o recurso não está ativado.

Retorna:

  • (Hash) —

    O comando marcado



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 126

def marque_command(cmd, db_name: nada, timeout_ms: nada)
  a menos que @mongocryptd_client
    aumentar ArgumentError,
          'marque_command exige que mongocryptd_client tenha sido passado para o construtor, mas não foi'
  end

  # Certifique-se de que a resposta do mongocryptd seja desserializada com { mode: :bson }
  # para evitar a perda de informações de tipo em comandos
  opções = {
    execution_options: { deserialize_as_bson: true },
    timeout_ms: timeout_ms
  }

  mongocryptd = db_name ? @mongocryptd_client.Usar(db_name) : @mongocryptd_client

  começar
    Resposta = mongocryptd.database.comando(cmd, opções)
  salvar Erro::NoServerAvailable => e
    aumentar e se @opções[:mongocryptd_bypass_spawn]

    spawn_mongocryptd
    Resposta = mongocryptd.database.comando(cmd, opções)
  end

  Resposta.primeiro
end

#remove_key_alt_name(ID, key_alt_name, timeout_ms: nil) ➤ 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.

Remove um key_alt_name da array key_alt_names do documento de chave na coleção de cofre de chaves com o ID fornecido.



219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 219

def remove_key_alt_name(id, key_alt_name, timeout_ms: nada)
  key_vault_collection.find_one_and_update(
    { _id: id },
    [
      {
        '$set' => {
          keyAltNames: {
            '$cond' => [
              { '$eq' => [ '$keyAltNames', [ key_alt_name ] ] },
              '$$REMOVE',
              {
                '$filter' => {
                  entrada: '$keyAltNames',
                  cond: { '$ne' => [ '$$This', key_alt_name ] }
                }
              }
            ]
          }
        }
      }
    ],
    timeout_ms: timeout_ms
  )
end

#update_data_keys(updates, timeout_ms: nil) ⇒ BulkWrite::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.

Aplique as solicitações fornecidas à coleção de cofre de chaves usando gravação em massa.

Parâmetros:

  • pedidos (Array<Hash>) —

    As solicitações de escrita em massa.

Retorna:



249
250
251
 
# Arquivo 'lib/mongo/crypt/encryption_io.rb', linha 249

def update_data_keys(Atualizações, timeout_ms: nada)
  key_vault_collection.bulk_write(Atualizações, timeout_ms: timeout_ms)
end