Introducción a OAuth 2.0 y OIDC

1

OAuth y OpenID Connect: Autenticación y Autorización Básica

2

¿Qué es la autenticación?

3

Autorización y Control de Acceso Basado en Roles

4

Protocolos Open Authorization y OpenID Connect: Alternativas y Comparación

5

Protección de Endpoints con Autenticación y Autorización Básica

6

Flujo de Open Authorization y Open ID con Discord

JSON Web Tokens

7

JSON Web Tokens: Conceptos, Ventajas y Algoritmos de Firma

8

Comparación de Sesiones y JSON Web Tokens en Autenticación

9

Firmado de JSON Web Tokens con Librería JWT en Node.js

10

Verificación de JSON Web Tokens en Node.js

Quiz: JSON Web Tokens

Open Authorization 2.0

11

Implementación de flujos OAuth 2.0 con APIs populares

12

Flujos de Autorización en OAuth 2.0: Conceptos y Funcionamiento

13

Elección del Flujo Oauth 2.0 según Roles del Cliente y Servidor

14

Implementación de Authorization Code Flow con Spotify y React

15

Implementación de Authorization CodeFlow con Proofkit en Twitter API

16

Implementación de Implicit Flow con Twitch en React

17

Implementación de Client Credentials Flow en Discord

18

Implementación de Resource Owner Password Flow con Auth0

Quiz: Open Authorization 2.0

Open ID Connect

19

OpenID Connect: Autenticación sobre OAuth paso a paso

20

Implementación de Implicit Flow con For Post usando Auth0

21

Implementación del Hybrid Flow en Autenticación de Aplicaciones

Quiz: Open ID Connect

OAuth y OIDC en producción

22

Buenas prácticas y riesgos de los JSON Web Tokens (JWT)

23

Implementación Segura de Open Authorization (OAuth)

24

Autenticación Rápida con NextAlt y GitHub en Next.js

25

Curso Práctico de Autenticación con Outh Zero

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Verificación de JSON Web Tokens en Node.js

10/25
Recursos

¿Cómo verificar un JSON Web Token?

La verificación de un JSON Web Token (JWT) es un paso crucial para asegurar la autenticidad y seguridad de las comunicaciones. Utilizando una librería especial, podemos comprobar si el token que recibimos ha sido firmado correctamente y no ha sido alterado. Aquí te explicamos el proceso detallado y simplificado para verificar un JWT en Node.js.

¿Qué necesitamos?

  • Un JSON Web Token en formato de serialización compacta, que es una cadena de tres partes codificadas en base 64, separadas por puntos.
  • Un secreto compartido o una llave pública, dependiendo del tipo de algoritmo de firmado (simétrico o asimétrico).
  • La librería adecuada para manejar JWT.

¿Cómo se verifica un token?

  1. Obtener el Token: Recibe el token desde el header de una solicitud HTTP en el endpoint correspondiente.
  2. Verificar el Token:
    • Usa la librería de JWT para verificar la firma del token pasándole el token y el secreto o llave pública.
    • Esta operación comprueba si el token es válido y no ha expirado.
// Ejemplo de cómo verificar un token en Node.js
const jwt = require('jsonwebtoken');

// Token y secreto
const token = 'your-jwt-token';
const secret = 'your-secret';

// Verificación
jwt.verify(token, secret, (err, decoded) => {
  if (err) {
    console.error('Error al verificar el token:', err.message);
  } else {
    console.log('Token verificado:', decoded);
  }
});

¿Cómo podemos implementar un firmado asimétrico?

El firmado asimétrico utiliza un par de llaves: una privada para firmar el token y una pública para verificarlo. Esto añade un nivel extra de seguridad, ya que la llave privada nunca se expone.

Pasos para la implementación:

  1. Generación de llaves: Crea un par de llaves con una herramienta como OpenSSL. Las llaves deben estar en formato PKCS8.
  2. Cargar la llave privada: Usa filesystem de Node.js para leer tu llave privada desde un archivo.
const fs = require('fs');
const privateKey = fs.readFileSync('path/to/private.pem', 'utf8');

// Firmado del token
const signOptions = { algorithm: 'RS256' };
const token = jwt.sign(payload, privateKey, signOptions);
  1. Verificar el token con la llave pública: Similar al método de firmado simétrico, pero usando la llave pública.
const publicKey = fs.readFileSync('path/to/public.pem', 'utf8');

// Verificación
jwt.verify(token, publicKey, (err, decoded) => {
  if (err) {
    console.error('Error al verificar token asimétrico:', err.message);
  } else {
    console.log('Token verificado:', decoded);
  }
});

¿Qué consideraciones de seguridad debemos tener?

  • Llave Pública: Es segura para exponer, ya que su propósito es verificar la firma.
  • Llave Privada: Debe mantenerse segura y nunca alojarse en lugares accesibles públicamente.
  • Secretos: Si usas un algoritmo simétrico, mantén el secreto bien protegido y nunca lo compartas ni lo expongas.

Desafíos prácticos

Para profundizar más, se te anima a implementar el proceso de verificación de JWT en otro lenguaje distinto a Node.js. Este ejercicio te permitirá entender mejor los principios de la criptografía involucrados y mejorar tus habilidades multiplataforma.

¡Continúa explorando y aprendiendo más sobre autenticación segura! Este conocimiento es clave para construir aplicaciones más robustas y seguras.

Aportes 11

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Alguien dijo… Curso de Criptografia?

queremos curso de criptografia

quien dijo miedo al curso de criptografia?

Curso de criptografía? por su puesto!!! Ojalá sea una realidad!!
claro que queremos curso de criptografía

Hay que darle al curso de criptografía, sin miedo al exito.

Vamos por el curso de criptografia

(Perdon por lo que van a leer a continuacion) Bien chicos! Recuerden SIEMPRE que el primer caso de "clave privada" solo es cuando tienes una app "sencilla" cliente-servidor o tu proyecto es un "monolito" PERO cuando es un app que usa microservicios en su arquitectura de servidores ejemplo "hexagonal" estos servicios, se comparten entre SI la clave "publica" y 1 solo servicio tiene la "privada" que es la que autentica a los frontends y luego cuando los frontends van a los otros servicios, estos validan con la "publica" no es que esa clave debe estar en todos lados OJO! No se rindan, go ahead 💚

por qué al verificar solo es necesario la llave pública?
es decir, imagina que cambia el token, un usuario decodifca el payload, lo cambia y lo vuelve a codificar, si se verifica solo con la public no es peligroso? es decir, en ese caso tendriamos que cuidar la llave publica tanto asi como cuidamos la privada y eso suena medio raro la verdad.

Por fin!! Alguien que piensa en hacer un curso de criptografía, SIUUUUUUU

Este es el proceso de verificación del jwt de manera simetrica en python para un backend en FastAPI

# Decode function debe devolver informacion teniendo el token

def decodeJWT(token):
        try:
            payload = jwt.decode(token, JWT_SECRET, algorithm=JWT_ALGORITHM)
            return payload
        except jwt.ExpiredSignatureError:
            raise HTTPException(status_code=401, detail='Signature has expired')
        except jwt.InvalidTokenError as e:
            raise HTTPException(status_code=401, detail='Invalid token')