Menu Docs
Página inicial do Docs
/
Línguas
/
Scala
/
Scala
/
Tutoriais

Criptografia do lado do cliente

Nesta página

  • Instalação
  • libmongocrypt
  • Configuração do mongocryptd
  • Exemplos
  • Criptografia e descriptografia automáticas
  • Especifique uma chave de encriptação de dados e campos criptografados
  • criptografia explícita e descriptografia
  • Criptografia explícita e descriptografia automática

A partir de v4.2, O MongoDB oferece suporte à criptografia do lado do cliente. A criptografia do lado do cliente permite que administradores e desenvolvedores criptografem campos de dados específicos, além de fornecer outros recursos de criptografia MongoDB.

Com a criptografia em nível de campo, os desenvolvedores podem criptografar campos no lado do cliente sem nenhuma configuração ou diretiva no lado do servidor. A criptografia no nível do campo no lado do cliente oferece suporte a cargas de trabalho em que os aplicativos devem garantir que partes não autorizadas, incluindo administradores de servidor, não possam ler os dados criptografados.

Observação

Este guia usa as implicações implícitas de Observable , conforme abordadas no Quick Start Primary.

Instalação

A maneira recomendada de começar a usar a criptografia em nível de campo em seu projeto é usando um sistema de gerenciamento de dependências. A criptografia em nível de campo requer pacotes adicionais além do driver.

Observação

Para obter instruções sobre como instalar o driver Scala, consulte o Guia de instalação .

libmongocrypt

Há um arquivo JAR separado contendo vinculações do libmongocrypt .

Se você estiver usando o Maven para gerenciar seus pacotes, adicione a seguinte entrada à sua pom.xml lista de dependências do :

<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-crypt</artifactId>
        <version>1.2.1</version>
    </dependency>
</dependencies>

Se você estiver usando o Gradle para gerenciar seus pacotes, adicione a seguinte entrada à sua lista de dependências:

dependencies {
    implementation 'org.mongodb:mongodb-crypt:1.2.1'
}

Configuração do mongocryptd

As vinculações do libmongocrypt exigem que o daemon/processo do mongocryptd esteja em execução. Um URI de daemon/processo específico pode ser configurado na classe AutoEncryptionSettings definindo mongocryptdURI na configuração extraOptions .

Exemplos

Criptografia e descriptografia automáticas

O exemplo a seguir é um aplicativo que pressupõe que a chave e o esquema já foram criados no MongoDB. O exemplo usa uma chave local, mas você também pode usar o AWS/Azure/GCP KMS. Os dados no campo encryptedField são automaticamente criptografados na inserção e descriptografados ao usar localizar no lado do cliente.

O exemplo de código é do ClientSideEncryptionSimpleTour.scala no repositório GitHub do código fonte do driver.

import java.security.SecureRandom
import org.mongodb.scala.{AutoEncryptionSettings, Document, MongoClient, MongoClientSettings}
import tour.Helpers._
import scala.collection.JavaConverters._
object ClientSideEncryptionSimpleTour {
  def main(args: Array[String]): Unit = {
    val localMasterKey = new Array[Byte](96)
    new SecureRandom().nextBytes(localMasterKey)
    val kmsProviders = Map("local" -> Map[String, AnyRef]("key" -> localMasterKey).asJava).asJava
    val keyVaultNamespace = "admin.datakeys"
    val autoEncryptionSettings = AutoEncryptionSettings.builder()
      .keyVaultNamespace(keyVaultNamespace).kmsProviders(kmsProviders).build()
    val clientSettings = MongoClientSettings.builder()
      .autoEncryptionSettings(autoEncryptionSettings).build()
    val mongoClient = MongoClient(clientSettings)
    val collection = mongoClient.getDatabase("test").getCollection("coll")
    collection.drop().headResult()
    collection.insertOne(Document("encryptedField" -> "123456789")).headResult()
    collection.find().first().printHeadResult()
    // release resources
    mongoClient.close()
  }
}

Observação

A criptografia automática é um recurso somente para empresas .

Especifique uma chave de encriptação de dados e campos criptografados

O exemplo seguinte mostra como configurar a instância do AutoEncryptionSettings para criar uma nova chave e configurar o mapa de JSON schema.

O exemplo de código é do ClientSideEncryptionAutoEncryptionSettingsTour.scala no repositório GitHub do código fonte do driver.

