Autenticación con TypeScript: Patrones de seguridad de tipos JWT para aplicaciones globales

En el mundo interconectado de hoy, construir aplicaciones globales seguras y fiables es primordial. La autenticación, el proceso de verificar la identidad de un usuario, juega un papel fundamental en la protección de datos confidenciales y la garantía de acceso autorizado. Los JSON Web Tokens (JWTs) se han convertido en una opción popular para implementar la autenticación debido a su simplicidad y portabilidad. Cuando se combinan con el potente sistema de tipos de TypeScript, la autenticación JWT puede ser aún más robusta y mantenible, particularmente para proyectos internacionales a gran escala.

¿Por qué usar TypeScript para la autenticación JWT?

TypeScript aporta varias ventajas a la mesa al construir sistemas de autenticación:

• Seguridad de tipos: El tipado estático de TypeScript ayuda a detectar errores al principio del proceso de desarrollo, reduciendo el riesgo de sorpresas en tiempo de ejecución. Esto es crucial para componentes sensibles a la seguridad como la autenticación.
• Mantenibilidad del código mejorada: Los tipos proporcionan contratos y documentación claros, lo que facilita la comprensión, modificación y refactorización del código, especialmente en aplicaciones globales complejas donde pueden participar varios desarrolladores.
• Finalización de código y herramientas mejoradas: Los IDE compatibles con TypeScript ofrecen una mejor finalización de código, navegación y herramientas de refactorización, lo que aumenta la productividad del desarrollador.
• Reducción de código repetitivo: Las características como las interfaces y los genéricos pueden ayudar a reducir el código repetitivo y mejorar la reutilización del código.

Entendiendo los JWTs

Un JWT es un medio compacto y seguro para URL de representar reclamaciones que se transferirán entre dos partes. Consta de tres partes:

1. Encabezado: Especifica el algoritmo y el tipo de token.
2. Carga útil: Contiene reclamaciones, como el ID de usuario, los roles y el tiempo de expiración.
3. Firma: Asegura la integridad del token utilizando una clave secreta.

Los JWTs se utilizan normalmente para la autenticación porque se pueden verificar fácilmente en el lado del servidor sin necesidad de consultar una base de datos para cada solicitud. Sin embargo, generalmente se desaconseja almacenar información confidencial directamente en la carga útil del JWT.

Implementación de la autenticación JWT con seguridad de tipos en TypeScript

Exploremos algunos patrones para construir sistemas de autenticación JWT con seguridad de tipos en TypeScript.

1. Definición de tipos de carga útil con interfaces

Comience definiendo una interfaz que represente la estructura de su carga útil JWT. Esto asegura que tenga seguridad de tipos al acceder a las reclamaciones dentro del token.

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  iat: number; // Issued At (timestamp)
  exp: number; // Expiration Time (timestamp)
}

Esta interfaz define la forma esperada de la carga útil JWT. Hemos incluido reclamaciones JWT estándar como `iat` (emitido en) y `exp` (tiempo de expiración) que son cruciales para gestionar la validez del token. Puede agregar cualquier otra reclamación relevante para su aplicación, como roles o permisos de usuario. Es una buena práctica limitar las reclamaciones solo a la información necesaria para minimizar el tamaño del token y mejorar la seguridad.

Ejemplo: Manejo de roles de usuario en una plataforma de comercio electrónico global

Considere una plataforma de comercio electrónico que atiende a clientes en todo el mundo. Diferentes usuarios tienen diferentes roles:

• Administrador: Acceso completo para gestionar productos, usuarios y pedidos.
• Vendedor: Puede agregar y gestionar sus propios productos.
• Cliente: Puede navegar y comprar productos.

La matriz `roles` en `JwtPayload` se puede utilizar para representar estos roles. Podría expandir la propiedad `roles` a una estructura más compleja, representando los derechos de acceso del usuario de forma granular. Por ejemplo, podría tener una lista de países en los que el usuario puede operar como vendedor, o una matriz de tiendas a las que el usuario tiene acceso de administrador.

2. Creación de un servicio JWT tipado

Cree un servicio que gestione la creación y verificación de JWT. Este servicio debe usar la interfaz `JwtPayload` para garantizar la seguridad de los tipos.

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key'; // ¡Almacenar de forma segura!

class JwtService {
  static sign(payload: Omit, expiresIn: string = '1h'): string {
    const now = Math.floor(Date.now() / 1000);
    const payloadWithTimestamps: JwtPayload = {
        ...payload,
        iat: now,
        exp: now + parseInt(expiresIn) * 60 * 60,
    };
    return jwt.sign(payloadWithTimestamps, JWT_SECRET);
  }

  static verify(token: string): JwtPayload | null {
    try {
      const decoded = jwt.verify(token, JWT_SECRET) as JwtPayload;
      return decoded;
    } catch (error) {
      console.error('JWT verification error:', error);
      return null;
    }
  }
}

