JSON Web Tokens (JWT): Autenticación y Autorización Completa

Opciones Avanzadas

const token = jwt.sign(
  { userId: usuario.id },
  SECRET_KEY,
  {
    algorithm: 'HS256',
    expiresIn: '1h',        // 1 hora
    issuer: 'mi-app',
    audience: 'api.mi-app.com',
    subject: usuario.id.toString(),
    notBefore: '0',         // Válido inmediatamente
    jwtid: generarUUID()    // ID único del token
  }
);

Verificar Token

function verificarToken(token) {
  try {
    const decoded = jwt.verify(token, SECRET_KEY);
    return {
      valido: true,
      datos: decoded
    };
  } catch (error) {
    if (error.name === 'TokenExpiredError') {
      return { valido: false, error: 'Token expirado' };
    } else if (error.name === 'JsonWebTokenError') {
      return { valido: false, error: 'Token inválido' };
    } else {
      return { valido: false, error: 'Error de verificación' };
    }
  }
}

// Uso
const resultado = verificarToken(token);
if (resultado.valido) {
  console.log('Usuario:', resultado.datos);
} else {
  console.error('Error:', resultado.error);
}

Decodificar Sin Verificar

// Solo para inspeccionar, NO para validar
const decoded = jwt.decode(token, { complete: true });

console.log('Header:', decoded.header);
console.log('Payload:', decoded.payload);
console.log('Signature:', decoded.signature);

Middleware de Autenticación (Express)

Middleware Básico

const jwt = require('jsonwebtoken');

function autenticar(req, res, next) {
  // Obtener token del header
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // "Bearer TOKEN"

  if (!token) {
    return res.status(401).json({ error: 'Token no proporcionado' });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.usuario = decoded; // Agregar datos a request
    next();
  } catch (error) {
    return res.status(403).json({ error: 'Token inválido' });
  }
}

// Uso en rutas
app.get('/api/perfil', autenticar, (req, res) => {
  // req.usuario contiene los datos del token
  res.json({
    mensaje: 'Perfil del usuario',
    usuario: req.usuario
  });
});

Middleware con Roles

function requiereRol(...rolesPermitidos) {
  return (req, res, next) => {
    if (!req.usuario) {
      return res.status(401).json({ error: 'No autenticado' });
    }

    if (!rolesPermitidos.includes(req.usuario.role)) {
      return res.status(403).json({ 
        error: 'No tienes permisos para esta acción' 
      });
    }

    next();
  };
}

// Uso
app.delete('/api/usuarios/:id', 
  autenticar,
  requiereRol('admin', 'superadmin'),
  (req, res) => {
    // Solo admin o superadmin pueden ejecutar esto
    eliminarUsuario(req.params.id);
    res.json({ mensaje: 'Usuario eliminado' });
  }
);

Sistema Completo de Autenticación

const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

const app = express();
app.use(express.json());

const SECRET_KEY = process.env.JWT_SECRET;

// Base de datos simulada
const usuarios = [];

// Registro
app.post('/api/registro', async (req, res) => {
  try {
    const { email, password, nombre } = req.body;

    // Validar
    if (!email || !password || !nombre) {
      return res.status(400).json({ error: 'Datos incompletos' });
    }

    // Verificar si existe
    if (usuarios.find(u => u.email === email)) {
      return res.status(400).json({ error: 'Email ya registrado' });
    }

    // Hash password
    const passwordHash = await bcrypt.hash(password, 10);

    // Crear usuario
    const nuevoUsuario = {
      id: usuarios.length + 1,
      email,
      nombre,
      passwordHash,
      role: 'usuario',
      createdAt: new Date()
    };

    usuarios.push(nuevoUsuario);

    // Generar token
    const token = jwt.sign(
      { 
        sub: nuevoUsuario.id,
        email: nuevoUsuario.email,
        role: nuevoUsuario.role
      },
      SECRET_KEY,
      { expiresIn: '7d' }
    );

    res.status(201).json({
      mensaje: 'Usuario creado',
      token,
      usuario: {
        id: nuevoUsuario.id,
        email: nuevoUsuario.email,
        nombre: nuevoUsuario.nombre
      }
    });
  } catch (error) {
    res.status(500).json({ error: 'Error en el servidor' });
  }
});

