Usar criptografia no nível do campo automática no lado do cliente com AWS
Nesta página
- Visão geral
- Antes de começar
- Código completo do aplicativo
- Configurar o KMS
- Criar a Chave Mestre do Cliente
- Criar um usuário AWS IAM
- Criar o aplicativo
- Crie um índice único em sua coleção do Key Vault
- Criar uma nova chave de criptografia de dados
- Configure o MongoClient
- Inserir um documento com campos criptografados
- Recupere seu documento com campos criptografados
- Saiba mais
Visão geral
Este guia mostra como criar um aplicativo habilitado para criptografia de nível de campo (CSFLE) do lado do cliente usando a Amazon Web Services (AWS) KMS.
Depois de concluir as etapas deste guia, você deverá ter:
Uma Chave mestre do cliente hospedada em uma instância do AWS KMS.
Uma aplicação cliente funcional que insere documentos com campos criptografados usando sua Chave Mestra do Cliente.
Antes de começar
Para concluir e executar o código neste guia, você precisa configurar seu ambiente de desenvolvimento como mostrado na páginaRequisitos de instalação do .
Neste guia, os exemplos de código usam texto de espaço reservado. Antes de executar os exemplos, substitua seus valores por esses espaços reservados.
Por exemplo:
dek_id := "<Your Base64 DEK ID>"
Você deve substituir tudo o que estiver entre aspas por sua ID DEK.
dek_id := "abc123"
Selecione a linguagem de programação para a qual você deseja ver exemplos de código no menu suspenso Select your language no lado direito da página.
Código completo do aplicativo
Para ver o código completo do aplicação de amostra , selecione sua linguagem de programação no seletor de idioma.
Configurar o KMS
// You are viewing the C# driver code examples. // Use the dropdown menu to select a different driver.
// You are viewing the Golang driver code examples. // Use the dropdown menu to select a different driver.
Importante
Ao criar ou executar o código Go neste guia usando go build
ou go run
, sempre inclua a restrição de compilação cse
para habilitar o CSFLE. Consulte o seguinte comando shell para obter um exemplo de inclusão da restrição de compilação:
go run -tags cse insert-encrypted-document.go
// You are viewing the Java synchronous driver code examples. // Use the dropdown menu to select a different driver.
// You are viewing the Node.js driver code examples. // Use the dropdown menu to select a different driver.
# You are viewing the Python driver code examples. # Use the dropdown menu to select a different driver.
Criar a Chave Mestre do Cliente
Navegue até o Console AWS KMS.
Crie sua chave mestra do cliente
Crie uma nova chave simétrica seguindo a documentação oficial da AWS sobre Criação de chaves KMS simétricas. A chave que você cria é a chave mestre do cliente. Escolha um nome e uma descrição que o ajudem a identificá-lo; esses campos não afetam a funcionalidade ou a configuração da CMK.
Na etapa Usage Permissions do processo de geração de chaves, aplique a seguinte política de chaves padrão que permite que as políticas de Gerenciamento de Identidade e Acesso (IAM) concedam acesso à sua chave mestra do cliente:
{ "Version": "2012-10-17", "Statement": [ { "Sid": "Enable IAM User Permissions", "Effect": "Allow", "Principal": { "AWS": "<ARN of your AWS account principal>" }, "Action": "kms:*", "Resource": "*" } ] } Importante
Registre o nome do recurso da Amazon (ARN) e a região da sua chave mestra do cliente. Você os usará nas etapas posteriores deste guia.
Dica
Saiba mais
Para saber mais sobre suas chaves mestres de clientes, consulte Chaves de criptografia e cofres de chaves.
Para saber mais sobre as principais políticas, consulte Principais políticas no AWS KMS na documentação oficial da AWS.
Criar um usuário AWS IAM
Navegue até o Console AWS IAM.
Criar um usuário IAM
Crie um novo usuário programático do IAM no console de gerenciamento da AWS seguindo a documentação oficial da AWS sobre como adicionar um usuário . Você usará esse usuário do IAM como uma conta de serviço para seu aplicativo habilitado para CSFLE. Seu aplicativo autentica com o AWS KMS usando o usuário IAM para criptografar e descriptografar suas chaves de criptografia de dados (DEKs) com sua chave mestre do cliente (CMK).
Importante
Registre suas Credenciais
Certifique-se de registrar as seguintes credenciais do IAM na etapa final da criação do seu usuário do IAM:
ID da chave de acesso
chave de acesso secreta
Você tem uma oportunidade de registrar essas credenciais. Se você não registrar essas credenciais durante essa etapa, deverá criar outro usuário do IAM .
Conceder permissões
Conceda ao seu usuário do IAM permissões
kms:Encrypt
ekms:Decrypt
para sua chave mestre remota.Importante
O novo usuário do cliente IAM não deve ter permissões administrativas para a chave mestre. Para manter seus dados seguros, siga o principal de privilégio mínimo.
A política em linha a seguir permite que um usuário do IAM criptografe e descriptografe com a chave mestra do cliente com o mínimo de privilégios possível:
Observação
Chave mestra remota ARN
A política a seguir requer o ARN da chave gerada na etapa Criar a chave mestra deste guia.
{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": ["kms:Decrypt", "kms:Encrypt"], "Resource": "<the Amazon Resource Name (ARN) of your remote master key>" } ] } Para aplicar a política anterior ao seu usuário do IAM, siga o guia Adicionando permissões de identidade do IAM na documentação da AWS.
Importante
Autenticar com funções IAM em produção
Ao implantar seu aplicativo habilitado para CSFLE em um ambiente de produção, autentique seu aplicativo usando uma função do IAM em vez de um usuário do IAM .
Para saber mais sobre roles do IAM, consulte as seguintes páginas na documentação oficial da AWS:
Criar o aplicativo
Crie um índice único em sua coleção do Key Vault
Crie um índice único no campo keyAltNames
no seu espaço de nomes encryption.__keyVault
.
Selecione a guia correspondente ao driver MongoDB de sua preferência:
var connectionString = "<Your MongoDB URI>"; var keyVaultNamespace = CollectionNamespace.FromFullName("encryption.__keyVault"); var keyVaultClient = new MongoClient(connectionString); var indexOptions = new CreateIndexOptions<BsonDocument>(); indexOptions.Unique = true; indexOptions.PartialFilterExpression = new BsonDocument { { "keyAltNames", new BsonDocument { { "$exists", new BsonBoolean(true) } } } }; var builder = Builders<BsonDocument>.IndexKeys; var indexKeysDocument = builder.Ascending("keyAltNames"); var indexModel = new CreateIndexModel<BsonDocument>(indexKeysDocument, indexOptions); var keyVaultDatabase = keyVaultClient.GetDatabase(keyVaultNamespace.DatabaseNamespace.ToString()); // Drop the Key Vault Collection in case you created this collection // in a previous run of this application. keyVaultDatabase.DropCollection(keyVaultNamespace.CollectionName); // Drop the database storing your encrypted fields as all // the DEKs encrypting those fields were deleted in the preceding line. keyVaultClient.GetDatabase("medicalRecords").DropCollection("patients"); var keyVaultCollection = keyVaultDatabase.GetCollection<BsonDocument>(keyVaultNamespace.CollectionName.ToString()); keyVaultCollection.Indexes.CreateOne(indexModel);
uri := "<Your MongoDB URI>" keyVaultClient, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri)) if err != nil { return fmt.Errorf("Connect error for regular client: %v", err) } defer func() { _ = keyVaultClient.Disconnect(context.TODO()) }() keyVaultColl := "__keyVault" keyVaultDb := "encryption" keyVaultNamespace := keyVaultDb + "." + keyVaultColl keyVaultIndex := mongo.IndexModel{ Keys: bson.D{{"keyAltNames", 1}}, Options: options.Index(). SetUnique(true). SetPartialFilterExpression(bson.D{ {"keyAltNames", bson.D{ {"$exists", true}, }}, }), } // Drop the Key Vault Collection in case you created this collection // in a previous run of this application. if err = keyVaultClient.Database(keyVaultDb).Collection(keyVaultColl).Drop(context.TODO()); err != nil { log.Fatalf("Collection.Drop error: %v", err) } // Drop the database storing your encrypted fields as all // the DEKs encrypting those fields were deleted in the preceding line. if err = keyVaultClient.Database("medicalRecords").Collection("patients").Drop(context.TODO()); err != nil { log.Fatalf("Collection.Drop error: %v", err) } _, err = keyVaultClient.Database(keyVaultDb).Collection(keyVaultColl).Indexes().CreateOne(context.TODO(), keyVaultIndex) if err != nil { panic(err) }
String connectionString = "<Your MongoDB URI>"; String keyVaultDb = "encryption"; String keyVaultColl = "__keyVault"; String keyVaultNamespace = keyVaultDb + "." + keyVaultColl; MongoClient keyVaultClient = MongoClients.create(connectionString); // Drop the Key Vault Collection in case you created this collection // in a previous run of this application. keyVaultClient.getDatabase(keyVaultDb).getCollection(keyVaultColl).drop(); // Drop the database storing your encrypted fields as all // the DEKs encrypting those fields were deleted in the preceding line. keyVaultClient.getDatabase("medicalRecords").getCollection("patients").drop(); MongoCollection keyVaultCollection = keyVaultClient.getDatabase(keyVaultDb).getCollection(keyVaultColl); IndexOptions indexOpts = new IndexOptions().partialFilterExpression(new BsonDocument("keyAltNames", new BsonDocument("$exists", new BsonBoolean(true) ))).unique(true); keyVaultCollection.createIndex(new BsonDocument("keyAltNames", new BsonInt32(1)), indexOpts); keyVaultClient.close();
const uri = "<Your Connection String>"; const keyVaultDatabase = "encryption"; const keyVaultCollection = "__keyVault"; const keyVaultNamespace = `${keyVaultDatabase}.${keyVaultCollection}`; const keyVaultClient = new MongoClient(uri); await keyVaultClient.connect(); const keyVaultDB = keyVaultClient.db(keyVaultDatabase); // Drop the Key Vault Collection in case you created this collection // in a previous run of this application. await keyVaultDB.dropDatabase(); // Drop the database storing your encrypted fields as all // the DEKs encrypting those fields were deleted in the preceding line. await keyVaultClient.db("medicalRecords").dropDatabase(); const keyVaultColl = keyVaultDB.collection(keyVaultCollection); await keyVaultColl.createIndex( { keyAltNames: 1 }, { unique: true, partialFilterExpression: { keyAltNames: { $exists: true } }, } );
connection_string = "<your connection string here>" key_vault_coll = "__keyVault" key_vault_db = "encryption" key_vault_namespace = f"{key_vault_db}.{key_vault_coll}" key_vault_client = MongoClient(connection_string) # Drop the Key Vault Collection in case you created this collection # in a previous run of this application. key_vault_client.drop_database(key_vault_db) # Drop the database storing your encrypted fields as all # the DEKs encrypting those fields were deleted in the preceding line. key_vault_client["medicalRecords"].drop_collection("patients") key_vault_client[key_vault_db][key_vault_coll].create_index( [("keyAltNames", ASCENDING)], unique=True, partialFilterExpression={"keyAltNames": {"$exists": True}}, )
Criar uma nova chave de criptografia de dados
Adicione suas credenciais da AWS KMS
Adicione as credenciais da conta de serviço ao código do cliente habilitado para CSFLE.
var kmsProviders = new Dictionary<string, IReadOnlyDictionary<string, object>>(); var provider = "aws"; var awsKmsOptions = new Dictionary<string, object> { { "accessKeyId", "<Your AWS Access Key ID>" }, { "secretAccessKey", "<Your AWS Secret Access Key>" } }; kmsProviders.Add(provider, awsKmsOptions); provider := "aws" kmsProviders := map[string]map[string]interface{}{ provider: { "accessKeyId": "<Your AWS Access Key ID>", "secretAccessKey": "<Your AWS Secret Access Key>", }, } Map<String, Map<String, Object>> kmsProviders = new HashMap<String, Map<String, Object>>(); String kmsProvider = "aws"; Map<String, Object> providerDetails = new HashMap<>(); providerDetails.put("accessKeyId", new BsonString("<IAM User Access Key ID>")); providerDetails.put("secretAccessKey", new BsonString("<IAM User Secret Access Key>")); kmsProviders.put(kmsProvider, providerDetails); Dica
Para saber como fornecer suas credenciais do Amazon Web Services sem especificá-las diretamente, conforme mostrado no exemplo de código anterior, consulte a documentação doJava MONGODB-Amazon Web Services .
const provider = "aws"; const kmsProviders = { aws: { accessKeyId: "<Your AWS Access Key ID>", secretAccessKey: "<Your AWS Secret Access Key>", }, }; provider = "aws" kms_providers = { provider: { "accessKeyId": "<IAM User Access Key ID>", "secretAccessKey": "<IAM User Secret Access Key>", } } Adicione suas informações principais
Atualize o seguinte código para especificar sua Chave Mestre do Cliente:
Dica
Você registrou o ARN e a região da chave mestra do cliente na etapa Criar uma chave mestra do cliente deste guia.
var dataKeyOptions = new DataKeyOptions( masterKey: new BsonDocument { { "region", "<Your AWS Key Region>" }, { "key", "<Your AWS Key ARN>" }, }); masterKey := map[string]interface{}{ "key": "<Your AWS Key ARN>", "region": "<Your AWS Key Region>", } masterKeyProperties.put("provider", new BsonString(kmsProvider)); masterKeyProperties.put("key", new BsonString("<Master Key ARN>")); masterKeyProperties.put("region", new BsonString("<Master Key AWS Region>")); const masterKey = { key: "<Your AWS Key ARN>", region: "<Your AWS Key Region>", }; master_key = {"region": "<Master Key AWS Region>", "key": "<Master Key ARN>"} Gere sua Chave de Criptografia de Dados
Gere sua Chave de criptografia de dados usando as variáveis declaradas na etapa um deste tutorial.
var clientEncryptionOptions = new ClientEncryptionOptions( keyVaultClient: keyVaultClient, keyVaultNamespace: keyVaultNamespace, kmsProviders: kmsProviders ); var clientEncryption = new ClientEncryption(clientEncryptionOptions); var dataKeyId = clientEncryption.CreateDataKey(provider, dataKeyOptions, CancellationToken.None); var dataKeyIdBase64 = Convert.ToBase64String(GuidConverter.ToBytes(dataKeyId, GuidRepresentation.Standard)); Console.WriteLine($"DataKeyId [base64]: {dataKeyIdBase64}"); clientEncryptionOpts := options.ClientEncryption().SetKeyVaultNamespace(keyVaultNamespace). SetKmsProviders(kmsProviders) clientEnc, err := mongo.NewClientEncryption(keyVaultClient, clientEncryptionOpts) if err != nil { return fmt.Errorf("NewClientEncryption error %v", err) } defer func() { _ = clientEnc.Close(context.TODO()) }() dataKeyOpts := options.DataKey(). SetMasterKey(masterKey) dataKeyID, err := clientEnc.CreateDataKey(context.TODO(), provider, dataKeyOpts) if err != nil { return fmt.Errorf("create data key error %v", err) } fmt.Printf("DataKeyId [base64]: %s\n", base64.StdEncoding.EncodeToString(dataKeyID.Data)) ClientEncryptionSettings clientEncryptionSettings = ClientEncryptionSettings.builder() .keyVaultMongoClientSettings(MongoClientSettings.builder() .applyConnectionString(new ConnectionString(connectionString)) .build()) .keyVaultNamespace(keyVaultNamespace) .kmsProviders(kmsProviders) .build(); MongoClient regularClient = MongoClients.create(connectionString); ClientEncryption clientEncryption = ClientEncryptions.create(clientEncryptionSettings); BsonBinary dataKeyId = clientEncryption.createDataKey(kmsProvider, new DataKeyOptions().masterKey(masterKeyProperties)); String base64DataKeyId = Base64.getEncoder().encodeToString(dataKeyId.getData()); System.out.println("DataKeyId [base64]: " + base64DataKeyId); clientEncryption.close(); const client = new MongoClient(uri); await client.connect(); const encryption = new ClientEncryption(client, { keyVaultNamespace, kmsProviders, }); const key = await encryption.createDataKey(provider, { masterKey: masterKey, }); console.log("DataKeyId [base64]: ", key.toString("base64")); await keyVaultClient.close(); await client.close(); Observação
Importar ClientEncryption
Ao usar o driver Node.js v6.0 e posterior, você deve importar
ClientEncryption
demongodb
.Para versões anteriores do driver, importe
ClientEncryption
demongodb-client-encryption
.key_vault_database = "encryption" key_vault_collection = "__keyVault" key_vault_namespace = f"{key_vault_database}.{key_vault_collection}" client = MongoClient(connection_string) client_encryption = ClientEncryption( kms_providers, # pass in the kms_providers variable from the previous step key_vault_namespace, client, CodecOptions(uuid_representation=STANDARD), ) data_key_id = client_encryption.create_data_key(provider, master_key) base_64_data_key_id = base64.b64encode(data_key_id) print("DataKeyId [base64]: ", base_64_data_key_id)
Dica
Saiba mais
Para visualizar um diagrama que mostra como o cliente cria a chave de encriptação de dados ao usar um AWS KMS, consulte Arquitetura.
Para saber mais sobre as opções de criação de uma chave de encriptação de dados criptografada com uma chave mestra do cliente hospedada no AWS KMS, consulte o objeto dataKeyOpts.
Dica
Veja: Código Completo
Para visualizar o código completo para criar uma Chave de criptografia de dados, consulte nosso repositório Github
Para visualizar o código completo para criar uma Chave de Criptografia de Dados, consulte nosso repositório Github.
Para visualizar o código completo para criar uma Chave de Criptografia de Dados, consulte nosso repositório Github.
Para visualizar o código completo para criar uma Chave de Criptografia de Dados, consulte nosso repositório Github.
Para visualizar o código completo para criar uma Chave de Criptografia de Dados, consulte nosso repositório Github.
Configure o MongoClient
Dica
Siga as etapas restantes deste tutorial em um arquivo separado daquele criado nas etapas anteriores.
Para visualizar o código completo deste arquivo, consulte nosso repositório Github
Para visualizar o código completo deste arquivo, consulte nosso repositório Github.
Para visualizar o código completo deste arquivo, consulte nosso repositório Github.
Para visualizar o código completo deste arquivo, consulte nosso repositório Github.
Para visualizar o código completo deste arquivo, consulte nosso repositório Github.
Especifique o namespace da coleção do Key Vault
Especifique
encryption.__keyVault
como o namespace da coleção Key Vault.var keyVaultNamespace = CollectionNamespace.FromFullName("encryption.__keyVault"); keyVaultNamespace := "encryption.__keyVault" String keyVaultNamespace = "encryption.__keyVault"; const keyVaultNamespace = "encryption.__keyVault"; key_vault_namespace = "encryption.__keyVault" Especifique suas Credenciais AWS
Informe o fornecedor KMS do
aws
e as credenciais IAM do usuário:var kmsProviders = new Dictionary<string, IReadOnlyDictionary<string, object>>(); var provider = "aws"; var awsKmsOptions = new Dictionary<string, object> { { "accessKeyId", "<Your AWS Access Key ID>" }, { "secretAccessKey", "<Your AWS Secret Access Key>" } }; kmsProviders.Add(provider, awsKmsOptions); kmsProviders := map[string]map[string]interface{}{ "aws": { "accessKeyId": "<Your AWS Access Key ID>", "secretAccessKey": "<Your AWS Secret Access Key>", }, } Map<String, Map<String, Object>> kmsProviders = new HashMap<String, Map<String, Object>>(); String kmsProvider = "aws"; Map<String, Object> providerDetails = new HashMap<>(); providerDetails.put("accessKeyId", "<IAM User Access Key ID>"); providerDetails.put("secretAccessKey", "<IAM User Secret Access Key>"); kmsProviders.put(kmsProvider, providerDetails); const kmsProviders = { aws: { accessKeyId: "<Your AWS Access Key ID>", secretAccessKey: "<Your AWS Secret Access Key>", }, }; provider = "aws" kms_providers = { "aws": { "accessKeyId": "<IAM User Access Key ID>", "secretAccessKey": "<IAM User Secret Access Key>", } } Importante
Lembrete: autenticar com funções IAM em produção
Para utilizar um papel IAM em vez de um usuário IAM para autenticar seu aplicativo, especifique um objeto vazio para suas credenciais em seu objeto do provedor de KMS. Isso instrui o condutor a recuperar automaticamente as credenciais do ambiente:
kmsProviders = { aws: { } }; kmsProviderCredentials.Add("aws", new Dictionary<string, object>); kmsProviderCredentials := map[string]map[string]interface{}{ "aws": { }, } kmsProviderCredentials.put("aws", new HashMap<>()); kmsProviders = { aws: { } }; kms_provider_credentials = { "aws": { } } Crie um esquema de criptografia para sua coleção
Dica
Adicione sua chave de encriptação de dados ID Base64
Certifique-se de atualizar o seguinte código para incluir seu ID Base64 DEK . Você recebeu esse valor na etapa Gerar sua chave de criptografia de dados deste guia.
var keyId = "<Your base64 DEK ID here>"; var schema = new BsonDocument { { "bsonType", "object" }, { "encryptMetadata", new BsonDocument("keyId", new BsonArray(new[] { new BsonBinaryData(Convert.FromBase64String(keyId), BsonBinarySubType.UuidStandard) })) }, { "properties", new BsonDocument { { "ssn", new BsonDocument { { "encrypt", new BsonDocument { { "bsonType", "int" }, { "algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" } } } } }, { "bloodType", new BsonDocument { { "encrypt", new BsonDocument { { "bsonType", "string" }, { "algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random" } } } } }, { "medicalRecords", new BsonDocument { { "encrypt", new BsonDocument { { "bsonType", "array" }, { "algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random" } } } } }, { "insurance", new BsonDocument { { "bsonType", "object" }, { "properties", new BsonDocument { { "policyNumber", new BsonDocument { { "encrypt", new BsonDocument { { "bsonType", "int" }, { "algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" } } } } } } } } } } } }; var schemaMap = new Dictionary<string, BsonDocument>(); schemaMap.Add(dbNamespace, schema); dek_id := "<Your Base64 DEK ID>" schema_template := `{ "bsonType": "object", "encryptMetadata": { "keyId": [ { "$binary": { "base64": "%s", "subType": "04" } } ] }, "properties": { "insurance": { "bsonType": "object", "properties": { "policyNumber": { "encrypt": { "bsonType": "int", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" } } } }, "medicalRecords": { "encrypt": { "bsonType": "array", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random" } }, "bloodType": { "encrypt": { "bsonType": "string", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random" } }, "ssn": { "encrypt": { "bsonType": "int", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" } } } }` schema := fmt.Sprintf(schema_template, dek_id) var schemaDoc bson.Raw if err := bson.UnmarshalExtJSON([]byte(schema), true, &schemaDoc); err != nil { return fmt.Errorf("UnmarshalExtJSON error: %v", err) } schemaMap := map[string]interface{}{ dbName + "." + collName: schemaDoc, } String dekId = "<paste-base-64-encoded-data-encryption-key-id>>"; Document jsonSchema = new Document().append("bsonType", "object").append("encryptMetadata", new Document().append("keyId", new ArrayList<>((Arrays.asList(new Document().append("$binary", new Document() .append("base64", dekId) .append("subType", "04"))))))) .append("properties", new Document() .append("ssn", new Document().append("encrypt", new Document() .append("bsonType", "int") .append("algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"))) .append("bloodType", new Document().append("encrypt", new Document() .append("bsonType", "string") .append("algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random"))) .append("medicalRecords", new Document().append("encrypt", new Document() .append("bsonType", "array") .append("algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random"))) .append("insurance", new Document() .append("bsonType", "object") .append("properties", new Document().append("policyNumber", new Document().append("encrypt", new Document() .append("bsonType", "int") .append("algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic")))))); HashMap<String, BsonDocument> schemaMap = new HashMap<String, BsonDocument>(); schemaMap.put("medicalRecords.patients", BsonDocument.parse(jsonSchema.toJson())); dataKey = "<Your base64 DEK ID>"; const schema = { bsonType: "object", encryptMetadata: { keyId: [new Binary(Buffer.from(dataKey, "base64"), 4)], }, properties: { insurance: { bsonType: "object", properties: { policyNumber: { encrypt: { bsonType: "int", algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic", }, }, }, }, medicalRecords: { encrypt: { bsonType: "array", algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Random", }, }, bloodType: { encrypt: { bsonType: "string", algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Random", }, }, ssn: { encrypt: { bsonType: "int", algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic", }, }, }, }; var patientSchema = {}; patientSchema[namespace] = schema; dek_id = b"<paste-base-64-encoded-data-encryption-key-id>" json_schema = { "bsonType": "object", "encryptMetadata": {"keyId": [Binary(base64.b64decode(dek_id), UUID_SUBTYPE)]}, "properties": { "insurance": { "bsonType": "object", "properties": { "policyNumber": { "encrypt": { "bsonType": "int", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic", } } }, }, "medicalRecords": { "encrypt": { "bsonType": "array", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random", } }, "bloodType": { "encrypt": { "bsonType": "string", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random", } }, "ssn": { "encrypt": { "bsonType": "int", "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic", } }, }, } patient_schema = {"medicalRecords.patients": json_schema} Especifique o local da biblioteca compartilhada de criptografia automática
var mongoBinariesPath = "<Full path to your Automatic Encryption Shared Library>"; var extraOptions = new Dictionary<string, object>() { { "cryptSharedLibPath", mongoBinariesPath }, }; extraOptions := map[string]interface{}{ "cryptSharedLibPath": "<Full path to your Automatic Encryption Shared Library>", } Map<String, Object> extraOptions = new HashMap<String, Object>(); extraOptions.put("cryptSharedLibPath", "<Full path to your Automatic Encryption Shared Library>")); const extraOptions = { cryptSharedLibPath: "<Full path to your Automatic Encryption Shared Library>", }; extra_options = { "cryptSharedLibPath": "<Full path to your Automatic Encryption Shared Library>" } Observação
Opções de criptografia automática
As opções de criptografia automática fornecem informações de configuração para a Biblioteca compartilhada de criptografia automática, que modifica o comportamento do aplicativo ao acessar campos criptografados.
Para saber mais sobre a Biblioteca compartilhada de criptografia automática, consulte a página Instalar e configurar uma biblioteca CSFLE .
Criar o MongoClient
Instale instantaneamente um objeto de cliente MongoDB com as seguintes configurações de criptografia automática que usam as variáveis declaradas nas etapas anteriores:
MongoClientSettings.Extensions.AddAutoEncryption(); // .NET/C# Driver v3.0 or later only var clientSettings = MongoClientSettings.FromConnectionString(connectionString); var autoEncryptionOptions = new AutoEncryptionOptions( keyVaultNamespace: keyVaultNamespace, kmsProviders: kmsProviders, schemaMap: schemaMap, extraOptions: extraOptions ); clientSettings.AutoEncryptionOptions = autoEncryptionOptions; var secureClient = new MongoClient(clientSettings); var clientSettings = MongoClientSettings.FromConnectionString(connectionString); var autoEncryptionOptions = new AutoEncryptionOptions( keyVaultNamespace: keyVaultNamespace, kmsProviders: kmsProviders, schemaMap: schemaMap, extraOptions: extraOptions ); clientSettings.AutoEncryptionOptions = autoEncryptionOptions; var secureClient = new MongoClient(clientSettings); autoEncryptionOpts := options.AutoEncryption(). SetKmsProviders(kmsProviders). SetKeyVaultNamespace(keyVaultNamespace). SetSchemaMap(schemaMap). SetExtraOptions(extraOptions) secureClient, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri).SetAutoEncryptionOptions(autoEncryptionOpts)) if err != nil { return fmt.Errorf("Connect error for encrypted client: %v", err) } defer func() { _ = secureClient.Disconnect(context.TODO()) }() MongoClientSettings clientSettings = MongoClientSettings.builder() .applyConnectionString(new ConnectionString(connectionString)) .autoEncryptionSettings(AutoEncryptionSettings.builder() .keyVaultNamespace(keyVaultNamespace) .kmsProviders(kmsProviders) .schemaMap(schemaMap) .extraOptions(extraOptions) .build()) .build(); MongoClient mongoClientSecure = MongoClients.create(clientSettings); const secureClient = new MongoClient(connectionString, { autoEncryption: { keyVaultNamespace, kmsProviders, schemaMap: patientSchema, extraOptions: extraOptions, }, }); fle_opts = AutoEncryptionOpts( kms_providers, key_vault_namespace, schema_map=patient_schema, **extra_options ) secureClient = MongoClient(connection_string, auto_encryption_opts=fle_opts)
Inserir um documento com campos criptografados
Use sua instância de MongoClient
habilitada para CSFLE para inserir um documento com campos criptografados no namespace medicalRecords.patients
usando o seguinte trecho de código:
var sampleDocFields = new BsonDocument { { "name", "Jon Doe" }, { "ssn", 145014000 }, { "bloodType", "AB-" }, { "medicalRecords", new BsonArray { new BsonDocument("weight", 180), new BsonDocument("bloodPressure", "120/80") } }, { "insurance", new BsonDocument { { "policyNumber", 123142 }, { "provider", "MaestCare" } } } }; // Construct an auto-encrypting client var secureCollection = secureClient.GetDatabase(db).GetCollection<BsonDocument>(coll); // Insert a document into the collection secureCollection.InsertOne(sampleDocFields);
test_patient := map[string]interface{}{ "name": "Jon Doe", "ssn": 241014209, "bloodType": "AB+", "medicalRecords": []map[string]interface{}{{ "weight": 180, "bloodPressure": "120/80", }}, "insurance": map[string]interface{}{ "provider": "MaestCare", "policyNumber": 123142, }, } if _, err := secureClient.Database(dbName).Collection(collName).InsertOne(context.TODO(), test_patient); err != nil { return fmt.Errorf("InsertOne error: %v", err) }
Observação
Em vez de criar um documento BSON bruto, você pode passar uma estrutura com marcações bson
diretamente para o driver para codificação.
ArrayList<Document> medicalRecords = new ArrayList<>(); medicalRecords.add(new Document().append("weight", "180")); medicalRecords.add(new Document().append("bloodPressure", "120/80")); Document insurance = new Document() .append("policyNumber", 123142) .append("provider", "MaestCare"); Document patient = new Document() .append("name", "Jon Doe") .append("ssn", 241014209) .append("bloodType", "AB+") .append("medicalRecords", medicalRecords) .append("insurance", insurance); mongoClientSecure.getDatabase(recordsDb).getCollection(recordsColl).insertOne(patient);
try { const writeResult = await secureClient .db(db) .collection(coll) .insertOne({ name: "Jon Doe", ssn: 241014209, bloodType: "AB+", medicalRecords: [{ weight: 180, bloodPressure: "120/80" }], insurance: { policyNumber: 123142, provider: "MaestCare", }, }); } catch (writeError) { console.error("writeError occurred:", writeError); }
def insert_patient( collection, name, ssn, blood_type, medical_records, policy_number, provider ): insurance = {"policyNumber": policy_number, "provider": provider} doc = { "name": name, "ssn": ssn, "bloodType": blood_type, "medicalRecords": medical_records, "insurance": insurance, } collection.insert_one(doc) medical_record = [{"weight": 180, "bloodPressure": "120/80"}] insert_patient( secureClient.medicalRecords.patients, "Jon Doe", 241014209, "AB+", medical_record, 123142, "MaestCare", )
Quando você insere um documento, o cliente habilitado para CSFLE criptografa os campos do documento de forma que ele se pareça com o seguinte:
{ "_id": { "$oid": "<_id of your document>" }, "name": "Jon Doe", "ssn": { "$binary": "<cipher-text>", "$type": "6" }, "bloodType": { "$binary": "<cipher-text>", "$type": "6" }, "medicalRecords": { "$binary": "<cipher-text>", "$type": "6" }, "insurance": { "provider": "MaestCare", "policyNumber": { "$binary": "<cipher-text>", "$type": "6" } } }
Dica
Veja: Código Completo
Para visualizar o código completo para inserir um documento com campos criptografados, consulte nosso repositório Github
Para visualizar o código completo de inserção de um documento com campos criptografados, consulte nosso repositório do Github.
Para visualizar o código completo de inserção de um documento com campos criptografados, consulte nosso repositório do Github.
Para visualizar o código completo de inserção de um documento com campos criptografados, consulte nosso repositório do Github.
Para visualizar o código completo de inserção de um documento com campos criptografados, consulte nosso repositório do Github.
Recupere seu documento com campos criptografados
Recupere o documento com campos criptografados inseridos na etapa Inserir um documento com campos criptografados deste guia.
Para mostrar a funcionalidade do CSFLE, as seguintes consultas de trecho de código para seu documento com um cliente configurado para CSFLE automático, bem como um cliente que não está configurado para CSFLE automático.
Console.WriteLine("Finding a document with regular (non-encrypted) client."); var filter = Builders<BsonDocument>.Filter.Eq("name", "Jon Doe"); var regularResult = regularCollection.Find(filter).Limit(1).ToList()[0]; Console.WriteLine($"\n{regularResult}\n"); Console.WriteLine("Finding a document with encrypted client"); var ssnFilter = Builders<BsonDocument>.Filter.Eq("name", "Jon Doe"); var secureResult = secureCollection.Find(ssnFilter).Limit(1).First(); Console.WriteLine($"\n{secureResult}\n");
fmt.Println("Finding a document with regular (non-encrypted) client.") var resultRegular bson.M err = regularClient.Database(dbName).Collection(collName).FindOne(context.TODO(), bson.D{{"name", "Jon Doe"}}).Decode(&resultRegular) if err != nil { panic(err) } outputRegular, err := json.MarshalIndent(resultRegular, "", " ") if err != nil { panic(err) } fmt.Printf("%s\n", outputRegular) fmt.Println("Finding a document with encrypted client") var resultSecure bson.M err = secureClient.Database(dbName).Collection(collName).FindOne(context.TODO(), bson.D{{"name", "Jon Doe"}}).Decode(&resultSecure) if err != nil { panic(err) } outputSecure, err := json.MarshalIndent(resultSecure, "", " ") if err != nil { panic(err) } fmt.Printf("%s\n", outputSecure)
System.out.println("Finding a document with regular (non-encrypted) client."); Document docRegular = mongoClientRegular.getDatabase(recordsDb).getCollection(recordsColl).find(eq("name", "Jon Doe")).first(); System.out.println(docRegular.toJson()); System.out.println("Finding a document with encrypted client"); Document docSecure = mongoClientSecure.getDatabase(recordsDb).getCollection(recordsColl).find(eq("name", "Jon Doe")).first(); System.out.println(docSecure.toJson());
console.log("Finding a document with regular (non-encrypted) client."); console.log( await regularClient.db(db).collection(coll).findOne({ name: /Jon/ }) ); console.log("Finding a document with encrypted client"); console.log( await secureClient.db(db).collection(coll).findOne({ name: /Jon/ }) );
print("Finding a document with regular (non-encrypted) client.") result = regularClient.medicalRecords.patients.find_one({"name": "Jon Doe"}) pprint.pprint(result) print("Finding a document with encrypted client") pprint.pprint(secureClient.medicalRecords.patients.find_one({"name": "Jon Doe"}))
A saída do trecho de código anterior deve ser semelhante a esta:
Finding a document with regular (non-encrypted) client. { _id: new ObjectId("629a452e0861b3130887103a"), name: 'Jon Doe', ssn: new Binary(Buffer.from("0217482732d8014cdd9ffdd6e2966e5e7910c20697e5f4fa95710aafc9153f0a3dc769c8a132a604b468732ff1f4d8349ded3244b59cbfb41444a210f28b21ea1b6c737508d9d30e8baa30c1d8070c4d5e26", "hex"), 6), bloodType: new Binary(Buffer.from("0217482732d8014cdd9ffdd6e2966e5e79022e238536dfd8caadb4d7751ac940e0f195addd7e5c67b61022d02faa90283ab69e02303c7e4001d1996128428bf037dea8bbf59fbb20c583cbcff2bf3e2519b4", "hex"), 6), 'key-id': 'demo-data-key', medicalRecords: new Binary(Buffer.from("0217482732d8014cdd9ffdd6e2966e5e790405163a3207cff175455106f57eef14e5610c49a99bcbd14a7db9c5284e45e3ee30c149354015f941440bf54725d6492fb3b8704bc7c411cff6c868e4e13c58233c3d5ed9593eca4e4d027d76d3705b6d1f3b3c9e2ceee195fd944b553eb27eee69e5e67c338f146f8445995664980bf0", "hex"), 6), insurance: { policyNumber: new Binary(Buffer.from("0217482732d8014cdd9ffdd6e2966e5e79108decd85c05be3fec099e015f9d26d9234605dc959cc1a19b63072f7ffda99db38c7b487de0572a03b2139ac3ee163bcc40c8508f366ce92a5dd36e38b3c742f7", "hex"), 6), provider: 'MaestCare' } } Finding a document with encrypted client { _id: new ObjectId("629a452e0861b3130887103a"), name: 'Jon Doe', ssn: 241014209, bloodType: 'AB+', 'key-id': 'demo-data-key', medicalRecords: [ { weight: 180, bloodPressure: '120/80' } ], insurance: { policyNumber: 123142, provider: 'MaestCare' } }
Dica
Veja: Código Completo
Para visualizar o código completo para localizar um documento com campos criptografados, consulte nosso repositório do Github
Para visualizar o código completo para encontrar um documento com campos criptografados, consulte nosso repositório Github.
Para visualizar o código completo para encontrar um documento com campos criptografados, consulte nosso repositório Github.
Para visualizar o código completo para encontrar um documento com campos criptografados, consulte nosso repositório Github.
Para visualizar o código completo para encontrar um documento com campos criptografados, consulte nosso repositório Github.
Saiba mais
Para saber como funciona o CSFLE, consulte Fundamentos.
Para saber mais sobre os tópicos mencionados neste guia, consulte os seguintes links:
Saiba mais sobre componentes CSFLE na página Referência.
Saiba como funcionam as chaves mestras do cliente e as chaves de criptografia de dados na página Chaves de criptografia e cofres de chaves
Veja como os provedores de KMS gerenciam suas chaves CSFLE na página Provedores de KMS .