Hashing e armazenamento de senhas: salts, bcrypt, Argon2 e o que não fazer
Uma senha nunca deve ser armazenada: apenas o resultado de uma transformação lenta, com salt e de mão única. Aprenda como o hashing funciona, por que hashes rápidos falham com senhas e o que bcrypt e Argon2 fazem de diferente.
O que você vai aprender
- Explicar o que uma função hash garante — e o que ela não garante
- Diferenciar hashing de criptografia
- Explicar salts, peppers e fatores de trabalho em linguagem simples
- Escolher entre bcrypt, scrypt e Argon2
- Identificar os erros de armazenamento de senhas por trás de vazamentos reais
- O que é uma função hash
- Hashing não é criptografia
- Como o armazenamento de senhas deve funcionar
- Por que os vazamentos ainda acontecem
- Erros comuns
- Experimente: Hash Generator
- Perguntas frequentes
O que é uma função hash
A função hash recebe uma entrada de qualquer tamanho e retorna uma impressão digital de tamanho fixo — um digest. O SHA-256 sempre retorna 256 bits (64 caracteres hex), seja a entrada uma letra ou um filme inteiro. Boas funções hash têm quatro propriedades:
Determinística
A mesma entrada sempre produz a mesma saída. Sem aleatoriedade, sem exceções.
Unidirecional
Você não pode reconstruir a entrada a partir da saída. A única maneira de “reverter” um hash é adivinhar entradas até que uma corresponda.
Efeito avalanche
Mudar um bit da entrada muda cerca de metade dos bits da saída.
passwordepassworenão têm nada visivelmente em comum como hashes.Resistente a colisões
É inviável encontrar duas entradas diferentes com a mesma saída. (Não é impossível em teoria — apenas mais trabalho do que qualquer um pode fazer.)
Experimente: gere o hash de hello e hellp no Hash Generator e compare — cada caractere do digest muda. Esse é o efeito avalanche, e é o que torna os hashes úteis como impressões digitais: se o SHA-256 de um arquivo baixado corresponde ao do editor, o arquivo não foi adulterado.
Hashing não é criptografia
Esta é a confusão que causa mais danos. A criptografia é reversível — o texto cifrado mais a chave devolve o texto simples, por design. O hashing é unidirecional — não há chave nem descriptografia. Eles resolvem problemas diferentes: a criptografia protege dados que você precisa ler novamente; o hashing verifica dados que você nunca precisa ler novamente.
Esse é exatamente o caso da senha. Um sistema de login nunca precisa saber sua senha — só precisa verificar se a senha que você digitou corresponde à que você escolheu no cadastro. Então ele armazena um hash e, no login, gera o hash do que você digitou e compara os digests. Se o banco de dados vazar, o invasor obtém hashes, não senhas — desde que o hashing tenha sido feito corretamente, que é o assunto do restante deste guia.
Como o armazenamento de senhas deve funcionar
Armazenar SHA-256(password) não é “feito corretamente”. Um hash rápido é um presente para um invasor com GPU: o hardware moderno tenta bilhões de palpites de SHA-256 por segundo, e senhas comuns caem em minutos. O armazenamento adequado de senhas tem três ingredientes:
Um salt único por senha
A salt é uma string aleatória (16+ bytes) gerada para cada usuário e armazenada junto ao hash. Isso significa que senhas idênticas recebem hashes diferentes — para que um invasor não possa pré-computar uma rainbow table e quebrar todas as contas de uma vez, e não consiga saber quais usuários compartilham uma senha.
Um hash lento com um fator de trabalho
Hashes de senha devem ser deliberadamente lentos — centenas de milissegundos por palpite em vez de nanossegundos. O fator de trabalho (custo) ajusta essa lentidão, e deve aumentar conforme o hardware fica mais rápido.
Um design memory-hard (melhor prática moderna)
GPUs quebram hashes rápidos em paralelo. Funções memory-hard forçam cada palpite a usar um pedaço de RAM, da qual as GPUs têm pouco por núcleo — nivelando o campo.
| Algoritmo | Tipo | Usar? |
|---|---|---|
| bcrypt (1999) | Adaptativo, salt embutido | Sim — o padrão seguro, testado em batalha |
| scrypt | Memory-hard | Sim — bom, precisa de parâmetros cuidadosos |
| Argon2id | Memory-hard, escolha da OWASP | Sim — a recomendação moderna |
| PBKDF2 | HMAC iterado | Aceitável com muitas iterações (600k+ para SHA-256) |
| MD5 / SHA-1 / plain SHA-256 | Hashes rápidos de uso geral | Não — nunca para senhas |
A verificação então funciona assim: pegue a senha que o usuário digitou, pegue o salt armazenado, execute a mesma função lenta e compare o resultado com o hash armazenado usando uma comparação em tempo constante (para que o tempo gasto não revele quantos caracteres corresponderam). A senha em texto simples nunca é gravada em disco.
Por que os vazamentos ainda acontecem
Quase todo título de “milhões de senhas vazadas” remonta a uma de uma lista curta de falhas: senhas armazenadas em texto simples; senhas com hash MD5 ou SHA-1 e sem salt; um salt compartilhado por todos os usuários; ou um algoritmo caseiro que o autor achava inteligente. Em cada caso, o invasor não quebrou a matemática — ele entrou por uma porta que os desenvolvedores deixaram aberta.
A defesa em profundidade ao redor do hashing também importa: exija senhas fortes (ou melhor, passkeys), limite a taxa de tentativas de login, alerte sobre logins incomuns e assuma que o banco de dados vai vazar um dia — porque a questão não é se o seu armazenamento é perfeito, mas quão caro você torna o vazamento.
Erros comuns
- Armazenar senhas em texto simples ou “criptografadas”. A criptografia é reversível — qualquer pessoa com a chave (ou o banco de dados e o código) lê todas as senhas.
- MD5/SHA-1/SHA-256 sem salt. Bilhões de palpites por segundo, rainbow tables, senhas idênticas visíveis de relance.
- Um salt para todos. Um salt compartilhado é pouco melhor que nenhum salt — pré-compute uma vez, quebre todos.
- Inventar seu próprio algoritmo. Criptografia é onde “eu escrevi o meu” significa com segurança “cometi um erro que não consigo ver”. Use bcrypt, scrypt ou Argon2.
- Truncar senhas. Cortar uma senha para 8 ou 16 caracteres antes do hashing joga fora a entropia que o usuário forneceu.
- Registrar senhas em logs. Senhas em logs de aplicativo acabam em agregadores de logs, backups e tickets de suporte. Nunca registre entradas de autenticação em logs.
Experimente: Hash Generator
Digite uma palavra no Hash Generator e veja seu SHA-256 mudar completamente quando você muda uma letra — o efeito avalanche — e continue lendo para saber por que o SHA-256 sozinho ainda é a ferramenta errada para senhas.
Continue aprendendo
Perguntas frequentes
Um hash pode ser revertido?
Não diretamente — não há descriptografia. Os invasores adivinham: eles geram hashes de senhas prováveis (dicionários, listas de senhas vazadas, força bruta) até que um corresponda. Hashes lentos e com salt tornam cada palpite caro, e essa é toda a defesa.
O SHA-256 é seguro?
Como hash de uso geral, sim — para integridade de arquivos, certificados e HMAC, ele é o padrão. Para senhas, não: ele é rápido demais. A segurança depende do trabalho, e o armazenamento de senhas precisa de uma função lenta e com salt, como Argon2id ou bcrypt.
O que exatamente é um salt?
Um valor aleatório, único por senha, armazenado junto ao hash e misturado no hashing. Ele impede rainbow tables pré-computadas e faz senhas idênticas gerarem hashes diferentes. Ele não é secreto — é armazenado em texto simples junto ao hash — e tudo bem, porque seu trabalho é a unicidade, não o sigilo.
Se o banco de dados vazar, senhas bcrypt com salt são seguras?
Muito mais seguras que texto simples ou hashes rápidos — quebrar cada uma custa tempo e hardware de verdade. Mas senhas fracas (123456, qwerty) ainda caem rápido em ataques de dicionário, e é por isso que a força da senha e o monitoramento de vazamentos ainda importam mesmo com armazenamento perfeito.
Devo criptografar senhas em vez de gerar hashes?
Não. A criptografia é reversível, então qualquer pessoa que obtenha a chave lê todas as senhas. O hashing é unidirecional por design — o sistema nunca precisa da senha original, apenas de uma maneira de verificar um palpite contra ela.