Todos os artigos
176 artigos · atualizado semanalmente Veja nossas Ferramentas
Todos os artigos
Tutoriais

Hash de senha: bcrypt, scrypt ou Argon2id? Qual usar em 2026

Por que MD5 e SHA-256 não servem para senha, o que salt e pepper resolvem e como escolher entre bcrypt, scrypt, Argon2id e PBKDF2, com parâmetros OWASP.

Hash de senha: bcrypt, scrypt ou Argon2id? Qual usar em 2026
COVER · Tutoriais

Em junho de 2012, cerca de 6,5 milhões de hashes de senha do LinkedIn apareceram num fórum russo. Eram SHA-1 sem salt. Quatro anos depois, em maio de 2016, o dump completo do mesmo incidente foi posto à venda: mais de 117 milhões de contas. A KoreLogic pegou a lista para análise e quebrou 65% dos hashes em umas duas horas; no dia seguinte já tinha a senha de cerca de 86% dos usuários do dump. Ninguém precisou de criptoanálise sofisticada. Bastou a escolha errada de algoritmo.

A pergunta não é se a sua tabela de usuários um dia vai parar num fórum, e sim o que o atacante encontra quando ela parar. Este post resolve a parte prática: por que hash rápido não serve, o que salt e pepper resolvem de verdade, e qual algoritmo usar, com os parâmetros atuais da OWASP e código testado em Python, Node e Go. Se você quer antes a base sobre MD5, SHA-1 e SHA-256 e para que cada um serve, ela está no post sobre MD5, SHA-1 e SHA-256; aqui eu parto do ponto em que esses algoritmos deixam de servir.

Por que hash rápido é o inimigo

MD5, SHA-1 e SHA-256 são funções de hash de propósito geral. Foram feitas para processar gigabytes por segundo, e isso é ótimo para checksum de arquivo e péssimo para senha. Uma RTX 4090 calcula na faixa de 22 bilhões de SHA-256 por segundo no hashcat. Uma senha de 8 caracteres alfanuméricos (maiúsculas, minúsculas e dígitos) tem 62^8, pouco mais de 218 trilhões de combinações: força bruta pura leva cerca de 2,7 horas numa placa só. E ninguém faz força bruta pura. Com dicionário e regras de mutação, a maioria das senhas reais cai em minutos.

Sem salt, ainda tem o agravante que matou o LinkedIn: o mesmo input sempre gera o mesmo output. Dois usuários com "123456" têm o mesmo hash, então quebrar um quebra todos, e tabelas pré-computadas (as rainbow tables) servem para qualquer banco que use o mesmo algoritmo cru.

A conclusão é direta: hash de senha não pode ser rápido nem determinístico de forma ingênua.

O que um hash de senha precisa ter

Primeiro, ser lento e ajustável. Um único hash deve custar algo entre 100 e 500 milissegundos no seu servidor. Para o login isso é imperceptível; para quem testa bilhões de palpites, vira uma parede. O "ajustável" importa porque hardware fica mais rápido todo ano, e você precisa de um parâmetro (o work factor) para subir o custo sem trocar de algoritmo.

Segundo, ter salt único por senha. O salt é um valor aleatório, de 16 bytes ou mais, gerado para cada hash. Ele mata rainbow tables e faz duas senhas iguais virarem hashes diferentes. O salt não é segredo: fica guardado junto do hash. O que ele não resolve é senha fraca. Se a senha é 123456, o atacante ainda testa esse palpite contra o salt daquele usuário específico, só que agora um usuário por vez.

Terceiro, idealmente ser memory-hard: exigir uma quantidade relevante de RAM por cálculo. GPUs e ASICs têm milhares de núcleos baratos, mas memória rápida por núcleo é cara e limitada. Um algoritmo que pede 19 ou 64 MiB por hash derruba o paralelismo que torna o ataque em GPU barato.

Qual algoritmo usar: a decisão direta

A Password Storage Cheat Sheet da OWASP põe a ordem assim: Argon2id primeiro; scrypt se Argon2id não estiver disponível; bcrypt para sistemas legados; PBKDF2 quando há exigência de FIPS-140. Na prática:

Cenário Escolha
Sistema novo, sem restrição Argon2id (m=19 MiB, t=2, p=1 como mínimo)
Sem Argon2id na sua stack scrypt (N=2^17, r=8, p=1)
bcrypt já em produção e bem implantado Mantenha, com custo 12 ou mais
Exigência de FIPS-140 PBKDF2-HMAC-SHA256 com 600.000 iterações
Legado com MD5/SHA crus Migre no próximo login (veja abaixo)

