Implementando recordar sesión

Clase 26 de 39 • Curso de Autenticación con Passport.js 2019

Contenido del curso

Aprender sobre autenticación y autorización

Conocer qué son los JSON Web Tokens

Entender cómo funcionan las cookies

Implementar autenticación en Express usando Passport.js

Entender qué es OAuth 2.0 y OpenID Connect

28
¿Qué es OAuth 2.0 y OpenID Connect?
04:25 min

Implementar autenticación con redes sociales

Asegurar tu aplicación de Express

Tomar examen

Generalmente cuando queremos implementar la opción de recordar sesión para Express mediante passport, lo que hacemos es extender la expiración de la Cookie.

En nuestra ruta de sign-in de nuestro render server hacemos las siguientes modificaciones:

// Agregamos las variables de timpo en segundos
const THIRTY_DAYS_IN_SEC = 2592000;
const TWO_HOURS_IN_SEC = 7200;

app.post("/auth/sign-in", async function(req, res, next) {
  // Obtenemos el atributo rememberMe desde el cuerpo del request
  const { rememberMe } = req.body;

  passport.authenticate("basic", function(error, data) {
    try {
      if (error || !data) {
        next(boom.unauthorized());
      }

      req.login(data, { session: false }, async function(error) {
        if (error) {
          next(error);
        }

        const { token, ...user } = data;

        // Si el atributo rememberMe es verdadero la expiración será en 30 dias
        // de lo contrario la expiración será en 2 horas
        res.cookie("token", token, {
          httpOnly: !config.dev,
          secure: !config.dev,
          maxAge: rememberMe ? THIRTY_DAYS_IN_SEC : TWO_HOURS_IN_SEC
        });

        res.status(200).json(user);
      });
    } catch (error) {
      next(error);
    }
  })(req, res, next);
});

Comentarios

José María Cuevas Ramírez

student•

Qué tal comunidad, seguí las instrucciones de esta lectura y tuve un problema en la clase siguiente al probar las rutas con Postman, al realizar la petición me estaba regresando un 401 (bad implementation). El problema estaba en que el tiempo de expiración de mis cookies era demasiado cortos. . Cuando hacía "sign-in" todo funciona perfecto, pero para cuando hacía la petición al "/user-movies" mi cookie ya había expirado. . Investigué y encontré que los tiempos que recibe el maxAge son en milisegundos, por tanto si queremos que la cookie dure 2 horas el valor tendría que ser 7200000 y para 30 días sería 2592000000 . Espero a alguien le pueda ser de ayuda si tiene este mismo problema.

Wilson Fernando Antury Torres

student•

Muchas gracias José por el aporte.

Jose Alberto Reyes Quevedo

student•

Me sirvió, muchas gracias!

Enrique Devars

teacher•

La manera en la que yo lo implemente fue de la siguiente forma:

const ONE_DAY_IN_SECONDS = 86400;
const TWO_MONTHS_IN_SECONDS = 5184000;

//Basic strategy
require('../utils/auth/strategies/basic');

