Como configurar o mecanismo de segredos KMIP do HashiCorp Vault com MongoDB CSFLE ou Queryable Encryption
Avalie esse Tutorial
A criptografia é comprovada e confiável e existe há quase 60 anos, mas existem lacunas. Então, quando pensamos em mover dados (criptografia TLS) e armazenar dados (criptografia de armazenamento), a maioria dos bancos de dados cobre isso. Mas assim que os dados são usados, processados pelo banco de dados, eles ficam em texto simples e ficam mais vulneráveis ao acesso interno e a violações ativas. A maioria dos bancos de dados não cobre isso.
Com a criptografia no nível do campo do lado do cliente (CSFLE) e a Queryable Encryption do MongoDB, os aplicativos podem criptografar campos de texto simples sensíveis em documentos antes de transmitir dados para o servidor. Isso significa que os dados processados pelo banco de dados (em uso) não estarão em texto simples, pois estão sempre criptografados e, o mais importante, ainda podem ser consultados. As chaves de criptografia usadas geralmente são armazenadas em um serviço de gerenciamento de chaves.
Organizações com uma estratégia multi-cloud enfrentam o desafio de gerenciar chaves de criptografia em ambientes de cloud de forma padronizada, já que os serviços KMS de cloud pública usam APIs proprietárias — por exemplo, AWS KMS, Azure Key Vault ou GCP KMS — para gerenciar chaves de criptografia. As organizações que desejam ter uma maneira padronizada de gerenciar o ciclo de vida das chaves de criptografia podem utilizar o KMIP, Protocolo de interoperabilidade de gerenciamento de chaves.
Conforme mostrado no diagrama acima, os KMIPs eliminam a expansão de serviços de gerenciamento de chaves de criptografia em vários provedores de nuvem, utilizando um provedor de chaves habilitado para KMIP. O MongoDB CSFLE e o Queryable Encryption suportam KMIP como um provedor de chaves.
Neste artigo, mostrarei como usar o MongoDB Queryable Encryption e o CSFLE com o Hashicorpo Key Vault KMIP Secrets Engine para ter uma maneira padronizada de gerenciar o ciclo de vida das chaves de criptografia, independentemente do provedor de nuvem.
Antes de me afundar em como usar o MongoDB CSFLE e a Queryable Encryption, explicarei a terminologia de criptografia e a prática comum de criptografar dados de texto sem formatação.
A chave mestra do cliente (CMK) é a chave de criptografia usada para proteger (criptografar) as chaves de criptografia de dados, que estão no nível superior da hierarquia de criptografia.
A DEK (Chave de Criptografia de Dados) é usada para criptografar os dados que são texto sem formatação. Depois que o texto simples for criptografado pela DEK, ele estará em texto cifrado.
Dados de texto simples são informações não criptografadas que você deseja proteger.
Texto cifrado é uma informação criptografada ilegível por um ser humano oucomputador sem decodificação.
A criptografia de envelope é a prática de criptografar dadosde texto simples com uma chave de criptografia de dados (DEK) e, em seguida, criptografar a chave de dados usando a chave mestra do cliente.
Os pré-requisitos para ativar a query no modo CSFLE ou Queryable Encryption são:
- Um sistema de gerenciamento de chaves em execução que suporta o padrão KMIP — por exemplo, HashiCorp Key Vault. Aplicativo configurado para usar o endpoint KMIP.
- Chaves de criptografia de dados (DEK) criadas e um JSON schema de criptografia que é usado por um driver do MongoDB para saber quais campos criptografar.
- Uma conexão MongoDB autenticada com CSFLE/Queryable Encryption habilitada.
- Você precisará de uma versão de servidor compatível e de uma versão de driver compatível. Para este tutorial, vamos usar a versão 6 do MongoDB Atlas.0. Consulte a documentação para ver quais versões do driver para CSFLE ou Queryable Encryption são necessárias.
Uma vez que os itens acima sejam atendidos, é o que acontece quando uma query é executada.
Etapa 1: Ao receber uma query, o driver do MongoDB verifica se algum campo criptografado está envolvido usando o esquema de criptografia JSON que é configurado ao se conectar ao banco de dados.
Etapa 2: O driver MongoDB solicita a chave Customer Master Key (CMK) do provedor de chaves KMIP. Em nossa configuração, será o HashiCorp Key Vault.
Etapa 3: O driver do MongoDB descriptografa as chaves de criptografia de dados usando o CMK. A DEK é usada para criptografar/descriptografar os campos de texto simples. Os campos a serem criptografados/descriptografados são definidos no esquema de criptografia JSON. As chaves de criptografia de dados criptografados são armazenadas em uma coleção de cofre de chaves em seu cluster do MongoDB.
** Etapa : ** 4 O driver envia a consulta para o servidor MongoDB com os campos criptografados renderizados como texto cifrado.
**Etapa 5:** O MongoDB retorna os resultados criptografados da consulta para o driver do MongoDB, ainda como texto cifrado.
Etapa 6: O driver do MongoDB descriptografa os campos criptografados usando DEK em texto sem formatação e o retorna ao cliente autenticado.
O próximo é realmente configurar e configurar os pré-requisitos necessários para habilitar a query do MongoDB no modo CSFLE ou Queryable Encryption.
Então, vamos ver o que é necessário para instalar, configurar e executar para implementar o que está descrito na seção acima.
- MongoDB Atlas cluster: O MongoDB Atlas é uma plataforma de dados totalmente gerenciada para aplicativos modernos. Armazenar dados da forma como eles são acessados como documentos torna os desenvolvedores mais produtivos. Ele fornece um banco de dados baseado em documentos econômico e redimensionável, ao mesmo tempo em que automatiza tarefas de administração demoradas, como provisionamento de hardware, configuração de banco de dados, aplicação de patches e backups. Ele permite que você se concentre em seus aplicativos, fornecendo a base para o alto desempenho, a alta disponibilidade, a segurança e a compatibilidade de que eles precisam. Para este tutorial, vamos usar a versão 6 do MongoDB Atlas.0. Consulte a documentação para ver quais versões do driver para CSFLE ou Queryable Encryption são necessárias.
- HashiCorp Vault Enterprise: Execute e configure o HashiCorp Vault KMIP Secrets Engine, juntamente com Escopos, Funções e Certificados.
- Python application: isso mostra como o CSFLE e a Queryable Encryption podem ser usados com o HashiCorp Key Vault. Mostrarei como configurar o DEK, o JSON schema e um MongoDB authenticated client para se conectar a um database e executar queries que podem consultar encrypted data stored in a collection no MongoDB Atlas.
Em primeiro lugar, precisamos ter pelo menos uma conta do Atlas para provisionar o Atlas e, em seguida, algum lugar para executar nossa automação. Você pode obter uma conta Atlas gratuitamente em mongodb.com. Se você quiser levar este tutorial para dar uma volta, crie sua conta Atlas agora.
Você também precisará ter o Docker instalado, pois estamos usando um contêiner Docker onde criamos uma imagem contendo todas as dependências necessárias, como HashiCorp Key Vault, MongoDB Driver e biblioteca de criptografia. Para obter mais informações sobre como instalar o Docker, consulte Comece com Docker. Além disso, instale a versão mais recente do MongoDB Compass, que usaremos para ver se os campos da coleção foram criptografados.
Agora estamos quase prontos para começar. Você precisará clonar o repositório do Githubdeste tutorial. Você pode clonar o repositório usando o comando abaixo:
1 git clone https://github.com/mongodb-developer/mongodb-kmip-fle-queryable
Existem quatro etapas principais para executar este tutorial:
- Recuperação da chave de licença de avaliação do Hashicorpo Key Vault
- Atualize a string de conexão do banco de dados
- Inicie o container docker incorporado ao HashiCorp Key Vault
- Execute o aplicativo Python, mostrando o CSFLE e o Queryable Encryption
Em seguida, solicite uma chave de licença de teste para o Hashicorpo Enterprise Key Vault na página de produtosda Hashicorpo. Copie a chave de licença gerada que é gerada.
Substitua o conteúdo do arquivo license.txt pela chave de licença gerada na etapa acima. O arquivo está localizado no repositório clonado do github, no local kmip-with-hashicorp-key-vault/vault/license.txt.
Você precisará atualizar a string de conexão para que o aplicativo Python possa se conectar ao seu cluster MongoDB Atlas. É melhor atualizar os dois arquivos de configuração, pois este tutorial demonstrará o CSFLE e a Queryable Encryption.
Para CSFLE: Abra o arquivo kmip-with-hashicorp-key-vault/configuration_fle.py linha 3 e atualize connection_uri.
1 encrypted_namespace = "DEMO-KMIP-FLE.users" 2 key_vault_namespace = "DEMO-KMIP-FLE.datakeys" 3 connection_uri = "mongodb+srv://<USER>:<PASSWORD>@<CLUSTER-NAME>?retryWrites=true&w=majority" 4 # Configure the "kmip" provider. 5 kms_providers = { 6 "kmip": { 7 "endpoint": "localhost:5697" 8 } 9 } 10 kms_tls_options = { 11 "kmip": { 12 "tlsCAFile": "vault/certs/FLE/vv-ca.pem", 13 "tlsCertificateKeyFile": "vault/certs/FLE/vv-client.pem" 14 } 15 }
Substitua , , pela configuração de conexão do Atlas cluster depois de atualizar os detalhes da conexão do Atlas cluster. Você deve ter algo parecido com isto:
1 encrypted_namespace = "DEMO-KMIP-FLE.users" 2 key_vault_namespace = "DEMO-KMIP-FLE.datakeys" 3 connection_uri = "mongodb+srv://admin:mPassword@demo-cluster.tcrpd.mongodb.net/myFirstDatabase?retryWrites=true&w=majority" 4 # Configure the "kmip" provider. 5 kms_providers = { 6 "kmip": { 7 "endpoint": "localhost:5697" 8 } 9 } 10 kms_tls_options = { 11 "kmip": { 12 "tlsCAFile": "vault/certs/FLE/vv-ca.pem", 13 "tlsCertificateKeyFile": "vault/certs/FLE/vv-client.pem" 14 } 15 }
Para Queryable Encryption: abra o arquivo kmip-with-hashicorp-key-vault/configuration_queryable.py no repositório Github clonado, atualize a linha 3 e substitua , , pela configuração de conexão do cluster Atlas. Portanto, você deverá ter algo parecido com isto, depois de atualizar os detalhes da conexão do cluster Atlas.
1 encrypted_namespace = "DEMO-KMIP-QUERYABLE.users" 2 key_vault_namespace = "DEMO-KMIP-QUERYABLE.datakeys" 3 connection_uri = "mongodb+srv://admin:mPassword@demo-cluster.tcrpd.mongodb.net/myFirstDatabase?retryWrites=true&w=majority" 4 5 # Configure the "kmip" provider. 6 kms_providers = { 7 "kmip": { 8 "endpoint": "localhost:5697" 9 } 10 } 11 kms_tls_options = { 12 "kmip": { 13 "tlsCAFile": "vault/certs/QUERYABLE/vv-ca.pem", 14 "tlsCertificateKeyFile": "vault/certs/QUERYABLE/vv-client.pem" 15 } 16 }
Uma imagem de docker pré-cozida é preparada com o HashiCorp Vault instalado e uma biblioteca compartilhada do Mongodb. A biblioteca compartilhada do MongoDB é a camada de tradução que pega uma consulta não criptografada e a traduz em um formato criptografado que o servidor entende. É o que faz com que você não precise reescrever todas as suas consultas com chamadas de criptografia explícitas. Você não precisa construir a imagem do docker, pois ela já está publicada no docker hub. Inicie o contêiner na raiz deste repositório. O container será iniciado e a pasta atual será montada no kmip no container em execução. O 8200 da porta é mapeado para que você possa acessar o Console do Hashicorp Key Vault em execução no container do Docker. O ${PWD} é usado para definir o caminho atual a partir do qual você está executando o comando. Se estiver executando este tutorial no shell do Windows, substitua ${PWD} pelo caminho completo para a raiz do repositório clonado do Github.
1 docker run -p 8200:8200 -it -v ${PWD}:/kmip piepet/mongodb-kmip-vault:latest
A execução dos comandos abaixo no Docker container iniciado iniciará o HashiCorp Vault Server e configurará o mecanismo HashiCorp KMIP Secrets. Escopos, funções e certificados serão gerados, vv-client.pem, vv-ca.pem, vv-key.pem, separado para CSFLE ou Queryable Encryption.
1 cd kmip 2 ./start_and_configure_vault.sh -a
Aguarde até ver a saída abaixo no console de comando:
Agora você pode acessar o console do Hashicorpo Key Vault acessando a URL http://localhost:8200/. Você deve ver isso em seu navegador:
Vamos entrar no console do Hashicorpor para ver o que foi configurado. Use o resultado "Root token " gerado no console do shell. Depois de fazer login, você verá isto:
O script que você acabou de executar —
./start_and_configure_vault.sh -a
— usa o CLI do HashiCorp Vault para criar todas as configurações necessárias, como Escopos, Funções e Certificados. Você pode explorar o que foi criado clicando em demo/kmip.Se você quiser utilizar o servidor Hashicorpo Key Vault de fora do container Docker, você precisará adicionar a porta 5697.
Um aplicativo Python de amostra será usado para demonstrar os recursos do CSFLE, em que o esquema de criptografia é definido no banco de dados. Vamos começar examinando o método principal do aplicativo Python no arquivo localizado em
kmip-with-hashicorp-key-vault/vault_encrypt_with_csfle_kmip.py
.1 def main(): 2 reset() 3 #1,2 Configure your KMIP Provider and Certificates 4 kmip_provider_config = configure_kmip_provider() 5 #3 Configure Encryption Data Keys 6 data_keys_config = configure_data_keys(kmip_provider_config) 7 #4 Create collection with Validation Schema for CSFLE defined, will be stored in 8 create_collection_with_schema_validation(data_keys_config) 9 #5 Configure Encrypted Client 10 secure_client=configure_csfle_session() 11 #6 Run Query 12 create_user(secure_client) 13 if __name__ == "__main__": 14 main()
Linha 118: descarta o banco de dados, apenas para simplificar a reexecução deste tutorial. Em uma configuração de produção, isso seria removido.
Linha 120: Configura o driver do MongoDB para usar o mecanismo de segredos KMIP do Hashicorp Vault como o provedor de chaves. Isso significa que o CMK será gerenciado pelo mecanismo de segredos KMIP do Hashicorp Vault.
Linha 122: cria chaves de criptografia de dados a serem usadas para criptografar/descriptografar campos na collection. Os dados criptografados serão armazenados no banco de dados DEMO-KMIP-FLE na collection datakeys.
Linha 126: cria um MongoClient que habilita o CSFLE e usa o Mecanismo de segredos KMIP do HashiCorp Key Vault como provedor de chaves.
Linha 128: insere um usuário no banco de dados DEMO-KMIP-FLE e nos usuários da coleção , usando o MongoClient configurado na linha 126. Em seguida, ele faz uma pesquisa no campo SSN para validar se o driver do MongoDB pode executar queries de dados criptografados.
Vamos iniciar o aplicativo Python executando os comandos abaixo no container docker em execução:
1 cd /kmip/kmip-with-hashicorp-key-vault/ 2 python3.8 vault_encrypt_with_csfle_kmip.py
Inicie oMongoDB Compass, conecte-se ao seu banco de dados DEMO-KMIP-FLE e revise a collection users. Os campos que devem ser criptografados são ssn, Contact.Mobile e Contact.email. Agora você deve ser capaz de ver no Compass que os campos criptografados são ocultados por **++ mostrado como valor — veja a imagem abaixo:
Um aplicativo Python de amostra será usado para mostrar os recursos da Queryable Encryption, atualmente em visualização pública, com esquema definido no servidor. Vamos começar examinando o método principal do aplicativo Python no arquivo localizado em
kmip-with-hashicorp-key-vault/vault_encrypt_with_queryable_kmip.py
.1 def main(): 2 reset() 3 #1,2 Configure your KMIP Provider and Certificates 4 kmip_provider_config = configure_kmip_provider() 5 #3 Configure Encryption Data Keys 6 data_keys_config = configure_data_keys(kmip_provider_config) 7 #4 Create Schema for Queryable Encryption, will be stored in database 8 encrypted_fields_map = create_schema(data_keys_config) 9 #5 Configure Encrypted Client 10 secure_client = configure_queryable_session(encrypted_fields_map) 11 #6 Run Query 12 create_user(secure_client) 13 if __name__ == "__main__": 14 main()
Linha 121: descarta o banco de dados, apenas para simplificar a reexecução do aplicativo. Em uma configuração de produção, isso seria removido.
Linha 123: Configura o driver do MongoDB para usar o mecanismo de segredos KMIP do Hashicorp Vault como o provedor de chaves. Isso significa que o CMK será gerenciado pelo mecanismo de segredos KMIP do Hashicorp Vault.
Linha 125: cria chaves de criptografia de dados a serem usadas para criptografar/descriptografar campos na coleção. Os dados criptografados serão armazenados no banco de dados DEMO-KMIP-QUERYABLE em coleção datakeys.
Linha 127: Cria um esquema de criptografia que define quais campos precisam ser criptografados. É importante observar que o esquema de criptografia tem um formato diferente em comparação com o esquema de criptografia CSFLE.
Linha 129: cria um MongoClient que habilita a Queryable Encryption e usa o Mecanismo de segredos KMIP do HashiCorp Key Vault como provedor de chaves.
Linha 131: insere um usuário no banco de dados DEMO-KMIP-QUERYABLE e nos usuários da coleção , usando o MongoClient configurado na linha 129. Em seguida, ele faz uma pesquisa no campo SSN para validar se o driver do MongoDB pode executar queries de dados criptografados.
Vamos iniciar o aplicativo Python para testar a Queryable Encryption.
1 cd /kmip/kmip-with-hashicorp-key-vault/ 2 python3.8 vault_encrypt_with_queryable_kmip.py
Inicie oMongoDB Compass, conecte-se ao seu banco de dados DEMO-KMIP-QUERYABLE e verifique a collection users. Os campos que devem ser criptografados são ssn, Contact.Mobile e Contact.email. Agora você deve ser capaz de ver no Compass que os campos criptografados são ocultados por **++ mostrado como valor, conforme mostrado na imagem abaixo.
Se você quiser executar novamente o tutorial, execute o seguinte na raiz deste repositório git fora do container docker.
1 ./cleanup.sh
Neste blog, você aprenderá a configurar e configurar o CSFLE e o Queryble Encryption com o mecanismo de segredos KMIP do Hashicorpo Key Vault. Ao usar o KMIP, você terá uma maneira padronizada de gerenciar o ciclo de vida das chaves de criptografia, independentemente dos serviços de nuvem pública KMS. Saiba mais sobre CSFLE e Queryable Encryption.