Introducción a OAuth2 y JWT para microservicios

Vamos a empezar nuestra aventura con una pregunta sencilla:

"¿Qué es OAuth2?"

OAuth2 (Open Authorization 2.0) — es un protocolo de autorización que permite a las aplicaciones obtener acceso limitado a recursos en nombre del usuario sin transmitir las contraseñas directamente. ¿Suena un poco enrevesado? Vamos a desglosarlo con un ejemplo.

Cómo funciona OAuth2: la historia de un cupcake

Imagina la situación. Tienes un casillero personal en una cafetería de moda donde guardas tus cupcakes favoritos. Pero en vez de darle al barista la llave personal (la contraseña), le das una ficha temporal con permisos limitados.

¿Qué puede hacer el barista con esa ficha?

• Abrir exactamente tu casillero ✓
• Sacar solo el cupcake ✓
• Mirar en otros casilleros ✗
• Usar el token mañana ✗

¡Eso es OAuth2 en acción! Tu llave personal (login y contraseña) se queda contigo, y los servicios reciben fichas temporales (tokens) con permisos bien definidos. Nada de accesos innecesarios, nada de riesgo de comprometer tus credenciales.

Como en la vida real no le das las llaves de tu casa a un desconocido, en la aplicación web OAuth2 protege tus datos, entregando solo pases temporales con los permisos mínimos necesarios.

Principios de funcionamiento de OAuth2

Para entender mejor la motivación y la estructura del protocolo, veamos sus principales "flujos".

OAuth2 usa los llamados flujos de autenticación. Estos definen cómo el usuario obtendrá un token de acceso, según el tipo de aplicación.

Principales flujos de autenticación:

1. Authorization Code (Código de autorización): se usa para aplicaciones del lado del servidor, donde el frontend consulta al servidor, y el servidor a su vez solicita la autorización al usuario.
2. Implicit (Flujo implícito): este flujo está optimizado para aplicaciones cliente (por ejemplo, SPA). El token de acceso se entrega directamente a través del navegador.
3. Client Credentials (Credenciales del cliente): se utiliza para la interacción server-server, donde no se necesita una sesión de usuario.
4. Password (Flujo de contraseña): el token se emite mediante la entrada del login y la contraseña del usuario. Se usa menos por motivos de seguridad.

Cómo funciona OAuth2 en Spring

Para usar OAuth2 en Spring, necesitas el módulo spring-security-oauth2. Proporciona todo lo necesario para trabajar con la parte servidor y cliente de OAuth2, incluyendo el manejo de tokens y la verificación de su autenticidad.

Documentación de OAuth2 en Spring Security

JSON Web Token (JWT)

Ahora que ya entendemos OAuth2, es momento de hablar de JSON Web Token (JWT). Es un formato de token que se usa frecuentemente en arquitecturas de microservicios.

JWT (JSON Web Token) — es un token compacto, seguro y autosuficiente que contiene información sobre el usuario y sus permisos. La idea principal del JWT es que está codificado y firmado, así que se puede usar como fuente de verdad para autorizar peticiones.

JWT consta de tres partes, separadas por puntos:

header.payload.signature

• Header (encabezado): contiene información sobre el tipo de token (normalmente JWT) y el algoritmo de cifrado (por ejemplo, HS256).
• Payload (datos): contiene información útil, como el ID del usuario, roles, tiempo de expiración del token, etc.
• Signature (firma): es la firma criptográfica que garantiza la integridad del token y lo protege frente a modificaciones.

Ejemplo de decodificación de un JWT real:

{
  "alg": "HS256",
  "typ": "JWT"
}

{
  "sub": "user123",
  "role": "ADMIN",
  "exp": 1698147200
}

¿Cómo funciona JWT en los microservicios?

JWT encaja muy bien con la arquitectura de microservicios porque:

1. Es autosuficiente. Los datos firmados en el JWT permiten a cada microservicio verificar el token sin preguntar a un servidor central.
2. Es compacto. El token se transmite fácilmente entre microservicios a través de cabeceras HTTP.
3. Facilita la escalabilidad. El sistema de autenticación puede ser distribuido, ya que cada servicio puede trabajar con los tokens de forma autónoma.

Ejemplos de integración de OAuth2 y JWT en Spring

1. Configurar la dependencia

Añade en el pom.xml de tu aplicación Spring Boot la dependencia:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>

2. Configurar la aplicación

En el archivo application.yml configura JWT:

spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: https://your-issuer-url

Esto indica a Spring Security que use JWT para verificar los tokens.

3. Crear la configuración de seguridad

Crea una clase para configurar la seguridad:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
                .and()
            .oauth2ResourceServer()
                .jwt();
    }
}

4. Generación de JWT

Para generar JWT usa la librería jjwt:

Añade la dependencia:

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
</dependency>

Ejemplo de código:

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;

public class JwtTokenGenerator {

    private static final String SECRET_KEY = "my-secret-key";

    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 1 hour validity
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }
}

Ejemplos de uso en proyectos reales

JWT y OAuth2 se usan activamente en arquitecturas de microservicios para asegurar sistemas. Ejemplos:

• Autorización de usuarios en REST API.
• Transferencia segura de datos entre servicios.
• Facilitar la escalabilidad, ya que los tokens se pueden verificar localmente.

¡Eso es todo por ahora! Hemos visto OAuth2 y JWT, entendido cómo usarlos en microservicios y cómo configurarlos en una aplicación Spring. En la siguiente lección profundizaremos en la implementación y en cómo proteger un REST API con estas tecnologías.