function AuthApi(app) {
  const router = express.Router();
  app.use('/api/auth', router);

  const apiKeyService = new ApiKeysService();
  const userService = new UsersServices();

  router.post('/sign-in', async function(req, res, next) {
    const { apiKeyToken, rememberMe } = req.body;
    if (!apiKeyToken) {
      next(boom.unauthorized('apiKeyToken is required'));
    }

    passport.authenticate('basic', function(error, user) {
      try {
        if (error || !user) {
          next(boom.unauthorized());
        }

        req.login(user, { session: false }, async function(error) {
          if (error) {
            next(error);
          }

          const apiKey = await apiKeyService.getApiKey({ token: apiKeyToken });

          if (!apiKey) {
            next(boom.unauthorized());
          }

          const { _id: id, name, email } = user;

          const payload = {
            sub: id,
            name,
            email,
            scopes: apiKey.scopes
          };

          const token = jwt.sign(payload, config.authJwtSecret, {
            expiresIn: rememberMe ? TWO_MONTHS_IN_SECONDS : ONE_DAY_IN_SECONDS
          });

          return res.status(200).json({ token, user: { id, name, email } });
        });
      } catch (error) {
        next(error);
      }
    })(req, res, next);
  });

rusbel bermúdez rivera

student•

muy buen aporte, aunque yo me quedo con la opción de 15 minutos en lugar de una sesión de 1 día.

rusbel bermúdez rivera

student•

Aunque en el ejemplo se implementa con cookie no con token

Omar Flores Grimontt

student•

maxAge recibe un valor en milisegundos, multipliquen el número por mil.

Irungaray Agustin

student•

le dio fiaca hacer esto en una clase?

Alejandro González Reyes

student•

El nombre de la cookie que passportJS genera siempre se llama token o podemos cambiarle el nombre No lo encuentro en la documentación.

Daniel Esteves

student•

¡Hola Alejandro! No es explícitamente token lo puedes cambiar a cualquier nombre pero eso significa que debes mandarla con el nombre que deseas y listo :muscle:

Wilson Fernando Antury Torres

student•

El valor de rememberMe es enviado en en el body desde el frontend en el momento de hacer log-in, si es true entonces se extiende la vida de la cookie.

Robert Jarod Meza Garcia

student•

No entiendo, si el token tiene una expiración de 15 min en el lado del servidor, de que serviría poner mas de ese tiempo la cookie si el token se invalida despues de 15 min???

José Enrique Pérez Aquino

student•

Justamente por eso es una clase en texto, es por si quieres agregar esa funcionalidad, a veces por temas de experiencia de usuario preferimos tener un token que dura mas tiempo.

Edwin García

student•

¿No se supone que esas rutas no van a ser accedidas directamente desde el navegador sino desde el backend del SSR? ¿Se le pasan cookies así al otro servidor también? ¿Qué pasó con el apiKeyToken?

Javier Fuentes Mora

teacher•

no entiendo aqui ya n se usa el apiKeysService??

Geraldine

student•

Pero si prolongamos la cookie y dejamos el valor del token por 15 min a la cookie se le negaría el acceso a las funcionalidades del sistema después de superado este tiempo. ¿qué debería hacer para que la cookie persista en el tiempo?

Luis Fernando Méndez González

student•

Precisamente en esta clase hace la aclaratoria de que lo que se suele hacer es extender el tiempo de vida, si queremos implementarlo por completo deberiamos hacer igual validación de rememberMe en este otro valor para que el token siga siendo válido.

Carlos Alfonso Garcia Rivera

student•

exactamente es lo que se manje la expiracion de la cookie, ya que ahi reside el token, ahora, que tan conveniente es regenerar el token en cada vez que el usuario se reauthentica?

Juan Manuel Velez

student•

el objetivo de eso es generar seguridad sin tener que hacer verificaciones en cada llamada al servidor

Tomas Goldenberg

student•

rememberMe es algo mas que debemos pasar en el body no entiendo esa parte,

como es que el rememberMe llega a ser true?

Nixon Fernando Ortiz Suarez

student•

En javascript null, undefined, '', son valores falsos. Es decir que si no esta el campo rememberMe en objeto req.body esto retornara undefined y cuando se hace la verificación pues retornara false.

Tomas Goldenberg

student•

pero entonces en una auth basic el cliente envia el

username:email password: password

y como envia el rememberMe?

ANTHONY JEAMPIER RANGEL RODRIGUEZ

student•

Excelente Información.

Naldo Duran

student•

✌

Maria Elizabeth Minero Alvarenga

student•

Gracias!

Karen Paola Diaz Duarte

student•

Buenisimo

Jaime Estuardo Sazo Cortéz

student•

Tatiana Karina Valencia Hernández

student•

**Muy bueno, gracias por compartirlo **

const ONE_DAY_IN_SECONDS = 86400;
const TWO_MONTHS_IN_SECONDS = 5184000;

//Basic strategy
require('../utils/auth/strategies/basic');

function AuthApi(app) {
  const router = express.Router();
  app.use('/api/auth', router);

  const apiKeyService = new ApiKeysService();
  const userService = new UsersServices();

  router.post('/sign-in', async function(req, res, next) {
    const { apiKeyToken, rememberMe } = req.body;
    if (!apiKeyToken) {
      next(boom.unauthorized('apiKeyToken is required'));
    }

    passport.authenticate('basic', function(error, user) {
      try {
        if (error || !user) {
          next(boom.unauthorized());
        }

        req.login(user, { session: false }, async function(error) {
          if (error) {
            next(error);
          }

          const apiKey = await apiKeyService.getApiKey({ token: apiKeyToken });

          if (!apiKey) {
            next(boom.unauthorized());
          }

          const { _id: id, name, email } = user;

          const payload = {
            sub: id,
            name,
            email,
            scopes: apiKey.scopes
          };

          const token = jwt.sign(payload, config.authJwtSecret, {
            expiresIn: rememberMe ? TWO_MONTHS_IN_SECONDS : ONE_DAY_IN_SECONDS
          });

          return res.status(200).json({ token, user: { id, name, email } });
        });
      } catch (error) {
        next(error);
      }
    })(req, res, next);
  });

Implementando recordar sesión

Aprender sobre autenticación y autorización

Lo que aprenderás sobre Passport.js

Stack de seguridad moderno

¿Qué es la autenticación y la autorización ?

Introducción a las sesiones

Conocer qué son los JSON Web Tokens

Anatomía de un JWT

Autenticación tradicional vs JWT

Firmando y Verificando nuestro JWT

Server-side vs Client-side sessions

Buenas prácticas con JWT

Entender cómo funcionan las cookies

¿Qué son las cookies y cómo implementar el manejo de sesión?

Cookies vs Session Storage vs Local Storage

Implementar autenticación en Express usando Passport.js

Arquitectura del proyecto Platzi Video

Agregando la colección de usuarios

Agregando la colección de películas de usuario

Implementando el POST y DELETE de las películas de usuario

Cómo conectarnos a la base de datos

Configuración de Passport.js

Implementación de BasicStrategy con Passport.js

Implementación de Strategy y ExtractJwt con Passport.js

Implementación de nuestro Sign-in

Implementación de nuestro Sign-up

Protegiendo nuestras rutas con Passport.js

Middleware para el manejo de scopes

Configuración del server render

Comunicación máquina a máquina