Criptografia de arquivos em Python: uma análise aprofundada de técnicas simétricas e assimétricas

No mundo moderno, compartilhamos constantemente informações privadas, confidenciais e sensíveis por canais digitais. Um componente fundamental dessa comunicação é a criptografia de arquivos — a transformação de dados em um formato ilegível usando algoritmos de criptografia.

Há dois tipos principais de criptografia: simétrica e assimétrica. A criptografia simétrica é como um cofre com uma única chave. Se duas pessoas tiverem essa chave, poderão passar o cofre uma para a outra, sabendo que só elas conseguem abri-lo. Já a criptografia assimétrica usa um par de chaves. Imagine um cofre que pode ser trancado com uma chave, mas só pode ser aberto com outra. Você pode compartilhar a chave que tranca o cofre (a chave pública) com segurança, pois ninguém conseguirá abri-lo (descriptografar os dados) sem a chave que o destranca (a chave privada).

Este artigo explora o universo da criptografia em Python. Na criptografia simétrica, vamos nos concentrar no Key Management Service (KMS) da Amazon e no SecretBox do PyNaCl. Em seguida, veremos a criptografia assimétrica e o public/private box do PyNaCl.

Pré-requisitos

Para acompanhar este tutorial, você precisa de:

• Python instalado (v3.7 ou superior)

• pipenv instalado. Esse gerenciador de dependências do Python ajuda a evitar conflitos entre versões de pacotes. Instale-o com pip install pipenv.

• Instale os pacotes necessários (aws-encryption-sdk, PyNaCl e cryptography) executando pipenv install aws-encryption-sdk pynacl cryptography. 

• Uma conta AWS ativa e uma chave KMS (deixe à mão o ID da chave e as informações da região da AWS — vamos usá-los ao executar o programa Python).

• A ferramenta de linha de comando da AWS (awscli) instalada. Execute aws configure para configurar os ajustes da AWS na sua máquina. 

• Um novo projeto configurado em um ambiente isolado, criado com:

mkdir python_encryption && cd python_encryption
pipenv shell

Para conferir o resultado final, acesse o código completo do projeto.

Criptografia simétrica em Python

A criptografia simétrica usa a mesma chave para criptografar e descriptografar os dados. É simples, rápida, eficiente e ideal para proteger grandes volumes de dados.

Neste tutorial, vamos usar o Amazon KMS e o SecretBox do PyNaCl para implementar a criptografia simétrica em Python. O Amazon KMS ajuda a criar, controlar e gerenciar chaves de criptografia na nuvem da Amazon Web Services (AWS). Pense nele como um chaveiro na nuvem, com uma camada extra de segurança. SecretBox é uma biblioteca Python que torna a criptografia simples e acessível. Pense nela como um cofre pessoal.

Como usar o Amazon KMS e os SDKs de criptografia para criptografia simétrica

O Amazon KMS é um serviço na nuvem para gerenciar chaves criptográficas. Ele funciona perfeitamente com outros serviços da AWS e kits de desenvolvimento de software (SDKs) de criptografia, aproveitando a segurança robusta oferecida pela AWS. Sua integração estreita com os serviços e SDKs de criptografia da AWS faz dele uma ótima opção para aplicações baseadas na AWS. 

O motivo mais convincente para usar o KMS na criptografia simétrica é o gerenciamento de chaves secretas compartilhadas. O tratamento seguro dessas chaves pode ser o aspecto mais desafiador da criptografia. O Amazon KMS contorna essas dificuldades com elegância ao adotar um padrão de criptografia em envelope. Nessa abordagem, as próprias chaves são criptografadas junto com os dados. Assim, você depende principalmente de uma chave mestra em um módulo de segurança de hardware, que permanece inacessível a pessoas não autorizadas. Esse mecanismo de encapsulamento de chaves simplifica o processo de criptografia e elimina, na prática, as complexidades do gerenciamento e da rotação de chaves, além de outros desafios relacionados.

No entanto, o Amazon KMS pode ser desnecessário se você precisa apenas de uma solução simples e de pequena escala. Além disso, é um serviço pago, então os custos podem disparar com o uso intenso.

