Protegendo suas Credenciais de Acesso com Python: Biblioteca de Fernet.

Esse artigo é para falarmos sobre um método relativamente simples de proteger suas credenciais ou dados utilizando uma biblioteca em Python.

Segurança de dados não é mais uma discussão antiga, tudo que fazemos tem alguns cuidados a serem tomados. Eu não estou falando isso apenas por conta da LGPD (Lei Geral de Proteção de Dados), mas também pelo lado de resguadarmos nossos processos e eles estarem sob um controle de acessos.

Em particular, hoje vou concentrar o uso dessa biblioteca para o cenário de proteção de credenciais de acesso, como chaves de APIs, usuários, senhas.

Vamos juntos?

O que é a biblioteca de Fernet?

A biblioteca Fernet em Python oferece uma maneira simples e segura de realizar criptografia simétrica, ideal para cenários de proteção de credenciais e senhas.

Fernet é uma implementação de criptografia simétrica (também conhecida como criptografia de chave secreta) que faz parte da biblioteca cryptography em Python. Ele é projetado para ser fácil de usar e seguro por padrão. A ideia central da criptografia simétrica é que a mesma chave é usada tanto para criptografar quanto para descriptografar os dados.

Por meio dessa biblioteca, é possível garantir que uma mensagem criptografada não possa ser manipulada ou lida sem a chave correta.

Principais utilidades

A principal utilidade do Fernet é proteger informações confidenciais que precisam ser armazenadas ou transmitidas. Alguns casos de uso comuns incluem:

• Criptografar credenciais de API: Como chaves de acesso, tokens de autenticação.
• Proteger dados de configuração sensíveis: Senhas de banco de dados, nome de usuários, chaves secretas de aplicações.
• Criptografar mensagens ou arquivos: Quando você precisa garantir que apenas o destinatário com a chave possa acessá-los. Especialmente em se tratando de dados sensíveis.
• Tokens seguros: Gerar tokens que não podem ser facilmente forjados ou lidos.

Veja bem, como a mesma chave é usada para criptografar e descriptografar, a segurança da chave em si é fundamental. Se a chave for comprometida, a segurança dos dados criptografados também será.

Faço um adendo aqui, se você estiver trabalhando com Cloud, utilize de Secret Management para armazenar e proteger suas chaves, possibilitando apenas que certos usuários liberados verifiquem e acessem essas informações.

Case Prático: Criptografando Credenciais de API

Vamos ver um exemplo prático de como usar Fernet para criptografar e descriptografar credenciais de API.

Primeiro, você precisa instalar a biblioteca cryptography:

pip install cryptography.fernet

Após ter a biblioteca instalada, agora você precisa gerar uma chave de criptografia. Esta chave deve ser mantida em segredo e armazenada de forma segura.

Reiterando, se você estiver em um ambiente de cloud, utilize os recursos de Secret Managers ou cofres opara armazenar com segurança dessa chave. Lembre que essa chave será literalmente o que é “liga” sua função de decriptografia para você acessar suas variáveis encriptadas.

No caso de estar lidando com dados em sua máquina local, você pode utilizar o recurso de PLACEHOLDER para compartilhar seus scripts sem expor as chaves).

Nessa etapa, você só precisar executar o código acima uma vez para gerar sua chave. Guarde essa chave em um local seguro (por exemplo, uma variável de ambiente, um arquivo .env protegido ou um serviço de gerenciamento de segredos). Não gere uma nova chave toda vez que for criptografar ou descriptografar, pois você precisará da mesma chave para ambas as operações.

from cryptography.fernet import Fernet 

chave = Fernet.generate_key()
with open('secret.key', 'wb') as key_file:
    key_file.write(chave)

Em seguida, implementei uma lógica que ele salve a chave em um arquivo (.key) o qual chamei de secret.key. Depois disso, armazeno essa chave em um objeto e abro o meu arquivo de credenciais que salvei com as minha credenciais “abertas”, ou melhor, sem proteção alguma.

A ideia aqui é que ao encriptar essas credenciais, elas sejam salvas sobrepostas ao mesmo arquivo, para facilitar minha gestão nas próximas etapas.

#Importando biblioteca de criptografia 
from cryptography.fernet import Fernet 

#Abrindo o arquivo que contém a chave de criptografia
with open ("secret.key","rb") as arquivo_chave:
    chave_fernet = arquivo_chave.read()

#Estou criando o objeto que armazena a chave de criptografia
objeto_chave = Fernet(chave_fernet) 

#Aqui vamos abrir o arquivo que declarei minhas credenciais :client_id e client_secret
with open ("credenciais.env", "r") as arquivo_credenciais:
    arquivo_credenciais = arquivo_credenciais.readlines()

#Lista para armazenar as linhas encriptadas, porque nesse arquivo eu tenho 2 variaveis
#Mas adapte para seu caso, em que você pode ter mais variáveis
linhas_encriptadas = []

#Utilizando a lista para armazenar as linhas encriptadas
#Criei uma lógica para ignorar linhas em branco e comentários, se caso tiver
for linha in arquivo_credenciais:
    if not linha.strip() or linha.strip().startswith("#"):
        linhas_encriptadas.append(linha)
        continue

    #Aqui estou separando o nome da credencial e o valor da credencial
    #Utilizando o split para separar o nome da credencial e o valor da credencial
    #O split está utilizando o primeiro sinal de igual para separar o nome da credencial e o valor da credencial

    nome_credencial,valor_credencial = linha.strip().split("=", 1)

    #Aqui estou encriptando o valor da credencial, utilizando o objeto que contém a chave 
    #e além do objeto, estou aplicando o método encrypt para encriptar o valor da credencial 

    valor_credencial_encriptado = objeto_chave.encrypt(valor_credencial.encode()).decode()
    #Aqui estou formatando a linha encriptada, utilizando o nome da credencial e o valor da credencial encriptado
    linhas_encriptadas.append(f"{nome_credencial}={valor_credencial}\n")

