Fernando Hernandez
Andrés Felipe Lubo Carracedo
Jehison Orostegui
Verificar un JSON Web Token (JWT) es el paso que cierra el ciclo de autenticación: confirma que el token recibido es genuino y no ha sido alterado. Aquí aprendes cómo hacerlo en Node.js con firma simétrica (HS256) y asimétrica (RS256), cuándo usar cada una y qué riesgos evitar al exponer claves.
¿Cómo verificar un JWT en Node.js paso a paso?
La verificación se apoya en la misma librería que usaste para firmar. El método jwt.verify recibe el token en formato de serialización compacta, esas tres partes codificadas en base64 separadas por puntos que ya conoces [01:00].
El segundo parámetro depende del algoritmo:
Dentro del endpoint privado, después de extraer el token de los headers, basta con llamar jwt.verify(token, secret). Una sola línea hace el trabajo [01:30].
¿Qué hace jwt.verify exactamente? Recalcula la firma del token usando el secret o la llave pública y la compara con la firma original. Si coinciden y el token no expiró, lo considera válido.
¿Cómo probar la verificación con Postman?
Al llamar el endpoint privado con un token expirado, recibes un error. Eso es buena señal: significa que la verificación funciona. Si pides un token nuevo y repites la llamada, la respuesta I'm private confirma que todo fluye [02:15].
¿Cómo firmar un JWT de forma asimétrica con RS256?
La firma asimétrica usa un par de llaves: una privada que firma y una pública que verifica. Para generarlas, un script con OpenSSL crea los archivos en formato PKCS8 (Public Key Cryptographic Standard número 8), el más recomendado actualmente [03:30].
El resultado son dos archivos:
private.pem con la llave privada.public.pem con la llave pública.En el método de firmado, agregas un condicional: si existe privateKeyPath en las variables de entorno, lees el archivo con el módulo nativo de Node.js. La forma correcta de importarlo en proyectos ES Modules es node:fs, así le indicas explícitamente que es la librería oficial [05:00].
Con la llave cargada, retornas el token usando el payload, la privateKey y declaras en el tercer argumento que el algoritmo es RS256. Sin ese parámetro, la librería no sabría que estás firmando asimétricamente.
¿Cómo confirmar que el token usa RS256?
Una forma rápida es pegar el token en JWT.io. A la derecha aparece la decodificación del header y el payload, donde puedes confirmar que el algoritmo es RS256. La página incluso permite pegar la llave privada y pública para verificar la firma manualmente [06:30].
¿Cómo verificar un token firmado asimétricamente?
El ajuste en verifyToken es paralelo al del firmado. Con un condicional preguntas si existe publicKeyPath. Si es así, lees el archivo de la llave pública y se la pasas a jwt.verify en lugar del secret [07:30].
En este caso no necesitas declarar el algoritmo en las opciones: la librería lo infiere desde el header del token. Cargas la variable de entorno con la ruta del archivo y la verificación queda lista.
Un detalle útil del flujo de pruebas: en la pestaña de test de Postman puedes guardar automáticamente el token recién emitido como variable de entorno. Así, cada llamada al endpoint privado usa el token vigente sin pasos manuales [08:15].
¿Cuándo conviene RS256 sobre HS256? Usa RS256 cuando varios servicios necesitan verificar tokens sin compartir secretos. La llave pública puede distribuirse libremente; solo quien tiene la privada puede emitir tokens válidos.
¿Qué riesgos tiene exponer el secreto en HS256?
La diferencia entre ambos algoritmos no es solo técnica, también es de seguridad operativa.
La verificación, al final, es tan simple como regenerar la firma con el material correspondiente y compararla con la firma del token original. La complejidad real está en proteger las llaves.
¿Qué pasa si alguien obtiene mi secret HS256? Puede emitir tokens válidos a nombre de cualquier usuario. Por eso ese valor debe vivir solo en variables de entorno seguras y nunca en el código fuente ni en repositorios.
Como reto, replica el proceso de verificación en un lenguaje distinto a Node.js. Comparte en los comentarios qué librería elegiste y si te gustaría una introducción a criptografía para entender qué ocurre dentro de PKCS8 y los algoritmos de firma.
Fernando Hernandez
Andrés Felipe Lubo Carracedo
Jehison Orostegui
Luis Márquez
Guillermo Rodas
ProfesorEdgar Rolando Cosajay Campos
Bryan Key
JUAN CARLOS PARRA GALAN
Luis Angel Hernandez Barreto
Samuel Gómez Balderas
Luisa Fernanda Duque Ortiz
Ulises Serrano Pérez
Samuel De La Hoz
Angel Javier Sanchez Tenjo
Luis Márquez
Guillermo Rodas
ProfesorJuan Pablo Bautista Cala
Mauricio Combariza
Alguien dijo... Curso de Criptografia?
✋
✋
¿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.
Lo qué pasa es que a diferencia del método de encriptación, nosotros estamos es “firmando”.
Es tal como sería firmar un documento, solo tú puedes firmar documentos (tu llave privada) la llave pública solo sirve para revisar que tu firma es correcta (una lupa para ver el detalle de tu firma).
Quien tenga la llave pública solo puede comprobar que la firma es correcta, pero no firmar.
El firmado asimétrico es cómo funciona por ejemplo el protocolo HTTPS / SSH entre otras cosas.
queremos 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 💚
quien dijo miedo al curso de criptografia?
jajajajjaja, me hiciste reir ome
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
Cargar la Llave privada desde archivo .pem (recomendado)
import java.nio.file.Files; import java.nio.file.Paths; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java.util.Base64; public class PublicKeyLoader { public static PublicKey loadPublicKey(String path) throws Exception { String key = new String(Files.readAllBytes(Paths.get(path))) .replace("-----BEGIN PUBLIC KEY-----", "") .replace("-----END PUBLIC KEY-----", "") .replaceAll("\\s+", ""); byte[] decoded = Base64.getDecoder().decode(key); X509EncodedKeySpec spec = new X509EncodedKeySpec(decoded); KeyFactory factory = KeyFactory.getInstance("RSA"); return factory.generatePublic(spec); } }
Servicio de verificación del JWT
import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jws; import io.jsonwebtoken.Jwts; import java.security.PublicKey; public class JwtVerificationService { private final PublicKey publicKey; public JwtVerificationService(PublicKey publicKey) { this.publicKey = publicKey; } public Claims verify(String token) { Jws<Claims> jws = Jwts.parserBuilder() .setSigningKey(publicKey) .build() .parseClaimsJws(token); return jws.getBody(); } }
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.
Lo qué pasa es que a diferencia del método de encriptación, nosotros estamos es “firmando”.
Es tal como sería firmar un documento, solo tú puedes firmar documentos (tu llave privada) la llave pública solo sirve para revisar que tu firma es correcta (una lupa para ver el detalle de tu firma).
Quien tenga la llave pública solo puede comprobar que la firma es correcta, pero no firmar.
El firmado asimétrico es cómo funciona por ejemplo el protocolo HTTPS / SSH entre otras cosas.
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')