Introducción

El middleware de autenticación se sitúa entre las solicitudes entrantes y tus route handlers, verificando que los usuarios sean quienes dicen ser antes de conceder acceso a recursos protegidos. En esta lección, construirás middleware de autenticación basado en JWT y lo aplicarás a rutas específicas, transformando tu API abierta en un sistema seguro y listo para producción.

Las funciones middleware tienen acceso al objeto de solicitud, al objeto de respuesta y a la siguiente función middleware en la pila. El middleware de autenticación inspecciona el header Authorization, valida el token, adjunta la información del usuario a la solicitud, y o bien transfiere el control al siguiente handler o rechaza la solicitud.

Construyendo el Middleware de Autenticación

Crea una función middleware que extraiga y verifique tokens JWT. El middleware busca un token Bearer en el header Authorization, lo valida usando tu clave secreta y adjunta el payload decodificado al objeto de solicitud para que lo usen los handlers posteriores.

const jwt = require('jsonwebtoken');

const authenticate = (req, res, next) => {
  const authHeader = req.headers.authorization;
  
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'No token provided' });
  }
  
  const token = authHeader.substring(7);
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    return res.status(401).json({ error: 'Invalid or expired token' });
  }
};

module.exports = authenticate;

El middleware extrae el token eliminando el prefijo Bearer, lo verifica con tu secreto y almacena los datos decodificados del usuario en req.user. Si la verificación falla, devuelve un estado 401 sin llamar a next, deteniendo el pipeline de la solicitud.

Protección de Rutas con Middleware

Aplica el middleware de autenticación a las rutas que requieren identidad del usuario. Puedes proteger rutas individuales, grupos de rutas o routers completos insertando el middleware antes de tus funciones handler.

const express = require('express');
const authenticate = require('./middleware/authenticate');
const router = express.Router();

router.get('/profile', authenticate, (req, res) => {
  res.json({
    userId: req.user.id,
    email: req.user.email,
    message: 'This is your protected profile'
  });
});

router.post('/posts', authenticate, async (req, res) => {
  const post = await createPost({
    ...req.body,
    authorId: req.user.id
  });
  res.status(201).json(post);
});

router.get('/public', (req, res) => {
  res.json({ message: 'This endpoint is public' });
});

El middleware authenticate se ejecuta antes del route handler. Las rutas sin el middleware permanecen accesibles públicamente. El objeto req.user, rellenado por el middleware, da a los handlers acceso a la identidad del usuario autenticado.

Control de Acceso Basado en Roles

Extiende tu middleware para manejar la autorización comprobando los roles o permisos del usuario. Crea una función envoltorio que acepte los roles requeridos y devuelva un middleware que aplique esos requisitos.

const authorize = (...allowedRoles) => {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({ error: 'Authentication required' });
    }
    
    if (!allowedRoles.includes(req.user.role)) {
      return res.status(403).json({ error: 'Insufficient permissions' });
    }
    
    next();
  };
};

router.delete('/users/:id', authenticate, authorize('admin'), async (req, res) => {
  await deleteUser(req.params.id);
  res.status(204).send();
});

router.put('/posts/:id', authenticate, authorize('admin', 'editor'), async (req, res) => {
  const post = await updatePost(req.params.id, req.body);
  res.json(post);
});

El middleware authorize asume que authenticate ya se ha ejecutado y ha adjuntado req.user. Comprueba el rol del usuario frente a los valores permitidos y devuelve 403 Forbidden si el rol no coincide. Encadena múltiples funciones middleware para aplicar tanto la autenticación como la autorización.

Manejo de Errores y Refresh de Tokens

Maneja con elegancia los escenarios comunes de autenticación. Distingue entre tokens ausentes, tokens inválidos y tokens expirados para ofrecer feedback claro. Considera implementar refresh tokens para sesiones de larga duración.

const authenticate = (req, res, next) => {
  const authHeader = req.headers.authorization;
  
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ 
      error: 'No token provided',
      code: 'TOKEN_MISSING'
    });
  }
  
  const token = authHeader.substring(7);
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({ 
        error: 'Token expired',
        code: 'TOKEN_EXPIRED'
      });
    }
    return res.status(401).json({ 
      error: 'Invalid token',
      code: 'TOKEN_INVALID'
    });
  }
};

Las respuestas de error estructuradas con códigos de error ayudan a los clientes a manejar adecuadamente los diferentes modos de fallo. Los tokens expirados pueden activar un flujo de refresh de token, mientras que los tokens inválidos requieren una nueva autenticación.

Resumen

El middleware de autenticación centraliza la lógica de seguridad y la aplica de forma consistente en toda tu API. Al extraer y verificar tokens JWT, adjuntar la información del usuario a las solicitudes y aplicar control de acceso basado en roles, transformas endpoints abiertos en un sistema seguro. Ejecuta siempre la autenticación antes de la autorización, devuelve respuestas de error claras y considera estrategias de expiración y refresh de tokens para despliegues en producción.