#Aqui estou sobrescrevendo as linhas encriptadas no arquivo credenciais.env
with open ("credenciais.env", "w") as credenciais_file:
    credenciais_file.writelines(linhas_encriptadas)

#Ao final do processo, fecho o arquivo de credenciais
credenciais_file.close()

Veja bem, a lógica é meio padrão, mas você vai adequando ao seu cenário, ao número de credenciais que você tem em mãos, ao ambiente que você tá trabalhando, cloud ou localmente, e por aí vai.

Quando sua aplicação precisar usar as credenciais, você as carregará e descriptografará usando a mesma chave.

Acompanhe a lógica que implementei abaixo:

#De novo, importanto a biblioteca Fernet do módulo cryptography
from cryptography.fernet import Fernet
#Importando os para manipular variáveis de ambiente
import os 

# Abrindo o arquivo que contém a chave de criptografia
with open ("secret.key","rb") as arquivo_chave:
    chave = arquivo_chave.read()   

# Estou criando o objeto que armazena a chave de criptografia
objeto_chave = Fernet(chave)

# Aqui vamos abrir o arquivo que declarei minhas credenciais :client_id e client_secret
with open("credenciais.env", "r") as arquivo_credenciais:
    linhas = arquivo_credenciais.readlines()

# Lista para armazenar as linhas descriptografadas
arquivo_credenciais_linhas = []

# Utilizando a lista para armazenar as linhas descriptografadas
# Criei uma lógica para ignorar linhas em branco e comentários, se caso tiver
for linha in linhas:
    if not linha.strip() or linha.strip().startswith("#"):
        continue 
    # Aqui estou separando o nome da credencial e o valor da credencial
    # Utilizando o split para separar o nome da credencial e o valor da credencial
    nome_chave, valor_encriptado = linha.strip().split("=", 1)
    print (f"Descriptografando {nome_chave}...")

    # Aqui estou descriptografando o valor da credencial, utilizando o objeto que contém a chave
    # e além do objeto, estou aplicando o método decrypt para descriptografar o valor da credencial
    # O encode é necessário para converter de string para bytes
    # O decode é necessário para converter de bytes para string

    try:
        decrypted_value = objeto_chave.decrypt(valor_encriptado.encode()).decode()
        os.environ[nome_chave] = decrypted_value
        print(f"{nome_chave} descriptografado com sucesso.")
    #Esse bloco de exceção captura erros de descriptografia
    except Exception as e:
        print(f"Erro ao descriptografar {nome_chave}: {e}")

# Obtendo as variáveis de ambiente descriptografadas
client_id = os.getenv("CLIENT_ID")
client_secret = os.getenv("CLIENT_SECRET")

Nesse script, até utilizei a biblioteca os para acessar minhas variáveis de ambiente de uma forma mais simples. Aproveite da flexibilidade do python para adequar às suas necessidades e processos.

Um ponto de atenção é que o aspecto mais crítico é a gestão da chave Fernet. Se um invasor obtiver acesso à sua chave, ele poderá descriptografar todas as suas credenciais.

Considere o uso de:

• Variáveis de ambiente: armazene a chave como uma variável de ambiente no servidor local onde sua aplicação roda.
• Arquivos de configuração protegidos: armazene a chave em um arquivo com permissões restritas.
• Serviços de gerenciamento de segredos: Para aplicações em cloud, utilize serviços como HashiCorp Vault, AWS Secrets Manager, Google Cloud Secret Manager, ou Azure Key Vault.
• Rotação de chaves: embora Fernet não forneça um mecanismo direto para rotação de chaves “ativas”, você pode implementar uma lógica para isso, por exemplo, adicionando um prefixo à cifra para indicar qual chave foi usada, permitindo que chaves antigas ainda descriptografem dados antigos enquanto novos dados são criptografados com uma nova chave.

Ah, antes que eu me esqueça…

Mesmo que você tenha uma credencial ou um dado com 10 caracteres, por exemplo, você provavelmente vai obter uma versão criptografada disso com muito mais que 10 caracteres. Isso acontece porque a criptografia moderna não somente “modifica” os dados, mas também adiciona algumas camadas de segurança, timestamp e até assinaturas digitais.

Finalizando…

A lógica que te apresentei acima é para que você entenda o mecanismo de funcionamento dessa biblioteca e , em especial, o o funcionamento dos métodos encrypt e decrypt.

Aqui eu gostaria de propor um desafio e modificar aquele código para uma lógica de POO, utilizando classes e funções para flexibilizar e garantir a escalabilidade do seu código.

Eu vou deixar uma sugestão pessoal no final do artigo, mas sem cola, rs.

Obrigada por ter lido até aqui, espero que tenha sido útil para você!

Vamos juntos, nos códigos e nos bugs e até a próxima!

Para quem quiser saber mais sobre a biblioteca, segue a documentação oficial:

[embed]Fernet (symmetric encryption) - Cryptography 46.0.0.dev1 documentation Fernet guarantees that a message encrypted using it cannot be manipulated or read without the key. Fernet is an…cryptography.io