SHA-256 vs bcrypt vs Argon2: Quando Usar Cada Um?

"Se eu fazer hash das senhas com SHA-256 e armazena-las, deve ser seguro, certo?"

Muitos desenvolvedores fazem essa pergunta. A conclusao e: voce nao deve usar SHA-256 para senhas.

Este guia explica as diferencas entre algoritmos de hashing e a escolha correta para cada situacao.

---

Hashing vs Criptografia: Conceitos Basicos

Hashing

Entrada → Funcao Hash → Saida de comprimento fixo (irreversivel)

"password" → SHA-256 → "5e884898da28047d..."

• Unidirecional: Nao pode recuperar o original
• Deterministico: Mesma entrada = Mesma saida
• Comprimento fixo: Tamanho de saida independente do tamanho de entrada

Criptografia

Entrada + Chave → Criptografia → Texto cifrado → Descriptografia + Chave → Original

"password" + key → AES → "Xyz..." → AES + key → "password"

• Bidirecional: Original recuperavel com chave
• Dependente de chave: Nao pode descriptografar sem chave

Use hashing para armazenamento de senhas. Voce nao precisa do original — apenas compare o valor de entrada com o hash.

---

Classificacao de Algoritmos de Hashing

Hash Rapido

Hash Lento (Hash de Senhas)

---

Por Que Voce Nao Deve Armazenar Senhas com SHA-256?

Razao 1: Muito Rapido

SHA-256 e projetado para velocidade. Isso e uma vantagem para verificacao de integridade de arquivos, mas uma falha fatal para armazenamento de senhas.

Desempenho de GPU moderna:
- MD5: 180 bilhoes de hashes/seg
- SHA-256: 10 bilhoes de hashes/seg
- bcrypt (cost 12): 1.000 hashes/seg

Mesmo uma senha complexa de 8 caracteres pode ser quebrada em minutos quando armazenada com SHA-256.

Razao 2: Gerenciamento Manual de Salt Necessario

# ❌ Abordagem errada
hash = sha256(password)

# Problema: Vulneravel a ataques de Rainbow Table

# ⚠️ Melhorado mas ainda insuficiente
salt = generate_random_salt()
hash = sha256(salt + password)

# Problema: Ainda muito rapido

Razao 3: Vulnerabilidade a Aceleracao de GPU

SHA-256 e facilmente paralelizado em GPUs. Atacantes podem calcular hashes em velocidades tremendas com apenas algumas GPUs de gaming.

---

bcrypt: 27 Anos de Padrao Comprovado

Como Funciona

bcrypt(cost, salt, password) → hash

cost: Numero de iteracoes de calculo (2^cost)
salt: String aleatoria de 22 caracteres (autogerada)

Por Que bcrypt e Seguro?

1. Intencionalmente lento: Velocidade controlada pelo cost factor
2. Salt automatico: Hash diferente toda vez
3. Intensivo em memoria: Dificil de acelerar com GPU

Guia de Cost Factor (2026)

Exemplos de Codigo

// Node.js with bcrypt
const bcrypt = require('bcrypt');

// Hashing (cadastro)
const hash = await bcrypt.hash(password, 12); // cost 12

// Verificacao (login)
const isValid = await bcrypt.compare(inputPassword, storedHash);

# Python with bcrypt
import bcrypt

# Hashing
hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))

# Verificacao
is_valid = bcrypt.checkpw(input_password.encode(), stored_hash)

---

Argon2: O Padrao de Nova Geracao

O Que e Argon2?

Vencedor da Password Hashing Competition de 2015. E o algoritmo #1 recomendado pelo OWASP para 2026.

Variantes do Argon2

Parametros do Argon2

Argon2id(memory, iterations, parallelism, password, salt)

- memory: Uso de memoria (KB)
- iterations: Numero de iteracoes
- parallelism: Numero de threads paralelas

Configuracao Recomendada OWASP (2026)

Configuracao minima:
- memory: 64MB (65536 KB)
- iterations: 3
- parallelism: 4

Alta seguranca:
- memory: 256MB
- iterations: 4
- parallelism: 8