Este servicio proporciona dos métodos:

• `sign()`: Crea un JWT a partir de una carga útil. Toma un `Omit` para asegurar que el `iat` y `exp` son generados automáticamente. Es importante almacenar `JWT_SECRET` de forma segura, idealmente usando variables de entorno y una solución de gestión de secretos.
• `verify()`: Verifica un JWT y devuelve la carga útil decodificada si es válida, o `null` si no es válida. Usamos una aserción de tipo `as JwtPayload` después de la verificación, que es segura porque el método `jwt.verify` lanza un error (capturado en el bloque `catch`) o devuelve un objeto que coincide con la estructura de carga útil que definimos.

Consideraciones de seguridad importantes:

• Gestión de claves secretas: Nunca codifique su clave secreta JWT en su código. Use variables de entorno o un servicio de administración de secretos dedicado. Rote las claves regularmente.
• Selección del algoritmo: Elija un algoritmo de firma fuerte, como HS256 o RS256. Evite algoritmos débiles como `none`.
• Expiración del token: Establezca tiempos de expiración apropiados para sus JWTs para limitar el impacto de los tokens comprometidos.
• Almacenamiento de tokens: Almacene los JWTs de forma segura en el lado del cliente. Las opciones incluyen cookies HTTP-only o almacenamiento local con las precauciones adecuadas contra los ataques XSS.

3. Protección de puntos finales de API con middleware

Cree un middleware para proteger sus puntos finales de API verificando el JWT en el encabezado `Authorization`.

import { Request, Response, NextFunction } from 'express';

interface RequestWithUser extends Request {
  user?: JwtPayload;
}

function authenticate(req: RequestWithUser, res: Response, next: NextFunction) {
  const authHeader = req.headers.authorization;

  if (!authHeader) {
    return res.status(401).json({ message: 'Unauthorized' });
  }

  const token = authHeader.split(' ')[1]; // Asumiendo token Bearer
  const decoded = JwtService.verify(token);

  if (!decoded) {
    return res.status(401).json({ message: 'Invalid token' });
  }

  req.user = decoded;
  next();
}

export default authenticate;

Este middleware extrae el JWT del encabezado `Authorization`, lo verifica usando el `JwtService` y adjunta la carga útil decodificada al objeto `req.user`. También definimos una interfaz `RequestWithUser` para extender la interfaz `Request` estándar de Express.js, agregando una propiedad `user` de tipo `JwtPayload | undefined`. Esto proporciona seguridad de tipos al acceder a la información del usuario en rutas protegidas.

Ejemplo: Manejo de zonas horarias en una aplicación global

Imagine que su aplicación permite a los usuarios de diferentes zonas horarias programar eventos. Es posible que desee almacenar la zona horaria preferida del usuario en la carga útil del JWT para mostrar correctamente las horas del evento. Podría agregar una reclamación `timeZone` a la interfaz `JwtPayload`:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  timeZone: string; // e.g., 'America/Los_Angeles', 'Asia/Tokyo'
  iat: number;
  exp: number;
}

Luego, en su middleware o controladores de ruta, puede acceder a `req.user.timeZone` para formatear fechas y horas de acuerdo con la preferencia del usuario.

4. Uso del usuario autenticado en los controladores de ruta

En sus controladores de ruta protegidos, ahora puede acceder a la información del usuario autenticado a través del objeto `req.user`, con total seguridad de tipos.

import express, { Request, Response } from 'express';
import authenticate from './middleware/authenticate';

const app = express();

app.get('/profile', authenticate, (req: Request, res: Response) => {
  const user = (req as any).user; // or use RequestWithUser
  res.json({ message: `Hello, ${user.email}!`, userId: user.userId });
});

Este ejemplo demuestra cómo acceder al correo electrónico y al ID del usuario autenticado desde el objeto `req.user`. Debido a que definimos la interfaz `JwtPayload`, TypeScript conoce la estructura esperada del objeto `user` y puede proporcionar verificación de tipos y finalización de código.

5. Implementación del control de acceso basado en roles (RBAC)

Para un control de acceso más granular, puede implementar RBAC basado en los roles almacenados en la carga útil del JWT.

function authorize(roles: string[]) {
  return (req: RequestWithUser, res: Response, next: NextFunction) => {
    const user = req.user;

    if (!user || !user.roles.some(role => roles.includes(role))) {
      return res.status(403).json({ message: 'Forbidden' });
    }

    next();
  };
}

Este middleware `authorize` comprueba si los roles del usuario incluyen alguno de los roles requeridos. Si no, devuelve un error 403 Forbidden.

app.get('/admin', authenticate, authorize(['admin']), (req: Request, res: Response) => {
  res.json({ message: 'Welcome, Admin!' });
});

Este ejemplo protege la ruta `/admin`, requiriendo que el usuario tenga el rol `admin`.

Ejemplo: Manejo de diferentes monedas en una aplicación global