Minha opinião: em projeto novo, Argon2id e não se discute mais. bcrypt não está quebrado, mas não há motivo para começar nele em 2026 se a sua linguagem tem uma boa biblioteca de Argon2.

Argon2id: parâmetros da OWASP e código

O Argon2 venceu a Password Hashing Competition em 2015 e virou a RFC 9106 em 2021. Tem três variantes. O Argon2d usa acesso à memória dependente dos dados, o que maximiza a resistência a GPU mas abre espaço para ataque de side-channel. O Argon2i faz o contrário: acesso independente dos dados, resistente a side-channel, mais fraco contra ataque de tempo-memória. O Argon2id é o híbrido: pela RFC 9106, ele funciona como Argon2i na primeira metade do primeiro passe sobre a memória e como Argon2d no resto. É a variante que a RFC exige de toda implementação e a que você deve usar para senha.

Os três parâmetros são memória (m, em KiB), iterações (t) e paralelismo (p). A OWASP lista configurações equivalentes entre si, trocando memória por iterações:

m (memória) t (iterações) p
47.104 KiB (46 MiB) 1 1
19.456 KiB (19 MiB) 2 1
12.288 KiB (12 MiB) 3 1
9.216 KiB (9 MiB) 4 1
7.168 KiB (7 MiB) 5 1

São mínimos, não alvos. Se o servidor aguenta mais memória por login sem engasgar sob carga, suba. Em Python, com argon2-cffi:

from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError

ph = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)

hashed = ph.hash("minha-senha")
# $argon2id$v=19$m=19456,t=2,p=1$<salt>$<hash>

try:
    ph.verify(hashed, "minha-senha")
    print("senha válida")
except VerifyMismatchError:
    print("senha inválida")

Detalhe útil: sem argumentos, o PasswordHasher() do argon2-cffi já usa o perfil de baixa memória da RFC 9106 (m=64 MiB, t=3, p=4), que fica acima do mínimo da OWASP.

Em Node, com o pacote argon2:

import argon2 from 'argon2';

const hash = await argon2.hash('minha-senha', {
  type: argon2.argon2id,
  memoryCost: 19456, // KiB = 19 MiB
  timeCost: 2,
  parallelism: 1,
});

await argon2.verify(hash, 'minha-senha'); // true

Em Go, o golang.org/x/crypto/argon2 só devolve os bytes da chave. O formato da string é problema seu, e é aí que muito exemplo na internet erra: guardar só o hash, sem salt e sem parâmetros, torna impossível verificar depois. Gere a string PHC completa:

import (
	"crypto/rand"
	"encoding/base64"
	"fmt"

	"golang.org/x/crypto/argon2"
)

func HashPassword(password string) (string, error) {
	salt := make([]byte, 16)
	if _, err := rand.Read(salt); err != nil {
		return "", err
	}
	const t, m, p, keyLen = 2, 19456, 1, 32
	key := argon2.IDKey([]byte(password), salt, t, m, p, keyLen)

	b64 := base64.RawStdEncoding
	return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
		argon2.Version, m, t, p,
		b64.EncodeToString(salt), b64.EncodeToString(key)), nil
}

A verificação faz o caminho inverso: separa a string por $, lê m, t e p, decodifica salt e hash, recalcula com argon2.IDKey e compara com subtle.ConstantTimeCompare. Como o formato é o mesmo, um hash gerado pelo Python acima verifica nesse código Go, e vice-versa.

bcrypt: anatomia do hash e o limite de 72 bytes

O bcrypt é de 1999, desenhado por Niels Provos e David Mazières especificamente para senha. O custo é exponencial: cada incremento dobra o trabalho. A OWASP pede custo mínimo 10; 12 é o padrão de muitos frameworks. A string de saída carrega tudo:

$2b$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/lewrHzPjBPJgTEyF2

$2b$                              → versão do algoritmo
12                                → custo (2^12 rodadas)
LQv3c1yqBWVHxkd0LHAkCO            → salt (22 caracteres, 128 bits)
Yz6TtxMQJqhN8/lewrHzPjBPJgTEyF2   → hash (31 caracteres)

Por isso você guarda uma coluna só, de 60 caracteres, e a função de verificação extrai salt e custo da própria string.