Agora, vamos usar o Amazon KMS para criptografar um arquivo em uma aplicação Python.

Importe os módulos necessários

Para interagir com o Amazon KMS, primeiro precisamos instalar e importar aws-encryption-sdk — o AWS Encryption SDK para Python, que simplifica os processos de criptografia e descriptografia. 

Crie um arquivo chamado main.py e adicione o código a seguir:

1import aws_encryption_sdk
2
3# Configuration
4KEY_ARNs = [
5    'arn:aws:kms:<REGION>:xxx:key/<KMS-KEY-ID>'
6]
7
8client = aws_encryption_sdk.EncryptionSDKClient()
9kms_key_provider = aws_encryption_sdk.StrictAwsKmsMasterKeyProvider(
10    key_ids=KEY_ARNs)
11

Observação: o ARN da chave KMS pode ser copiado no painel do AWS KMS.

Criptografe o arquivo

Vamos usar o AWS Encryption SDK para realizar a criptografia. O SDK tem integração estreita com o AWS KMS e oferece uma experiência de criptografia simples e integrada.

Adicione o código a seguir a main.py:

1def encrypt_file(file_path, encrypted_path):
2    with open(file_path, 'rb') as pt_file, open(encrypted_path, 'wb') as ct_file:
3        with client.stream(
4            mode='e',
5            source=pt_file,
6            key_provider=kms_key_provider
7        ) as encryptor:
8            for chunk in encryptor:
9                ct_file.write(chunk)

Descriptografe o arquivo

Mais uma vez, vamos usar o AWS Encryption SDK para descriptografar o arquivo. O processo de descriptografia lê o arquivo criptografado e usa as chaves KMS para descriptografar os dados de forma integrada.

Adicione os comandos a seguir a main.py:

1def decrypt_file(encrypted_path, decrypted_path):
2    with open(encrypted_path, 'rb') as ct_file, open(decrypted_path, 'wb') as pt_file:
3        with client.stream(
4            mode='d',
5            source=ct_file,
6            key_provider=kms_key_provider
7        ) as decryptor:
8            for chunk in decryptor:
9                pt_file.write(chunk)

Chame as funções

Criamos as funções; agora, precisamos chamá-las e executar o programa Python. Primeiro, crie um arquivo chamado myfile.txt e adicione algum conteúdo aleatório.

Em seguida, em main.py, chame as funções a seguir:

1encrypt_file('myfile.txt', 'encrypted_file.txt')
2decrypt_file('encrypted_file.txt', 'decrypted_file.txt')

Ao executar python main.py para rodar o script, criptografamos e depois descriptografamos myfile.txt, mantendo o conteúdo inalterado. 

Observação: para simplificar, definimos o ID da chave (como parte do ARN da chave) diretamente no código. Use o arquivo .env para armazenar informações confidenciais.

Como usar o SecretBox do PyNaCl para criptografia simétrica

PyNaCl é uma interface Python para a biblioteca de redes e criptografia libsodium. Ela reúne uma grande variedade de ferramentas criptográficas, incluindo SecretBox, que oferece funcionalidades de criptografia simétrica. A vantagem do SecretBox é a simplicidade: basta uma chave para criptografar e descriptografar nossos dados.

Vamos ver como criptografar um arquivo sensível em uma aplicação Python usando o SecretBox. 

Primeiro, crie um arquivo nacl.txt e adicione um texto de exemplo. Em seguida, importe os módulos necessários para um novo arquivo de programa Python chamado sym.py:

1from nacl import utils
2from nacl.secret import SecretBox
3import os

O próximo passo é gerar e carregar a chave secreta. A função generate_key gera uma chave aleatória, e a função load_key carrega a chave gerada do caminho do arquivo e a retorna:

1def generate_key(secret_key_file):
2    secret_key = utils.random(SecretBox.KEY_SIZE)
3    with open(secret_key_file, 'wb') as f:
4        f.write(secret_key)
5    return secret_key
6
7def load_key(secret_key_file):
8    if not os.path.exists(secret_key_file):
9        print(f"Key file {secret_key_file} not found.")
10    with open(secret_key_file, 'rb') as f:
11        key = f.read()
12    if len(key) != SecretBox.KEY_SIZE:
13        print("Incorrect key length.")
14    return key

Agora, vamos criptografar o arquivo. A função encrypt_file precisa do file_path e da chave para criptografar o arquivo sensível. Ela encontra o arquivo pelo file_path, lê e criptografa o conteúdo usando a chave secreta e grava o texto criptografado em um novo arquivo com a extensão .enc:

1def encrypt_file(file_path, key):
2    if not os.path.exists(file_path):
3        print(f"Key file {secret_key_file} not found.")
4    secret_box = SecretBox(key)
5    with open(file_path, 'rb') as f:
6        plaintext = f.read()
7    ciphertext = secret_box.encrypt(plaintext)
8    with open(file_path+'.enc', 'wb') as f:
9        f.write(ciphertext)

Assim como temos uma função para criptografar, também precisamos de uma função semelhante para descriptografar. A função decrypt_file recebe o file_path e a key para descriptografar um arquivo. Primeiro, verifica se existe um arquivo criptografado com extensão .enc (sim — nós o geramos na etapa anterior). Depois, lê o conteúdo e o descriptografa usando a mesma chave secreta. Por fim, grava o conteúdo descriptografado em um novo arquivo com a extensão .dec:

1def decrypt_file(file_path, key):
2    if not os.path.exists(file_path+'.enc'):
3        print(f"Key file {secret_key_file} not found.")
4    secret_box = SecretBox(key)
5    with open(file_path+'.enc', 'rb') as f:
6        ciphertext = f.read()
7    plaintext = secret_box.decrypt(ciphertext)
8    with open(file_path+'.dec', 'wb') as f:
9        f.write(plaintext)

A última etapa é chamar as funções que acabamos de criar:

1secret_key_file = 'secret.key'
2
3# generate key for encryption
4key = generate_key(secret_key_file)
5encrypt_file('nacl.txt', key)
6
7# load key for decryption
8key = load_key(secret_key_file)
9decrypt_file('nacl.txt', key)

Agora, você pode executar o programa Python com o comando sym.py no terminal.

Observação: este código não está pronto para uso em uma aplicação real ou em um ambiente de produção. O tratamento seguro das chaves de criptografia é uma tarefa complexa que envolve etapas adicionais, como a rotação regular das chaves. Este código não inclui essas medidas essenciais de segurança.

Criptografia assimétrica em Python

Enquanto a criptografia simétrica usa uma chave, a criptografia assimétrica usa duas: uma chave pública para criptografar e uma chave privada para descriptografar. É como uma caixa de correio que pode ser trancada. Qualquer pessoa pode depositar uma carta pela abertura (criptografia), mas só quem tiver uma chave exclusiva pode abri-la e ler a carta (descriptografia).

A criptografia assimétrica é especialmente adequada para proteger as comunicações pela internet. Se você quiser enviar uma mensagem secreta a um amigo, poderá criptografá-la com a chave pública dele; só ele poderá descriptografá-la com a chave privada. A criptografia assimétrica protege assinaturas digitais e certificados — a base da autenticação no mundo digital.

Como usar o public/private box do PyNaCl para criptografia assimétrica

Então, como fazer criptografia assimétrica em Python? Vamos conhecer outra ferramenta do PyNaCl: o public/private box. 

O public/private box do PyNaCl é parecido com uma caixa de correio pessoal. Ele oferece uma interface para criptografar e descriptografar mensagens com duas chaves: uma pública e outra privada. Podemos compartilhar abertamente a chave pública usada para criptografar mensagens. Já a chave privada, usada para descriptografar, deve ser mantida em segredo.

Primeiro, crie um arquivo chamado asym_nacl.txt e adicione um texto de exemplo. Precisamos permitir o armazenamento e a recuperação seguros das chaves de criptografia. A função save_key grava a chave em file_path, enquanto load_key busca e retorna a chave de file_path. 

