Como guardar senhas: por que não usar SHA-256 e o que usar

Por que não SHA-256

O SHA-256 foi feito para ser rápido, e é isso que o torna ruim para senhas. Se o banco vazar, quem tem os hashes testa bilhões de senhas por segundo em uma placa de vídeo, e as senhas comuns caem em minutos. Sem sal, pior ainda: senhas iguais geram hashes iguais, e tabelas prontas revelam as mais usadas.

Um hash de senha é lento de propósito (e o scrypt e o Argon2 também gastam memória), para que cada tentativa custe caro. E usa um sal aleatório por senha, para que duas senhas iguais gerem resultados diferentes.

Qual algoritmo usar

• Argon2id: a primeira escolha da OWASP, quando a linguagem oferece.
• scrypt: boa alternativa, e vem pronto no Node.js e no Python, sem instalar nada. Custo sugerido: N = 2^17, r = 8, p = 1.
• bcrypt: seguro e muito difundido, mas só considera os primeiros 72 bytes da senha. É o padrão do password_hash do PHP.
• PBKDF2: use quando uma norma exigir (como a FIPS-140), com muitas iterações.

Em Node.js, com scrypt

O resultado guarda o sal e o hash juntos. Na conferência, timingSafeEqual compara em tempo constante, para que a demora da comparação não revele quantos bytes batem.

import { randomBytes, scryptSync, timingSafeEqual } from 'node:crypto';

// Custo recomendado pela OWASP para o scrypt: N = 2^17, r = 8, p = 1 (usa 128 MiB)
const CUSTO = { N: 2 ** 17, r: 8, p: 1, maxmem: 256 * 1024 * 1024 };

function hashSenha(senha) {
  const sal = randomBytes(16); // um sal novo para cada senha
  const hash = scryptSync(senha, sal, 64, CUSTO);
  return `${sal.toString('hex')}:${hash.toString('hex')}`;
}

function conferirSenha(senha, guardado) {
  const [sal, hash] = guardado.split(':').map((h) => Buffer.from(h, 'hex'));
  return timingSafeEqual(scryptSync(senha, sal, 64, CUSTO), hash);
}

Em Python, com scrypt

Com o mesmo custo e o mesmo formato, um sistema em Python confere as senhas gravadas pelo Node.js, e o contrário também.

import hashlib
import hmac
import os

# O mesmo custo do exemplo em Node.js: os dois leem as senhas um do outro
CUSTO = {"n": 2**17, "r": 8, "p": 1, "maxmem": 256 * 1024 * 1024, "dklen": 64}


def hash_senha(senha: str) -> str:
    sal = os.urandom(16)
    h = hashlib.scrypt(senha.encode("utf-8"), salt=sal, **CUSTO)
    return f"{sal.hex()}:{h.hex()}"


def conferir_senha(senha: str, guardado: str) -> bool:
    sal, esperado = (bytes.fromhex(x) for x in guardado.split(":"))
    h = hashlib.scrypt(senha.encode("utf-8"), salt=sal, **CUSTO)
    return hmac.compare_digest(h, esperado)

Em PHP, com password_hash

O PHP já traz tudo pronto: password_hash gera o sal e grava o algoritmo e o custo no próprio resultado, e password_verify lê essas informações na conferência. Use password_needs_rehash no login para atualizar hashes antigos quando o custo padrão subir.

<?php
function hashSenha(string $senha): string
{
    // O resultado já inclui o algoritmo, o custo e o sal
    return password_hash($senha, PASSWORD_DEFAULT);
}

function conferirSenha(string $senha, string $guardado): bool
{
    return password_verify($senha, $guardado);
}

Cuidados

• Guarde os parâmetros de custo junto com o hash (o password_hash já faz isso). Assim dá para aumentar o custo no futuro sem invalidar as senhas antigas.
• Nunca compare hashes com == ou ===: use a comparação em tempo constante da linguagem.
• Limite o tamanho da senha aceita (por exemplo, 128 caracteres) para evitar que senhas enormes sejam usadas para sobrecarregar o servidor.
• Para gerar senhas temporárias e tokens, use um gerador seguro. Veja como gerar senha segura em código ou o gerador de senha.