Autenticación con Twitter

Clase 34 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

Comentarios

Victor Martin Ortiz Palacio

student•

Challenge:

const passport = require('passport');
const boom = require('@hapi/boom');
const axios = require('axios');
//Esta fue la libreria que a mi me funcionó.
const LinkedInStrategy = require('@sokratis/passport-linkedin-oauth2').Strategy;

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

passport.use(
  new LinkedInStrategy(
    {
      clientID: config.linkedinClientId,
      clientSecret: config.linkedinClientSecret,
      callbackURL: '/auth/linkedin/callback',
      scope: ['r_emailaddress', 'r_liteprofile']
    },
    async function(accessToken, refreshToken, profile, cb) {
      const { data, status } = await axios({
        url: `${config.apiUrl}/api/auth/sign-provider`,
        method: 'post',
        data: {
          name: profile.displayName,
          email: profile.emails[0].value,
          password: profile.id,
          apiKeyToken: config.apiKeyToken
        }
      });

      if (!data || status !== 200) {
        return cb(boom.unauthorized(), false);
      }

      return cb(null, data);
    }
  )
);

app.get(
  '/auth/linkedin',
  passport.authenticate('linkedin', { state: 'SOME STATE' })
);

app.get('/auth/linkedin/callback', passport.authenticate('linkedin', { session: false}),
  function(req, res, next) {
    if (!req.user) {
      next(boom.unauthorized())
    }

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

    res.cookie('token', token, {
      httpOnly: !config.dev,
      secure: !config.dev
    });

    res.status(200).json(user)
  }
);

Andrés Enrique Sanabria Flores

student•

Agregar el profile.id como password no es un problema de seguridad? cualquiera que pueda obtenerlo luego podría iniciar sesión con las credenciales del usuario.

Bruno Amadori

student•

Ok, por lo que estuve viendo hay que pedir un "product" a LinkedIn, y te tienen que aprobar la petición. El producto sería "Sign In with LinkedIn". No sé si esto es algo nuevo...

Pero terminé sacando la conclusión de que necesitaba eso porque aunque hiciera todo "bien" me tiraba este Authorization Error:

AuthorizationError: Scope "r_emailaddress" is not authorized for your application

Y en el panel de LinkedIn tenés un listado de los SCOPES permitidos para tu app, el cual estaba vacío...

Juan Carlos Del Rio Enciso

student•

Es cierto, en mi caso también necesité de "Sign In with LinkedIn" y ahí funcionó todo!!!

Karen Paola Diaz Duarte

student•

Muy buen curso

Fernando Cordero

student•