Adicione o código a seguir a um novo arquivo chamado asym.py:

1from nacl.public import PrivateKey, Box
2import pickle
3
4def save_key(file_path, key):
5    with open(file_path, 'wb') as f:
6        pickle.dump(key, f)
7
8def load_key(file_path):
9    with open(file_path, 'rb') as f:
10        key = pickle.load(f)
11    return key

Agora, precisamos implementar funções para criptografar e descriptografar nosso arquivo sensível. A função encrypt_file usa chaves públicas para criptografar o arquivo e armazená-lo em um arquivo .enc com o texto criptografado. Já a função decrypt_file usa chaves privadas para abrir (descriptografar) o arquivo e armazená-lo em um arquivo .dec. 

Adicione as funções a seguir a asym.py:

1def encrypt_file(file_path, public_key):
2    private_key = PrivateKey.generate()
3    box = Box(private_key, public_key)
4
5    with open(file_path, 'rb') as f:
6        plaintext = f.read()
7
8    ciphertext = box.encrypt(plaintext)
9
10    with open(file_path+'.enc', 'wb') as f:
11        f.write(ciphertext)
12
13    return private_key
14
15def decrypt_file(file_path, private_key, public_key):
16    box = Box(private_key, public_key)
17
18    with open(file_path+'.enc', 'rb') as f:
19        ciphertext = f.read()
20
21    plaintext = box.decrypt(ciphertext)
22
23    with open(file_path+'.dec', 'wb') as f:
24        f.write(plaintext)

Por fim, chegou a hora de conferir o resultado de todo o nosso trabalho. Geramos duas chaves: a chave pública, que usamos para trancar o arquivo, e uma chave privada, que salvamos. Quando precisarmos acessar o arquivo, carregaremos a chave privada salva junto com a chave pública correspondente para descriptografá-lo. 

Adicione as chamadas finais de função ao arquivo asym.py:

1private_key = PrivateKey.generate()
2public_key = private_key.public_key
3
4encryption_private_key = encrypt_file('asym_nacl.txt', public_key)
5save_key('private.key', encryption_private_key)
6
7encryption_private_key = load_key('private.key')
8decrypt_file('asym_nacl.txt', private_key, encryption_private_key.public_key)

Execute o programa com python asym.py no terminal local.

Observação: o código acima demonstra como funcionam a criptografia e a descriptografia. No entanto, ele não é seguro para uso em aplicações reais. O arquivo da chave não está protegido; portanto, se alguém obtiver acesso a ele, poderá abrir seus arquivos.

Vantagens e desvantagens do public/private box do PyNaCl

O public/private box do PyNaCl oferece segurança robusta. Ele também permite a comunicação segura até mesmo por canais não seguros, o que o torna ideal para a comunicação pela internet.

Por outro lado, o gerenciamento de chaves pode ser complicado com o public/private box. Precisamos armazenar as chaves privadas com segurança e garantir que as chaves públicas corretas sejam usadas na criptografia. A criptografia assimétrica também pode ser mais lenta que a simétrica, pois envolve operações mais complexas.

Conclusão da nossa exploração

Neste artigo, exploramos algumas ferramentas poderosas de Python para implementar métodos de criptografia. O Amazon KMS e o SecretBox do PyNaCl são ótimas opções para criptografia simétrica, enquanto o public/private box do PyNaCl se destaca na criptografia assimétrica.

Essas ferramentas oferecem diversos benefícios para o tratamento seguro de dados. O Amazon KMS oferece escalabilidade excepcional; o SecretBox do PyNaCl tem alto desempenho e ampla compatibilidade; e o public/private box do PyNaCl permite comunicações altamente seguras. Juntas, essas ferramentas formam um kit completo de criptografia.

Ao escolher um método de criptografia, precisamos considerar o grau de sensibilidade dos dados, o ambiente em que vamos transmiti-los e como vamos gerenciar as chaves. Não existe um método de criptografia perfeito, mas é fácil encontrar aquele que melhor atende às nossas necessidades.