A pegadinha do bcrypt é o limite de entrada de 72 bytes. A maioria das implementações ignora em silêncio o que passa disso; testei o bcryptjs 3 e ele continua truncando: duas senhas que só diferem depois do byte 72 batem com o mesmo hash. A bcrypt do Python (pyca) mudou na versão 5.0 e agora lança ValueError em vez de truncar. Em bytes, não caracteres: com acento e emoji, 72 bytes chegam antes de 72 letras. A OWASP sugere limitar a senha a 72 bytes ou fazer um pré-hash com chave, que é exatamente o que a seção de pepper abaixo faz.

scrypt e PBKDF2: quando entram

O scrypt (Colin Percival, 2009) foi o primeiro memory-hard de uso amplo e é o plano B da OWASP quando não há Argon2id. Os parâmetros recomendados são N=2^17, r=8, p=1, o que dá 128 MiB por hash (a memória é cerca de 128 × N × r bytes). E aqui o hashlib.scrypt do Python morde: ele herda o limite padrão de memória do OpenSSL, de 32 MiB. Testei com OpenSSL 3.0 e até N=2^15 com r=8, que precisa de exatamente 32 MiB, falha com memory limit exceeded. Passe maxmem com folga:

import hashlib, os

salt = os.urandom(16)
key = hashlib.scrypt(
    b"minha-senha", salt=salt,
    n=2**17, r=8, p=1,
    maxmem=256 * 1024 * 1024,  # precisa de ~128 MiB; o padrão do OpenSSL é 32 MiB
    dklen=32,
)

Note que isso devolve só os bytes da chave. Ao contrário do bcrypt e das bibliotecas de Argon2, você precisa guardar salt e parâmetros junto, num formato seu. É um dos motivos para preferir Argon2id.

O PBKDF2 não é memory-hard, então é o mais barato de atacar em GPU dos quatro. Ele entra quando a exigência é FIPS-140, e aí a OWASP pede PBKDF2-HMAC-SHA256 com 600.000 iterações (ou HMAC-SHA512 com 220.000):

import hashlib, hmac, os

salt = os.urandom(16)
key = hashlib.pbkdf2_hmac("sha256", b"minha-senha", salt, 600_000)
# na verificação: recalcule e compare com hmac.compare_digest

Pepper do jeito certo: HMAC antes do hash

O pepper é um segredo global, igual para toda a aplicação, guardado fora do banco (cofre de segredos, HSM, no mínimo uma variável de ambiente). Ele protege o cenário em que só o banco vaza: sem o pepper, o atacante não consegue nem testar palpites. Se o servidor de aplicação inteiro for comprometido, o pepper vai junto. É camada extra, não garantia.

O erro clássico é concatenar: bcrypt(senha + pepper). Por causa do limite de 72 bytes, uma senha longa empurra o pepper para fora do trecho que o bcrypt considera, e ele deixa de ter efeito justamente para essas senhas (ou, na pyca/bcrypt 5, o login passa a dar erro). A outra tentação, fazer bcrypt(sha256(senha)) sem chave para contornar o limite, abre a porta para o password shucking: o atacante pega hashes SHA-256 crus vazados de outro site e testa direto como entrada do bcrypt, sem precisar descobrir a senha.

O que a OWASP recomenda é HMAC com o pepper como chave, codificado em base64 (para não ter byte nulo, que algumas implementações tratam como fim da string):

import base64, hashlib, hmac, os
import bcrypt

PEPPER = os.environ["PASSWORD_PEPPER"].encode()  # fora do banco

def _peppered(plain: str) -> bytes:
    mac = hmac.new(PEPPER, plain.encode("utf-8"), hashlib.sha384).digest()
    return base64.b64encode(mac)  # 64 bytes ASCII, cabe nos 72 do bcrypt

def hash_password(plain: str) -> bytes:
    return bcrypt.hashpw(_peppered(plain), bcrypt.gensalt(rounds=12))

def verify_password(plain: str, stored: bytes) -> bool:
    return bcrypt.checkpw(_peppered(plain), stored)

Isso resolve três coisas de uma vez: o pepper sempre conta, senha de qualquer tamanho funciona (testei com 100 caracteres diferindo só no último), e hash cru de outro vazamento não serve como atalho. Com Argon2id não existe limite de 72 bytes, mas o mesmo HMAC antes do hash funciona igual se você quiser pepper. Planeje a rotação: trocar o pepper invalida todos os hashes, então guarde um identificador da versão do pepper ao lado do hash e regrave no login.

Verificação, rehash e migração no login

Nunca compare hashes com ==. Use a função verify da biblioteca, que lê os parâmetros da própria string e compara em tempo constante.