No me funciono Twitter, me da Error: Callback URL not approved for this client application. Approved callback URLs can be adjusted in your application settings. Tampoco me funciono LinkedIn y mucho menos Facebook :(

Leonardo Rodriguez

student•

En la consola de desarrollador de Twitter se debe poner la URL del callback para que te funcione, eso si, verifica de poner la url igual en el código y en la consola de Twitter.

Jose Daniel Molina

student•

Mi solucion, me di cuenta de que con estos challenges se refuerzan conceptos y te demuestras a ti mismo que eres capaz de hacer las cosas!!

/*
  Implementando autenticacion con Linkedin
*/
const passport = require('passport');
const axios = require('axios');
const boom = require('@hapi/boom');
const LinkedInStrategy = require('passport-linkedin-oauth2').Strategy;
const { config } = require('../../../config');

passport.use(new LinkedInStrategy({
  clientID: config.linkedinClientId,
  clientSecret: config.linkedinClientSecret,
  callbackURL: '/auth/linkedin/callback',
  scope: ['r_liteprofile', 'r_emailaddress']
},
async (token, tokenSecret, profile, done) => {
  const { data, status } = await axios({
    url: `${config.apiUrl}/api/auth/sign-provider`,
    method: 'post',
    data: {
      name: profile.displayName,
      email: profile.emails[0].value,
      password: profile.id,
      apiKeyToken: config.apiKeyToken
    }
  });

  if(!data || status !== 200) {
    return done(boom.unauthorized(), false);
  }

  return done(null, data);
}
));```

Leonardo Rodriguez

student•

Hola, por alguna extraña razon no me esta mostrando la cookie "token" en el navegador, cuando hago sign-in en postman si me lo muestra. Saben que podria ser?

Jose Anibal Garcia Giraldo

student•

Mi solución al reto :D

Rutas

app.get(
  "/auth/linkedin",
  passport.authenticate("linkedin", { state: "SOME STATE" })
);

app.get(
  "/auth/linkedin/callback",
  passport.authenticate("linkedin", { session: false }),
  function (req, res, next) {
    if (!req.user) {
      next(boom.unauthorized());
    }

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

    res.cookie("token", token, {
      httpOnly: !config.dev,
      secure: !config.dev,
    });

    res.status(200).json(user);
  }
);

Estrategia

const passport = require("passport");
const axios = require("axios");
const boom = require("@hapi/boom");
const LinkedInStrategy = require("passport-linkedin-oauth2").Strategy;
const { config } = require("../../../config");

passport.use(
  new LinkedInStrategy(
    {
      clientID: config.linkedinClientId,
      clientSecret: config.linkedinSecret,
      callbackURL: "/auth/linkedin/callback",
      scope: ["r_liteprofile", "r_emailaddress"],
    },
    async function (accesToken, refreshToken, profile, done) {
      const { data, status } = await axios({
        url: `${config.apiUrl}/api/auth/sign-provider`,
        method: "post",
        data: {
          name: profile.displayName,
          email: profile.emails[0].value,
          password: profile.id,
          apiKeyToken: config.apiKeyToken,
        },
      });

      if (!data || status !== 200) {
        return done(boom.unauthorized(), false);
      }

      return done(null, data);
    }
  )
);

<code>

Es importante solicitar el servicio de autenticación con Linkedin y validar que permisos nos dan para nuestro scope :D

Diego Andres Valderruten Vargas

student•

Challenge:

const passport = require('passport');
const axios = require('axios');
const boom = require('@hapi/boom');
const { Strategy: LinkedInStrategy } = require('passport-linkedin-oauth2');

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

passport.use(
    new LinkedInStrategy({
        clientID: config.linkedinKey,
        clientSecret: config.linkedinSecret,
        callbackURL: "/auth/linkedin/callback",
        scope: ['r_emailaddress', 'r_liteprofile'],
    },
        async (token, tokenSecret, profile, cb) => {
            console.log(profile);
            const { data, status } = await axios({
                url: `${config.apiUrl}/api/auth/sign-provider`,
                method: 'post',
                data: {
                    name: profile.displayName,
                    email: profile.emails[0].value,
                    password: profile.id,
                    apiKeyToken: config.apiKeyToken
                },
            });

            if (!data || status !== 200) {
                return cb(boom.unauthorized());
            }
            console.log(data);

            return cb(null, data);
        }
    )
);

Index.js

app.get("/auth/linkedin", passport.authenticate("linkedin"));

app.get("/auth/linkedin/callback", passport.authenticate("linkedin", { session: false }),
  function (req, res, next) {
    if (!req.user) {
      next(boom.unauthorized());
    }

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

    res.cookie("token", token, {
      httpOnly: !config.dev,
      secure: !config.dev
    });

    res.status(200).json(user);
  }
)

Naldo Duran

student•

✌

Erick Avila Rojas

student•

Mi solución

Estrategia

const passport = require('passport');
const axios = require('axios');
const boom = require('@hapi/boom');
const { get } = require('lodash');
var LinkedInStrategy = require('passport-linkedin-oauth2').Strategy;

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

passport.use(new LinkedInStrategy({
  clientID: config.linkedinClientId,
  clientSecret: config.linkedinClientSecret,
  callbackURL: "/auth/linkedin/callback",
  scope: ['r_emailaddress', 'r_liteprofile'],
  state: false
},
  async (accessToken, refreshToken, profile, done) => {
    try {
      const { data, status } = await axios({
        url: `${config.apiUrl}/api/auth/sign-provider`,
        method: "post",
        data: {
          name: profile.displayName,
          email: get(profile, 'emails.0.value', `${profile.username}@linkedin.com`),
          password: profile.id,
          apiKeyToken: config.apiKeyToken
        }
      });

      if (!data || status !== 200) {
        return done(boom.unauthorized(), false);
      }

      return done(null, data);
    } catch (e) {
      return done(e);
    }
  }
));

Ruta

//@context LinkedIn OAuth Strategy
app.get('/auth/linkedin', passport.authenticate('linkedin', {
  scope: ['r_emailaddress', 'r_liteprofile']
})
);

app.get(
  '/auth/linkedin/callback',
  passport.authenticate('linkedin', { session: false }),
  (req, res, next) => {
    if (!req.user) {
      next(boom.unauthorized());
    }

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

    res.cookie('token', token, {
      httpOnly: !config.dev,
      secure: !config.dev
    });

    res.status(200).json(user);
  }
);

Maria Elizabeth Minero Alvarenga

student•

I like!

const passport = require('passport');
const boom = require('@hapi/boom');
const axios = require('axios');
//Esta fue la libreria que a mi me funcionó.
const LinkedInStrategy = require('@sokratis/passport-linkedin-oauth2').Strategy;

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

passport.use(
  new LinkedInStrategy(
    {
      clientID: config.linkedinClientId,
      clientSecret: config.linkedinClientSecret,
      callbackURL: '/auth/linkedin/callback',
      scope: ['r_emailaddress', 'r_liteprofile']
    },
    async function(accessToken, refreshToken, profile, cb) {
      const { data, status } = await axios({
        url: `${config.apiUrl}/api/auth/sign-provider`,
        method: 'post',
        data: {
          name: profile.displayName,
          email: profile.emails[0].value,
          password: profile.id,
          apiKeyToken: config.apiKeyToken
        }
      });

      if (!data || status !== 200) {
        return cb(boom.unauthorized(), false);
      }

      return cb(null, data);
    }
  )
);

app.get(
  '/auth/linkedin',
  passport.authenticate('linkedin', { state: 'SOME STATE' })
);

app.get('/auth/linkedin/callback', passport.authenticate('linkedin', { session: false}),
  function(req, res, next) {
    if (!req.user) {
      next(boom.unauthorized())
    }

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

    res.cookie('token', token, {
      httpOnly: !config.dev,
      secure: !config.dev
    });

    res.status(200).json(user)
  }
);

/*
  Implementando autenticacion con Linkedin
*/
const passport = require('passport');
const axios = require('axios');
const boom = require('@hapi/boom');
const LinkedInStrategy = require('passport-linkedin-oauth2').Strategy;
const { config } = require('../../../config');

passport.use(new LinkedInStrategy({
  clientID: config.linkedinClientId,
  clientSecret: config.linkedinClientSecret,
  callbackURL: '/auth/linkedin/callback',
  scope: ['r_liteprofile', 'r_emailaddress']
},
async (token, tokenSecret, profile, done) => {
  const { data, status } = await axios({
    url: `${config.apiUrl}/api/auth/sign-provider`,
    method: 'post',
    data: {
      name: profile.displayName,
      email: profile.emails[0].value,
      password: profile.id,
      apiKeyToken: config.apiKeyToken
    }
  });

  if(!data || status !== 200) {
    return done(boom.unauthorized(), false);
  }

  return done(null, data);
}
));```

app.get(
  "/auth/linkedin",
  passport.authenticate("linkedin", { state: "SOME STATE" })
);

app.get(
  "/auth/linkedin/callback",
  passport.authenticate("linkedin", { session: false }),
  function (req, res, next) {
    if (!req.user) {
      next(boom.unauthorized());
    }

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

    res.cookie("token", token, {
      httpOnly: !config.dev,
      secure: !config.dev,
    });

    res.status(200).json(user);
  }
);

const passport = require("passport");
const axios = require("axios");
const boom = require("@hapi/boom");
const LinkedInStrategy = require("passport-linkedin-oauth2").Strategy;
const { config } = require("../../../config");

passport.use(
  new LinkedInStrategy(
    {
      clientID: config.linkedinClientId,
      clientSecret: config.linkedinSecret,
      callbackURL: "/auth/linkedin/callback",
      scope: ["r_liteprofile", "r_emailaddress"],
    },
    async function (accesToken, refreshToken, profile, done) {
      const { data, status } = await axios({
        url: `${config.apiUrl}/api/auth/sign-provider`,
        method: "post",
        data: {
          name: profile.displayName,
          email: profile.emails[0].value,
          password: profile.id,
          apiKeyToken: config.apiKeyToken,
        },
      });

      if (!data || status !== 200) {
        return done(boom.unauthorized(), false);
      }

      return done(null, data);
    }
  )
);

const passport = require('passport');
const axios = require('axios');
const boom = require('@hapi/boom');
const { Strategy: LinkedInStrategy } = require('passport-linkedin-oauth2');

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

passport.use(
    new LinkedInStrategy({
        clientID: config.linkedinKey,
        clientSecret: config.linkedinSecret,
        callbackURL: "/auth/linkedin/callback",
        scope: ['r_emailaddress', 'r_liteprofile'],
    },
        async (token, tokenSecret, profile, cb) => {
            console.log(profile);
            const { data, status } = await axios({
                url: `${config.apiUrl}/api/auth/sign-provider`,
                method: 'post',
                data: {
                    name: profile.displayName,
                    email: profile.emails[0].value,
                    password: profile.id,
                    apiKeyToken: config.apiKeyToken
                },
            });

            if (!data || status !== 200) {
                return cb(boom.unauthorized());
            }
            console.log(data);

            return cb(null, data);
        }
    )
);

app.get("/auth/linkedin", passport.authenticate("linkedin"));

app.get("/auth/linkedin/callback", passport.authenticate("linkedin", { session: false }),
  function (req, res, next) {
    if (!req.user) {
      next(boom.unauthorized());
    }

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

    res.cookie("token", token, {
      httpOnly: !config.dev,
      secure: !config.dev
    });

    res.status(200).json(user);
  }
)

const passport = require('passport');
const axios = require('axios');
const boom = require('@hapi/boom');
const { get } = require('lodash');
var LinkedInStrategy = require('passport-linkedin-oauth2').Strategy;

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

passport.use(new LinkedInStrategy({
  clientID: config.linkedinClientId,
  clientSecret: config.linkedinClientSecret,
  callbackURL: "/auth/linkedin/callback",
  scope: ['r_emailaddress', 'r_liteprofile'],
  state: false
},
  async (accessToken, refreshToken, profile, done) => {
    try {
      const { data, status } = await axios({
        url: `${config.apiUrl}/api/auth/sign-provider`,
        method: "post",
        data: {
          name: profile.displayName,
          email: get(profile, 'emails.0.value', `${profile.username}@linkedin.com`),
          password: profile.id,
          apiKeyToken: config.apiKeyToken
        }
      });

      if (!data || status !== 200) {
        return done(boom.unauthorized(), false);
      }

      return done(null, data);
    } catch (e) {
      return done(e);
    }
  }
));

//@context LinkedIn OAuth Strategy
app.get('/auth/linkedin', passport.authenticate('linkedin', {
  scope: ['r_emailaddress', 'r_liteprofile']
})
);

app.get(
  '/auth/linkedin/callback',
  passport.authenticate('linkedin', { session: false }),
  (req, res, next) => {
    if (!req.user) {
      next(boom.unauthorized());
    }

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

    res.cookie('token', token, {
      httpOnly: !config.dev,
      secure: !config.dev
    });

    res.status(200).json(user);
  }
);

Autenticación con Twitter

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

Implementando recordar sesión

Implementación de las rutas de las películas de usuario

Entender qué es OAuth 2.0 y OpenID Connect

¿Qué es OAuth 2.0 y OpenID Connect?

Implementar autenticación con redes sociales

Cómo crear un proyecto en Google API para hacer autenticación con 0Auth 2.0

Implementando 0Auth2.0 con Google

Implementando Sign Provider en nuestra API

Autenticación con Google usando OpenID Connect

Cómo crear una cuenta de desarrollador con Twitter

Autenticación con Twitter

Autenticación con Facebook

Asegurar tu aplicación de Express

Seguridad con Helmet y npm audit

Automatizar el chequeo de vulnerabilidades con Snyk

Qué es OWASP y buenas prácticas de seguridad

Conclusiones y cierre del curso