Exemplos de Codigo

// Node.js with argon2
const argon2 = require('argon2');

// Hashing
const hash = await argon2.hash(password, {
  type: argon2.argon2id,
  memoryCost: 65536, // 64MB
  timeCost: 3,
  parallelism: 4
});

// Verificacao
const isValid = await argon2.verify(storedHash, inputPassword);

# Python with argon2-cffi
from argon2 import PasswordHasher

ph = PasswordHasher(
    memory_cost=65536,
    time_cost=3,
    parallelism=4
)

# Hashing
hash = ph.hash(password)

# Verificacao
try:
    ph.verify(stored_hash, input_password)
except VerifyMismatchError:
    # Senha nao corresponde

---

bcrypt vs Argon2: Qual Escolher?

Tabela de Comparacao

Guia de Selecao

Escolher bcrypt:

• Precisa de compatibilidade com sistemas legados
• Prefere estabilidade comprovada
• Prefere configuracao simples

Escolher Argon2id:

• Comecando novo projeto
• Seguindo ultimos padroes de seguranca
• Precisa de alta resistencia a GPU

Ordem de Recomendacao 2026 (OWASP)

#1: Argon2id
#2: bcrypt
#3: scrypt
#4: PBKDF2 (quando compatibilidade e necessaria)

---

Quando Usar SHA-256

SHA-256 e perfeito para propositos diferentes de senhas.

Casos de Uso Adequados

Exemplo de Codigo

// Hash de arquivo (Node.js)
const crypto = require('crypto');
const fs = require('fs');

const fileBuffer = fs.readFileSync('file.zip');
const hash = crypto.createHash('sha256').update(fileBuffer).digest('hex');

console.log(hash); // "a1b2c3d4..."

---

Lista de Verificacao de Implementacao Pratica

Armazenamento de Senhas

• Usar Argon2id ou bcrypt
• Definir work factor apropriado (250-500ms)
• Usar geracao automatica de salt da biblioteca
• Armazenar resultado completo do hash (incluindo salt)

Verificacao de Senhas

• Usar funcoes de comparacao seguras contra timing attacks
• Tempo de resposta consistente em falha de verificacao
• Limitar tentativas de login falhas

Migracao

• Atualizacao gradual para novo hash
• Re-hash com novo algoritmo em login bem-sucedido
• Usar prefixo para identificar hashes antigos

---

Perguntas Frequentes

P1: Como lido com senhas existentes armazenadas com MD5?

R: Re-hash com o novo algoritmo quando os usuarios fizerem login.

// Em login bem-sucedido
if (hash.startsWith('$md5$')) {
  // Re-hash com bcrypt
  const newHash = await bcrypt.hash(inputPassword, 12);
  await updateUserHash(userId, newHash);
}

P2: O limite de 72 bytes do bcrypt nao e um problema?

R: A maioria das senhas esta dentro de 72 bytes. Para entradas mais longas, primeiro faca hash com SHA-256, depois aplique bcrypt.

// Lidando com senhas longas
const prehash = crypto.createHash('sha256').update(password).digest('base64');
const finalHash = await bcrypt.hash(prehash, 12);

P3: Um cost factor alto nao te torna vulneravel a ataques DoS?

R: Sim. Implemente rate limiting em requisicoes de login. 250-500ms e o equilibrio apropriado.

P4: Pepper e necessario?

R: Pepper (chave secreta em nivel de aplicacao) fornece seguranca adicional mas nao e obrigatorio. Apenas salt e suficiente.

P5: Posso usar ferramentas de hash online?

R: Use apenas para propositos de aprendizado/teste. Em producao, o hashing deve ser feito no lado do servidor. O Gerador de Hash e seguro pois processa 100% no lado do cliente.

---

Conclusao

Principios Chave:

1. Nunca usar hashes rapidos (SHA-256, MD5) para senhas
2. bcrypt cost 12+, Argon2 memory 64MB+
3. Usar geracao automatica de salt fornecida pela biblioteca

---

Ferramentas Relacionadas