import java.security.SecureRandom
import java.util.Base64
import scala.collection.JavaConverters._
import org.mongodb.scala._
import org.mongodb.scala.bson.BsonDocument
import org.mongodb.scala.model.vault.DataKeyOptions
import org.mongodb.scala.vault.ClientEncryptions
import tour.Helpers._
...
    val keyVaultNamespace = "admin.datakeys"
    val clientEncryptionSettings = ClientEncryptionSettings.builder()
      .keyVaultMongoClientSettings(
        MongoClientSettings.builder().applyConnectionString(ConnectionString("mongodb://localhost")).build())
      .keyVaultNamespace(keyVaultNamespace).kmsProviders(kmsProviders).build()
    val clientEncryption = ClientEncryptions.create(clientEncryptionSettings)
    val dataKey = clientEncryption.createDataKey("local", DataKeyOptions()).headResult()
    val base64DataKeyId = Base64.getEncoder.encodeToString(dataKey.getData)
    val dbName = "test"
    val collName = "coll"
    val autoEncryptionSettings = AutoEncryptionSettings.builder()
      .keyVaultNamespace(keyVaultNamespace)
      .kmsProviders(kmsProviders)
      .schemaMap(Map(s"$dbName.$collName" -> BsonDocument(
        s"""{
            properties: {
              encryptedField: {
                encrypt: {
                  keyId: [{
                    "$$binary": {
                      "base64": "$base64DataKeyId",
                      "subType": "04"
                    }
                  }],
                  bsonType: "string",
                  algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
                }
              }
            },
            bsonType: "object"
          }""")).asJava)
      .build()

criptografia explícita e descriptografia

A criptografia e descriptografia explícitas são um recurso MongoDB Community e não usam o processo mongocryptd . A criptografia explícita é fornecida pela classe ClientEncryption .

O exemplo de código é de ClientSideEncryptionExplicitEncryptionAndDecryptionTour.scala no repositório GitHub do código fonte do driver.

// This would have to be the same master key as was used to create the encryption key
val localMasterKey = new Array[Byte](96)
new SecureRandom().nextBytes(localMasterKey)
val kmsProviders = Map("local" -> Map[String, AnyRef]("key" -> localMasterKey).asJava).asJava
val keyVaultNamespace = new MongoNamespace("encryption.testKeyVault")
val clientSettings = MongoClientSettings.builder().build()
val mongoClient = MongoClient(clientSettings)
// Set up the key vault for this example
val keyVaultCollection = mongoClient.getDatabase(keyVaultNamespace.getDatabaseName)
  .getCollection(keyVaultNamespace.getCollectionName)
keyVaultCollection.drop().headResult()
// Ensure that two data keys cannot share the same keyAltName.
keyVaultCollection.createIndex(Indexes.ascending("keyAltNames"), new IndexOptions().unique(true)
  .partialFilterExpression(Filters.exists("keyAltNames")))
val collection = mongoClient.getDatabase("test").getCollection("coll")
collection.drop().headResult()
// Create the ClientEncryption instance
val clientEncryptionSettings = ClientEncryptionSettings
  .builder()
  .keyVaultMongoClientSettings(
    MongoClientSettings.builder()
       .applyConnectionString(ConnectionString("mongodb://localhost")).build()
  )
  .keyVaultNamespace(keyVaultNamespace.getFullName)
  .kmsProviders(kmsProviders)
  .build()
val clientEncryption = ClientEncryptions.create(clientEncryptionSettings)
val dataKeyId = clientEncryption.createDataKey("local", DataKeyOptions()).headResult()
// Explicitly encrypt a field
val encryptedFieldValue = clientEncryption.encrypt(BsonString("123456789"),
  EncryptOptions("AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic").keyId(dataKeyId))
    .headResult()
collection.insertOne(Document("encryptedField" -> encryptedFieldValue)).headResult()
val doc = collection.find.first().headResult()
println(doc.toJson())
// Explicitly decrypt the field
println(
    clientEncryption.decrypt(doc.get[BsonBinary]("encryptedField").get).headResult()
)

Criptografia explícita e descriptografia automática

Embora a criptografia automática exija MongoDB 4.2 enterprise ou um cluster do Atlas MongoDB 4.2, a descriptografia automática é suportada para todos os usuários. Para configurar a descriptografia automática sem criptografia automática, defina bypassAutoEncryption(true).

O exemplo de código é do ClientSideEncryptionExplicitEncryptionOnlyTour.scala no repositório GitHub do código fonte do driver.

...
val clientSettings = MongoClientSettings.builder()
    .autoEncryptionSettings(AutoEncryptionSettings.builder()
            .keyVaultNamespace(keyVaultNamespace.getFullName)
            .kmsProviders(kmsProviders)
            .bypassAutoEncryption(true)
            .build())
    .build()
val mongoClient = MongoClient(clientSettings)
...
// Explicitly encrypt a field
val encryptedFieldValue = clientEncryption.encrypt(BsonString("123456789"),
  EncryptOptions("AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic").keyId(dataKeyId))
    .headResult()
collection.insertOne(Document("encryptedField" -> encryptedFieldValue)).headResult()
val doc = collection.find.first().headResult()
println(doc.toJson())

Voltar

Ler operações

Próximo

Operações de Escrita

Nesta página