Verificar JWT con HS256 y RS256 en Node.js
Curso de OAuth 2.0 y OpenID Connect: Flujos de Autenticación y Casos de Estudio
Contenido del curso
Curso de OAuth 2.0 y OpenID Connect: Flujos de Autenticación y Casos de Estudio
Clase 10 de 25
Clase 10 / 25
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')