Quando você sobe os parâmetros, não precisa forçar ninguém a trocar de senha. No login bem-sucedido você tem a senha em texto na mão por um instante; é a hora de regravar:

def login(user, senha_digitada: str) -> bool:
    try:
        ph.verify(user.password_hash, senha_digitada)
    except VerifyMismatchError:
        return False
    if ph.check_needs_rehash(user.password_hash):
        user.password_hash = ph.hash(senha_digitada)
        user.save()
    return True

O mesmo vale para sair de um legado em bcrypt ou, pior, MD5/SHA cru: detecte o formato pelo prefixo ($2b$, $argon2id$), verifique com o algoritmo antigo e regrave em Argon2id. Em poucas semanas a maioria dos usuários ativos está migrada. Para os hashes crus de quem não volta, dá para embrulhar o hash antigo dentro do novo (argon2id(md5_antigo)) e tirar o MD5 exposto do banco hoje, sem esperar login nenhum.

Senha armazenada direito também não salva senha fraca. Sobre o que torna uma senha difícil de adivinhar do lado do usuário, vale ler o que faz uma senha forte.

Não confunda com criptografia reversível

Cifra simétrica como AES é reversível por design: você criptografa para depois descriptografar com a chave. Isso serve para dado que você precisa recuperar, como número de cartão, mensagem ou arquivo. Senha não é assim. Você nunca precisa da senha original; só precisa confirmar que quem está logando sabe a mesma. Por isso hash é de mão única de propósito. O panorama de cifras e chaves está em criptografia simétrica vs assimétrica. A regra fica: senha se faz hash, dado recuperável se criptografa.

Perguntas frequentes

bcrypt ainda é seguro em 2026?

Sim, com custo 12 ou mais e atenção ao limite de 72 bytes. Ele não é memory-hard, então é mais barato de atacar em GPU que o Argon2id, e a OWASP já o classifica como opção para sistemas legados. Se está bem implantado, não há urgência em migrar; em projeto novo, prefira Argon2id.

Preciso guardar o salt em uma coluna separada?

Com bcrypt e com as bibliotecas de Argon2id, não: salt e parâmetros vão embutidos na string de saída, e uma coluna de texto basta. Com hashlib.scrypt ou pbkdf2_hmac crus, sim: eles devolvem só os bytes, e você precisa guardar salt, parâmetros e hash num formato seu.

Devo usar pepper sempre?

Não é obrigatório, mas é barato se feito com HMAC e com o segredo fora do banco. Ele só ajuda no cenário em que o banco vaza e o servidor de aplicação não. Nunca concatene o pepper à senha antes do bcrypt, e não invente outro esquema de "embaralhar" a senha além disso.

Quanto tempo um hash de senha deve levar?

Não existe número oficial; a OWASP manda medir no seu hardware. Uma faixa razoável é de 100 a 500 ms por hash no servidor de produção, sob carga real. Lembre que memória por login multiplica pelo número de logins simultâneos, então teste com pico de tráfego, não com uma requisição isolada.

Argon2id com parâmetros medidos, e pepper só com HMAC

Senha nunca em texto e nunca em hash rápido. Em projeto novo, Argon2id com pelo menos m=19 MiB, t=2, p=1, medido no seu servidor; bcrypt com custo 12+ onde ele já estiver; PBKDF2 com 600 mil iterações só se FIPS exigir. Se usar pepper, faça HMAC com o segredo fora do banco antes do hash, nunca concatenação. Regrave o hash no login quando subir os parâmetros, e não escreva seu próprio esquema: as bibliotecas maduras já resolveram a parte difícil.

Para calibrar o custo do bcrypt antes de mexer em produção, eu uso o gerador de bcrypt: ele gera e confere hashes com custo ajustável no navegador, então dá para ver quanto cada incremento pesa. E se o que você precisa é o checksum de um arquivo, não de uma senha, o caso é o oposto: aí o gerador de hash com SHA-256 é a ferramenta certa, justamente porque é rápido.

RD
Autor
Rafael Duarte
Desenvolvedor backend com passagem por fintech e SaaS B2B — trabalhou em times que escalaram APIs de zero a milhões de requisições. Carrega cicatrizes de produção suficientes para ter opiniões fortes sobre ferramentas, padrões e decisões de arquitetura. Não é acadêmico: leu a RFC do UUID quando precisou escolher entre v4 e v7 para uma tabela de alta escrita.
Ver perfil