7. Hashing Criptográfico de Contraseñas con Bcrypt: Salt Rounds y Prevención de Timing Attacks
Aprende por qué nunca guardar contraseñas en texto plano ni MD5/SHA, cómo calcular los factores de coste de Salt Rounds (12) y comparar hashes de forma segura.
Seguridad Criptográfica de Contraseñas con Bcrypt
Las funciones de hash como MD5, SHA-1 o incluso SHA-256 fueron diseñadas para ser ultrarrápidas al verificar integridad de archivos. Esa misma velocidad las convierte en un desastre para contraseñas, pues una tarjeta gráfica moderna (GPU) puede probar miles de millones de combinaciones por segundo mediante tablas arcoíris (Rainbow Tables). Bcrypt resuelve esto siendo deliberadamente lento y adaptativo.
1. Factores de Coste (Salt Rounds)
En Bcrypt, cada incremento de 1 en el factor de coste duplica el tiempo de cálculo de la función:
- Rounds = 10: ~100 milisegundos por hash. Aceptable pero básico.
- Rounds = 12: ~300 a 400 milisegundos. Estándar recomendado para servidores VPS modernos (balance ideal entre experiencia de usuario y resistencia contra ataques de fuerza bruta).
- Rounds = 14: ~1.5 segundos. Apto para sistemas bancarios o de alta criticidad.
2. Prevención de Timing Attacks
Al verificar si una contraseña ingresada coincide con el hash almacenado, comparar cadenas con el operador === es vulnerable a ataques de temporización (Timing Attacks), donde el atacante mide el tiempo de respuesta en microsegundos para deducir los primeros caracteres correctos. La función bcrypt.compare() utiliza una comparación en tiempo constante (Constant-Time Comparison) inmune a esta técnica.
⚡ Módulo Criptográfico con Bcrypt y Comparación en Tiempo Constante
Hashing asíncrono y verificación segura para servicios de autenticación.
import bcrypt from 'bcrypt';
// Factor de coste recomendado para servidores de producción
const SALT_ROUNDS = 12;
export class PasswordService {
/**
* Genera un hash seguro con Salt único integrado en el string de salida
* Formato resultante: $2b$12$[22 caracteres de salt][31 caracteres de hash]
*/
static async hash(plainPassword) {
if (!plainPassword || typeof plainPassword !== 'string') {
throw new Error('La contraseña debe ser una cadena de texto no vacía.');
}
return await bcrypt.hash(plainPassword, SALT_ROUNDS);
}
/**
* Compara una contraseña en texto plano contra el hash de la base de datos
* Utiliza comparación de tiempo constante para evitar Timing Attacks
*/
static async verify(plainPassword, storedHash) {
if (!plainPassword || !storedHash) return false;
return await bcrypt.compare(plainPassword, storedHash);
}
/**
* Verifica si el hash guardado en BD usa un factor de coste obsoleto
* y necesita ser recalculado (ejemplo: al iniciar sesión con éxito)
*/
static needsRehash(storedHash) {
const rounds = bcrypt.getRounds(storedHash);
return rounds < SALT_ROUNDS;
}
}
// Ejemplo de uso en un controlador de autenticación:
export async function handleLogin(user, inputPassword) {
const isMatch = await PasswordService.verify(inputPassword, user.password_hash);
if (!isMatch) {
// Usar mensaje genérico para no revelar si el error fue el email o la contraseña
const error = new Error('Credenciales inválidas.');
error.statusCode = 401;
throw error;
}
// Si el usuario tenía un hash antiguo (ej. factor 10), re-hashear a 12 de forma transparente
if (PasswordService.needsRehash(user.password_hash)) {
const newHash = await PasswordService.hash(inputPassword);
// await userRepository.updatePassword(user.id, newHash);
}
return true;
}
Mini-Quiz de Retención
Comprueba tu comprensión antes de pasar a la siguiente lección¿Por qué las funciones como SHA-256 o MD5 son consideradas inseguras para almacenar contraseñas, a diferencia de Bcrypt?
¿Tienes dudas con este tema?
Sócrates AI puede darte analogías y explicarte este código paso a paso.🚀 ¿Quieres dominar Express.js: Framework Backend & APIs Empresariales y crear proyectos reales?
Aprende arquitectura limpia, desarrollo web moderno, buenas prácticas y despliegue en producción con nuestro Bootcamp Fullstack Developer con mentorías en vivo.