Cursos Empresas Blog Live Conf Eventos Precios

0:006:21

Recursos

Resumen

¿Cómo implementar la generación de un token en una API?

Implementar la generación de tokens en tu API es esencial para asegurar la autenticación y autorización de los usuarios. En este contexto, al usuario, una vez autenticado, se le debe otorgar un token que permita manejar su sesión y conectarse a otros endpoints. Veamos cómo implementar esta lógica utilizando JSON Web Tokens (JWT).

¿Cómo generar un token?

Importación de librerías: Comienza importando la librería de JSON Web Token. Esto es crucial ya que te permitirá trabajar con JWT en tu aplicación.
```
const jwt = require('jsonwebtoken');
```
Definir el payload: El payload contiene la información que se almacenará en el token. Esto puede incluir cualquier dato relevante, como el ID del usuario. En nuestro caso, utilizaremos el ID y el rol del usuario.
```
const payload = {
    id: req.user.id,
    role: req.user.role
};
```
Generar el token: Una vez que se tiene el payload, se genera el token utilizando una clave secreta que no debe estar en el código fuente, sino configurada como una variable de entorno.
```
const token = jwt.sign(payload, process.env.JWT_SECRET);
```

¿Cómo manejar el secreto de la firma del token?

Es importante que el secreto utilizado para firmar el token sea seguro y esté gestionado como una variable de entorno. Esto lo proporciona mayor seguridad frente a ataques. Aquí te explicamos cómo:

Crear una variable de entorno: Define una variable de entorno llamada JWT_SECRET que contenga el secreto.

Ejemplo en .env:
```
JWT_SECRET=your-secret-key
```
Generación del secreto: Utiliza herramientas en línea como Keygen.io para generar claves seguras mediante algoritmos robustos.

¿Cómo reiniciar el entorno de desarrollo?

Después de configurar las variables de entorno, es esencial reiniciar tu entorno de desarrollo para que los cambios surtan efecto. Si no lo haces, podrías enfrentar errores, como el que el secreto no tenga un valor asignado.

Detener la aplicación: Si tu aplicación está corriendo, asegúrate de detenerla antes de realizar cambios.
Reiniciar la aplicación: Una vez configurada la variable de entorno, corre nuevamente tu aplicación para cargar los nuevos valores.

¿Qué esperar al probar el login?

Una vez implementada la lógica de generación de tokens, al probar el endpoint de login, se espera lo siguiente:

Respuesta: El sistema debería devolver tanto la información del usuario como el token recién generado.
Funcionalidad segura: Este token le permitirá al usuario manejar su sesión de manera segura en los siguientes requests.

Por último, asegúrate de aplicar estos tokens en la protección de las rutas de tu API, forzando a los usuarios a enviar el token para acceder a recursos protegidos. ¡Así garantizas una capa más de seguridad y control en tus servicios!

Generación y Firma de Tokens JWT en APIs Backend

Curso de Backend con Node.js: Autenticación con Passport.js y JWT

Clase 10 / 20

Ver clases

Generación y Firma de Tokens JWT en APIs Backend

Curso de Backend con Node.js: Autenticación con Passport.js y JWT

Clase 10 de 20

Clase 10 / 20

Generación y Firma de Tokens JWT en APIs Backend

Curso de Backend con Node.js: Autenticación con Passport.js y JWT

Clase 10 / 20

Ver clases

Maria Gabriela Rodriguez Cuevas#4659832

🗝 Clase #10: Generar JWT en el servicio 10/20 🗝

Pasos: 📝

Vamos a implementar la lógica para que cuando se haga login, tengamos el token. Para ello en VSC, en la carpeta routes, abrimos el archivo auth.router.js, el código queda:

const express = require('express');
const passport = require('passport');
const jwt = require('jsonwebtoken');

//Traemos el config para el jwtSecret
const { config } = require('./../config/config');

const router = express.Router();

router.post('/login',
  passport.authenticate('local', {session: false}),
  //Al pasar la capa de autenticación después de verificar que el usuario y password son correctos
  //al devolver el login, se le brinda un token
  async (req, res, next) => {
    try {
      const user = req.user;
      const payload = {
        sub: user.id,
        role: user.role
      }
      //Se hace la firma
      const token = jwt.sign(payload, config.jwtSecret);
      res.json({
        user,
        token
      });
    } catch (error) {
      next(error);
    }
  }
);

module.exports = router;

Guardamos, vamos a la carpeta config y abrimos el archivo config.js y después de apiKey colocamos:

jwtSecret: process.env.JWT_SECRET,