// Login
app.post('/api/login', async (req, res) => {
  try {
    const { email, password } = req.body;

    // Buscar usuario
    const usuario = usuarios.find(u => u.email === email);
    if (!usuario) {
      return res.status(401).json({ error: 'Credenciales inválidas' });
    }

    // Verificar password
    const passwordValido = await bcrypt.compare(password, usuario.passwordHash);
    if (!passwordValido) {
      return res.status(401).json({ error: 'Credenciales inválidas' });
    }

    // Generar token
    const token = jwt.sign(
      {
        sub: usuario.id,
        email: usuario.email,
        role: usuario.role
      },
      SECRET_KEY,
      { expiresIn: '7d' }
    );

    res.json({
      token,
      usuario: {
        id: usuario.id,
        email: usuario.email,
        nombre: usuario.nombre,
        role: usuario.role
      }
    });
  } catch (error) {
    res.status(500).json({ error: 'Error en el servidor' });
  }
});

// Ruta protegida
app.get('/api/perfil', autenticar, (req, res) => {
  const usuario = usuarios.find(u => u.id === req.usuario.sub);

  res.json({
    id: usuario.id,
    email: usuario.email,
    nombre: usuario.nombre,
    role: usuario.role
  });
});

app.listen(3000, () => console.log('Servidor en puerto 3000'));

Implementación en Python

Instalación

pip install pyjwt cryptography

Generar y Verificar Token

import jwt
import datetime
from typing import Dict, Optional

SECRET_KEY = "tu-clave-secreta-muy-segura"
ALGORITHM = "HS256"

def generar_token(usuario: Dict) -> str:
    """Genera JWT para usuario"""
    payload = {
        'sub': str(usuario['id']),
        'email': usuario['email'],
        'role': usuario['role'],
        'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1),
        'iat': datetime.datetime.utcnow()
    }

    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)

def verificar_token(token: str) -> Optional[Dict]:
    """Verifica y decodifica JWT"""
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        return payload
    except jwt.ExpiredSignatureError:
        print("Token expirado")
        return None
    except jwt.InvalidTokenError:
        print("Token inválido")
        return None

# Uso
usuario = {
    'id': 123,
    'email': 'ana@ejemplo.com',
    'role': 'admin'
}

token = generar_token(usuario)
print(f"Token: {token}")

# Verificar
datos = verificar_token(token)
if datos:
    print(f"Usuario: {datos['email']}")

Flask con JWT

// ✅ Más seguro (no accesible desde JavaScript)
res.cookie('token', token, {
  httpOnly: true,
  secure: true,      // Solo HTTPS
  sameSite: 'strict',
  maxAge: 3600000    // 1 hora
});

Mejor Práctica: Cookie + Header

// Servidor envía en cookie HttpOnly
res.cookie('refreshToken', refreshToken, {
  httpOnly: true,
  secure: true,
  sameSite: 'strict'
});

// Access token en respuesta JSON
res.json({ accessToken });

// Cliente guarda access token en memoria (no localStorage)
// y envía en Authorization header

Mejores Prácticas

1. Implementa Lista Negra para Logout

const listaNegraTokens = new Set();

app.post('/api/logout', autenticar, (req, res) => {
  const token = req.headers.authorization.split(' ')[1];
  listaNegraTokens.add(token);
  res.json({ mensaje: 'Logout exitoso' });
});

// Middleware actualizado
function autenticar(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];

  if (listaNegraTokens.has(token)) {
    return res.status(401).json({ error: 'Token revocado' });
  }

  // ... resto de verificación
}

2. Rate Limiting