Conteúdo do curso Lição 78 de 156 · Privacidade desde a concepção
Privacidade desde a concepção

Guarde com segurança o que você guarda

Por que isso importa Mesmo um site cuidadoso guarda alguns dados: um e-mail para fazer login, uma senha, talvez um endereço para entregas. Bancos de dados são copiados, backups se perdem, notebooks são roubados. Bem feito, uma cópia roubada do seu banco de dados quase não diz nada ao ladrão. Esta lição cobre as duas ferramentas principais: hash de senhas e criptografia de campos em repouso.

Senhas: nunca as guarde, guarde uma impressão digital lenta

Pense em um liquidificador. Coloque um morango e você recebe uma vitamina; não consegue ter o morango de volta. Para conferir uma senha, você bate a tentativa do mesmo jeito e vê se a vitamina bate. Você nunca precisa do original.

Hash de senha: uma impressão digital de mão única de uma senha, feita com uma função propositalmente lenta e que usa um salt, para que hashes roubados sejam muito caros de adivinhar.

Salt: bytes aleatórios guardados ao lado de cada hash e misturados antes do hash, para que duas pessoas com a mesma senha recebam hashes diferentes e listas de palpites pré-calculadas não sirvam para nada.

Por que lenta? Um hash rápido como o SHA-256 simples pode ser testado bilhões de vezes por segundo, então senhas curtas caem rápido. Os hashes de senha são ajustados para levar uma fração perceptível de segundo cada. Isso não é nada para um login e é um custo enorme para alguém testando um bilhão de palpites. As escolhas mais usadas são Argon2id (a primeira recomendação do guia de armazenamento de senhas da OWASP), scrypt, bcrypt e PBKDF2 (verificado em outubro de 2026).

# Teaching code. In a real app, use your framework's password functions.
import hashlib, hmac, os

ROUNDS = 600_000    # PBKDF2-HMAC-SHA256 setting suggested by OWASP (checked October 2026)

def hash_password(password):
    salt = os.urandom(16)
    key = hashlib.pbkdf2_hmac("sha256", password.encode(), salt, ROUNDS)
    return salt.hex() + "$" + key.hex()

def check_password(password, stored):
    salt_hex, key_hex = stored.split("$")
    key = hashlib.pbkdf2_hmac("sha256", password.encode(), bytes.fromhex(salt_hex), ROUNDS)
    return hmac.compare_digest(key.hex(), key_hex)   # compare without leaking timing

No Django você não escreve isso: user.set_password() e check_password() já usam PBKDF2 por padrão, e o Django pode trocar para Argon2 ou scrypt nas configurações (verificado em outubro de 2026).

Um equívoco comum: "nós criptografamos nossas senhas". A criptografia pode ser desfeita por quem tem a chave, então uma única chave roubada revela todas as senhas. Senhas devem ter hash, nunca ser criptografadas.

Outros campos: criptografe em repouso, guarde a chave em outro lugar

Um endereço de e-mail precisa poder ser lido de novo (para enviar um recibo), então um hash de mão única não serve. Aqui você criptografa: tranca o valor com uma chave e o destranca só quando o app precisa.

Criptografia em repouso: guardar dados no banco de dados ou no disco em forma trancada, para que uma cópia dos arquivos fique ilegível sem a chave.

  • Mantenha a chave fora do banco de dados, por exemplo em uma variável de ambiente ou em um serviço de chaves. Uma chave guardada no mesmo backup que os dados não protege nada.
  • Use uma biblioteca verificada, nunca criptografia caseira. Em Python, o Fernet do pacote cryptography é uma escolha simples e segura.
  • Procurando coisas. Uma boa criptografia dá um resultado diferente a cada vez, mesmo para o mesmo e-mail, então você não consegue buscá-lo. Guarde ao lado um hash com chave, um HMAC (um hash misturado com uma chave secreta), e busque por ele. Sem a chave, o HMAC não pode ser atacado por força bruta como um hash simples.
# Concept sketch (needs: pip install cryptography)
from cryptography.fernet import Fernet
import hmac, hashlib
box = Fernet(ENCRYPTION_KEY)                      # key from the environment
email_enc = box.encrypt(email.encode())           # stored, readable only with the key
email_lookup = hmac.new(LOOKUP_KEY, email.strip().lower().encode(), hashlib.sha256).hexdigest()

É assim que funciona a lista de espera do navegador do próprio floati.life: o e-mail é guardado criptografado, as duplicatas são encontradas com um HMAC com chave do endereço, e só um hash do endereço IP é guardado para limitar a taxa de pedidos. O recurso "salvar em vários dispositivos" do Learn vai além e nunca guarda o e-mail, só uma impressão digital com chave, com o progresso criptografado (verificado em outubro de 2026).

O que isso protege, e o que não protege

A criptografia em repouso protege contra um backup roubado, um banco de dados copiado ou um disco perdido. Ela não protege contra um atacante que roda código dentro do seu app, porque seu app tem a chave. É por isso que coletar menos (lição 76) e apagar no prazo (próxima lição) continuam sendo o mais importante.

Em outras linguagens
// JavaScript (Node): password hashing with built-in scrypt
const salt = crypto.randomBytes(16);
const key = crypto.scryptSync(password, salt, 64);
// Go
hash, _ := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
// PHP (Argon2id where available)
$hash = password_hash($password, PASSWORD_ARGON2ID);
$ok = password_verify($attempt, $hash);
// C# (ASP.NET Core Identity)
var hash = new PasswordHasher<User>().HashPassword(user, password);

Resumo

  • Faça o hash das senhas com uma função lenta e com salt (Argon2id, scrypt, bcrypt ou PBKDF2); nunca as criptografe.
  • Criptografe os campos que você precisa ler de volta, mantenha a chave fora do banco de dados e busque-os com um HMAC com chave.
  • A criptografia em repouso impede cópias roubadas, não um atacante dentro do seu app em execução.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.