Guardamos, abrimos la página para generar claves (enlace: aquí), para ésta clase se buscó: WEP 256-bit Key, se generó en la pestaña ++NEW++ y luego al dar en la pestaña ++COPY++, aparece un cuadro donde indica que al presionar las teclas Ctrl + C se copia la clave generada. Esa clave se copia y se pega en el archivo de variables de entorno .env después de API_KEY se coloca el JWT_SECRET, para mi ejemplo:

JWT_SECRET=csvV9KYB4QeqhaEgoJdIzwunROb1XDZU

Guardamos, como se modificó el archivo .env con las variables de entorno, en la terminal se corre de nuevo:

npm run dev

Vamos a Insomia y en la carpeta de Auth en Login, la solicitud del ++POST++ con la dirección: _.API_URL/api/v1/auth/login

En el body JSON:

{
	"email": "superadmin@mail.com",
	"password": "12356 .2020",
	"role": "admin"
}

Al enviar la petición debe salir el código 200 OK:

{
	"user": {
		"id": 3,
		"email": "superadmin@mail.com",
		"role": "admin",
		"createdAt": "2023-03-17T02:47:32.524Z"
	},
	"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjMsInJvbGUiOiJhZG1pbiIsImlhdCI6MTY3OTUzNjc4MH0.ivIhrTTJreKyEFvFWJbRBJ_eLEItoIgH5HlWSVLOESw"
}

Comentarios (16)16 comentarios

Ricardo Rito Anguiano

Hace 5 años

Generating tokes from backend

First of all, configure .env to provide a secret and it won't be accessible from code.

jwtSecret="A SECRET REALLY SECRET"

Page to generate greats passwords:

In our auth.routes configure secret such as we did in the last lesson

router.post('/login',
    //We are using the local strategy and not using sessions
    passport.authenticate('local', { session: false }),
    async(req, res, next) => {
        try {
            const user = req.user;
            **const payload = {
                sub: user.id,
                role: user.role
            }**

            **const token = jwt.sign(payload, config.auth.jwtSecret);**

            res.json({ user, token });

        } catch (err) {
            next(err);
        }
    }
);

Finally,
try it in insomnia/postman!

Miguel Angel Reyes Moreno

Hace 4 años

thanks for the summary

just for feedback, it sounds weird 'a secret really secret'. I'm sure it's supposed to be 'a really secret secret'

Edixon Piña

Al implementar JWT ya no es necesario enviar los datos del usuario en la petición, ya que por medio del payload del token podemos enviarla, ademas recordar que por ningún motivo se debe enviar informacion sensible del usuario.

Juan Jiménez

En el archivo auth.route.js se hace la implementación del JWT, primero se hace la autenticación con la estrategia local y con ello se tiene al usuario (req.user), por lo tanto, se crea el payload con los datos del usuario, posteriormente se firma el token con la función .sign() y como respuesta se envía un JSON con el user y el token.

const express = require('express');
const passport = require('passport');
const jwt = require('jsonwebtoken');

const { config } = require('../../config/config');

const router = express.Router();

router.post(
  '/login',
  passport.authenticate('local', { session: false }),
  async (req, res, next) => {
    try {
      const user = req.user;
      const payload = {
        sub: user.id,
        role: user.role,
      };

      const token = jwt.sign(payload, config.jwtSecret);
      res.json({ user, token });
    } catch (error) {
      next(error);
    }
  }
);

module.exports = router;

El secret es necesario para firmar el token, por ello se asigna en el archivo .env, una página para generar passwords con diferentes algoritmos es .

PORT=3000
DATABASE_URL='postgres://john:admin123@localhost:5432/my_store'
API_KEY=321456
JWT_SECRET='D8T1LkIMVTA8yYSuNgbadlFJ9yGU7cjD'

La nueva variable de entorno se agrega a la configuración config/config.js:

require('dotenv').config();

const config = {
  env: process.env.NODE_ENV || 'dev',
  isProd: process.env.NODE_ENV === 'production',
  port: process.env.PORT || 3000,
  dbUser: process.env.DB_USER,
  dbPassword: process.env.DB_PASSWORD,
  dbHost: process.env.DB_HOST,
  dbName: process.env.DB_NAME,
  dbPort: process.env.DB_PORT,
  dbUrl: process.env.DATABASE_URL,
  apiKey: process.env.API_KEY,
  jwtSecret: process.env.JWT_SECRET,
};

module.exports = { config };

Mario Vizcaino

Otra cosa que es recomendable agregarle al token es un tiempo de expiración (también definido desde envs o alguna configuración por usuario/cliente)

const token = jwt.sign(payload, "secret", {
  // Ejemplo: token expira en 10 horas
  expiresIn: "10h" 
})

Mario Andrés Castro Martínez

Otra forma de generar secrets desde la terminal es:

$ openssl rand -hex 45

Maria Gabriela Rodriguez Cuevas

Andres Achury

Hace 2 años

Veo que la pagina de generar el WEP 256-bit key ya no esta disponible, piden un pago.

Puede usar esta:

Pedro Marval

Para la funcionalidad de jwt cree un servicio y no dejar la logia del lado del router

const jwt = require('jsonwebtoken')
const {config} = require('../config/config')

class JwtService {

    constructor(){
        this.secret = config.secretJWT
    }

    signToken(payload){
        return jwt.sign(payload, this.secret)
    }

    verifyToken(token){
        return jwt.verify(token, this.secret)
    }

}

module.exports = JwtService

Eric Rodriguez

#hola

Hola

Jorge Arias Argüelles

Hace un año

Para aplicar el middleware de inicio de sesión dentro de una ruta en Express, puedes utilizar la función app.use() para aplicar el middleware de autenticación a rutas específicas. Aquí hay un ejemplo básico:

const express = require('express');
const app = express();

// Middleware de autenticación
function isAuthenticated(req, res, next) {
    if (req.isAuthenticated()) {
        return next();
    }
    res.redirect('/login'); // Redirige a la página de inicio de sesión si no está autenticado
}

// Ruta protegida
app.get('/dashboard', isAuthenticated, (req, res) => {
    res.send('Bienvenido al panel de control');
});

En este ejemplo, isAuthenticated es el middleware que verifica si el usuario está autenticado antes de permitir el acceso a la ruta /dashboard. Puedes modificarlo según tus necesidades.

Víctor José Ruiz Herrera

Hace 3 años

Profesor @nicobyte Nicolás Molina, ¿puede ser una buena opción, encriptar la información del payload antes de ingresarla, por ejemplo el correo?

Miguel Giraldo Duque

¡Uhh, qué buena pregunta! 🤔 Me dejaste pensando también. Según lo que investigué y creo, encriptar la información sensible en el payload de un JWT puede ser útil para evitar comprometer esos datos. Sin embargo, esto añade un grado mayor de complejidad, ya que necesitarías implementar un mecanismo para desencriptar el payload antes de interactuar con la base de datos

Aldo Said Salas Rodríguez

¿Cómo se implementaría si quiero que el token que le generamos al usuario se guarde en los headers y no estemos copiando y pegando el token a cada rato?

Andrés Muñoz

En insomnia lo que se me ocurre es guardarlo como variable de ambiente como hicimos con la URL

const jwt = require('jsonwebtoken')
const {config} = require('../config/config')

class JwtService {

    constructor(){
        this.secret = config.secretJWT
    }

    signToken(payload){
        return jwt.sign(payload, this.secret)
    }

    verifyToken(token){
        return jwt.verify(token, this.secret)
    }

}

module.exports = JwtService
```const jwt = require('jsonwebtoken')const {config} = require('../config/config')
class JwtService {
    constructor(){        this.secret = config.secretJWT    }
    signToken(payload){        return jwt.sign(payload, this.secret)    }
    verifyToken(token){        return jwt.verify(token, this.secret)    }
}
module.exports = JwtService

Alejandro Chavez

¡Excelente clase! :star2:

Victor Baruch Pazaran Jaimes

Otra opcion para generar los secrets es directamente con el mismo node creando caracteres aleatorios, en este caso lo hago con un oneliner desde la terminal

echo 'key=require("crypto").randomBytes(128).toString("base64");console.log(key)' | node

Recursos

Resumen

Generación y Firma de Tokens JWT en APIs Backend

Generación y Firma de Tokens JWT en APIs Backend

Generación y Firma de Tokens JWT en APIs Backend

Progreso del curso

Introducción

Protección de contraseñas

Passport y JSON Web Tokens

Envío de emails con Node.js

Recuperación de contraseñas

Despliegue a producción

Próximos pasos

Generación y Firma de Tokens JWT en APIs Backend

Generación y Firma de Tokens JWT en APIs Backend

Recursos

Resumen

¿Cómo implementar la generación de un token en una API?

¿Cómo generar un token?

¿Cómo manejar el secreto de la firma del token?

¿Cómo reiniciar el entorno de desarrollo?

¿Qué esperar al probar el login?

Comentarios

Generating tokes from backend

Recursos

Resumen

¿Cómo implementar la generación de un token en una API?

¿Cómo generar un token?

¿Cómo manejar el secreto de la firma del token?

¿Cómo reiniciar el entorno de desarrollo?

¿Qué esperar al probar el login?

Comentarios

Generating tokes from backend

🗝 Clase #10: Generar JWT en el servicio 10/20 🗝

Pasos: 📝

#hola

Hola