Si su aplicación maneja transacciones financieras, es posible que necesite admitir varias monedas. Podría almacenar la moneda preferida del usuario en la carga útil del JWT:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  currency: string; // e.g., 'USD', 'EUR', 'JPY'
  iat: number;
  exp: number;
}

Luego, en su lógica de backend, puede usar `req.user.currency` para formatear precios y realizar conversiones de moneda según sea necesario.

6. Refresh Tokens

Los JWTs son de corta duración por diseño. Para evitar requerir que los usuarios inicien sesión con frecuencia, implemente refresh tokens. Un refresh token es un token de larga duración que se puede usar para obtener un nuevo token de acceso (JWT) sin requerir que el usuario vuelva a ingresar sus credenciales. Almacene los refresh tokens de forma segura en una base de datos y asócielos con el usuario. Cuando el token de acceso de un usuario expira, puede usar el refresh token para solicitar uno nuevo. Este proceso debe implementarse cuidadosamente para evitar vulnerabilidades de seguridad.

Técnicas avanzadas de seguridad de tipos

1. Uniones discriminadas para un control más preciso

A veces, es posible que necesite diferentes cargas útiles de JWT según el rol del usuario o el tipo de solicitud. Las uniones discriminadas pueden ayudarlo a lograr esto con seguridad de tipos.

interface AdminJwtPayload {
  type: 'admin';
  userId: string;
  email: string;
  roles: string[];
  iat: number;
  exp: number;
}

interface UserJwtPayload {
  type: 'user';
  userId: string;
  email: string;
  iat: number;
  exp: number;
}

type JwtPayload = AdminJwtPayload | UserJwtPayload;

function processToken(payload: JwtPayload) {
  if (payload.type === 'admin') {
    console.log('Admin email:', payload.email); // Seguro para acceder al correo electrónico
  } else {
    // payload.email no es accesible aquí porque el tipo es 'user'
    console.log('User ID:', payload.userId);
  }
}

Este ejemplo define dos tipos de carga útil de JWT diferentes, `AdminJwtPayload` y `UserJwtPayload`, y los combina en una unión discriminada `JwtPayload`. La propiedad `type` actúa como un discriminador, lo que le permite acceder de forma segura a las propiedades según el tipo de carga útil.

2. Genéricos para lógica de autenticación reutilizable

Si tiene varios esquemas de autenticación con diferentes estructuras de carga útil, puede usar genéricos para crear lógica de autenticación reutilizable.

interface BaseJwtPayload {
  userId: string;
  iat: number;
  exp: number;
}

function verifyToken(token: string): T | null {
  try {
    const decoded = jwt.verify(token, JWT_SECRET) as T;
    return decoded;
  } catch (error) {
    console.error('JWT verification error:', error);
    return null;
  }
}

const adminToken = verifyToken('admin-token');
if (adminToken) {
  console.log('Admin email:', adminToken.email);
}

Este ejemplo define una función `verifyToken` que toma un tipo genérico `T` que extiende `BaseJwtPayload`. Esto le permite verificar tokens con diferentes estructuras de carga útil al tiempo que garantiza que todos tengan al menos las propiedades `userId`, `iat` y `exp`.

Consideraciones para aplicaciones globales

Al construir sistemas de autenticación para aplicaciones globales, considere lo siguiente:

• Localización: Asegúrese de que los mensajes de error y los elementos de la interfaz de usuario estén localizados para diferentes idiomas y regiones.
• Zonas horarias: Maneje las zonas horarias correctamente al configurar los tiempos de expiración de los tokens y mostrar fechas y horas a los usuarios.
• Privacidad de datos: Cumpla con las regulaciones de privacidad de datos como GDPR y CCPA. Minimice la cantidad de datos personales almacenados en los JWTs.
• Accesibilidad: Diseñe sus flujos de autenticación para que sean accesibles para usuarios con discapacidades.
• Sensibilidad cultural: Tenga en cuenta las diferencias culturales al diseñar interfaces de usuario y flujos de autenticación.

Conclusión

Al aprovechar el sistema de tipos de TypeScript, puede construir sistemas de autenticación JWT robustos y mantenibles para aplicaciones globales. Definir tipos de carga útil con interfaces, crear servicios JWT tipados, proteger puntos finales de API con middleware e implementar RBAC son pasos esenciales para garantizar la seguridad y la seguridad de los tipos. Al considerar las consideraciones de la aplicación global, como la localización, las zonas horarias, la privacidad de los datos, la accesibilidad y la sensibilidad cultural, puede crear experiencias de autenticación inclusivas y fáciles de usar para una audiencia internacional diversa. Recuerde siempre priorizar las mejores prácticas de seguridad al manejar JWTs, incluida la gestión segura de claves, la selección de algoritmos, la expiración de tokens y el almacenamiento de tokens. Adopte el poder de TypeScript para construir sistemas de autenticación seguros, escalables y confiables para sus aplicaciones globales.