---

💡 정보 출처

1. passport-official website : Click Here
2. github-passport : Click Here
3. npm-passport : Click Here

---

🔑 공식 홈페이지 Documentation 번역

http://www.passportjs.org/docs/

😀 Overview

• $ npm install passport

app.post(
  '/login',
  passport.authenticate(
    'local',
    {
      successRedirect: '/',
      failureRedirect: '/login'
    }
  )
);

😁 Authenticate

• 그냥 라우터에 미들웨어처럼 쓰면 된다.
• strategy만 정해서 알려주면 된다.
• 만약 인증이 실패하면 passport는 401 Unauthorized를 반환한다.
• 인증이 성공하며 req.user에 user 정보가 담기고 next()가 호출된다.
• flash message 기능은 req.flash()를 사용한다.
• 이는 Express 2 버전에는 내장되어 있지만, Express 3버전에는 없기 때문에 connect-flash를 사용해야 한다.
• var flash = require('connect-flash'); app.use(flash());

// default
app.post('/login',
  passport.authenticate('local'),
  function(req, res) {
    // If this function gets called, authentication was successful.
    // `req.user` contains the authenticated user.
    res.redirect('/users/' + req.user.username);
  });

// redirect
app.post('/login',
  passport.authenticate(
  	'local',
    {
      successRedirect: '/',
      failureRedirect: '/login',
      failureFlash: true // 이러면 error 메세지를 유저에게 Flash로 보여준다.
    }
));

// flash 예제
passport.authenticate('local', { failureFlash: 'Invalid username.' });
passport.authenticate('local', { successFlash: 'Welcome!' });

// Disable Sessions
app.get('/api/users/me',
  passport.authenticate('basic', { session: false }),
  function(req, res) {
    res.json({ id: req.user.id, username: req.user.username });
  });

// Custom Callback
app.get('/login', function(req, res, next) {
  passport.authenticate('local', function(err, user, info) {
    if (err) { return next(err); }
    if (!user) { return res.redirect('/login'); }
    req.logIn(user, function(err) {
      if (err) { return next(err); }
      return res.redirect('/users/' + user.username);
    });
  })(req, res, next);
});

😂 Configure

• strategy, app middleware, sessions(optional) 세 가지를 설정해야한다.

// strategy 사용법
var passport = require('passport');
var LocalStrategy = require('passport-local').Strategy;

passport.use(new LocalStrategy(
  function(username, password, done) {
    User.findOne({ username: username }, function (err, user) {
      if (err) { return done(err); }
      if (!user) {
        return done(null, false, { message: 'Incorrect username.' });
      }
      if (!user.validPassword(password)) {
        return done(null, false, { message: 'Incorrect password.' });
      }
      return done(null, user);
    });
  }
));

// middleware 사용법 (Express 4)
var session = require("express-session");
var bodyParser = require("body-parser");

app.use(express.static("public"));
app.use(session({ secret: "cats" }));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(passport.initialize());
app.use(passport.session());

// sessions
passport.serializeUser(function(user, done) {
  done(null, user.id);
});

passport.deserializeUser(function(id, done) {
  User.findById(id, function(err, user) {
    done(err, user);
  });
});

😃 Username & Password

• the most widely used way for websites is the "passport-local"

var passport = require('passport');
var LocalStrategy = require('passport-local').Strategy;

passport.use(new LocalStrategy(
  // you can skip right below object
  // if you use input named username and password
  {
    usernameField: 'email',
    passwordField: 'passwd'
  },
  function(username, password, done) {
    User.findOne({ username: username }, function(err, user) {
      if (err) { return done(err); }
      if (!user) {
        return done(null, false, { message: 'Incorrect username.' });
      }
      if (!user.validPassword(password)) {
        return done(null, false, { message: 'Incorrect password.' });
      }
      return done(null, user);
    });
  }
));

app.post('/login',
  passport.authenticate(
    'local',
    { 
      successRedirect: '/',
      failureRedirect: '/login',
      failureFlash: true
    }
  )
);

😆 OpenID

• openID는 사용자의 openID Provider를 통해 인증을 진행하는 로그인 방식이다.
• npm install passport-openID가 필요하다.

var passport = require('passport');
var OpenIDStrategy = require('passport-openid').Strategy;

passport.use(new OpenIDStrategy({
    // 로그인 후 돌아가야할 곳(내 사이트 주소)
    returnURL: 'http://www.example.com/auth/openid/return',
    // 내 사이트의 root url
    realm: 'http://www.example.com/'
  },
  function(identifier, done) {
    User.findOrCreate({ openId: identifier }, function(err, user) {
      done(err, user);
    });
  }
));

app.post('/auth/openid', passport.authenticate('openid'));

app.get('/auth/openid/return',
  passport.authenticate('openid', { successRedirect: '/',
                                    failureRedirect: '/login' }));

// if you need profile info, you can get those like below
passport.use(new OpenIDStrategy({
    returnURL: 'http://www.example.com/auth/openid/return',
    realm: 'http://www.example.com/',
    profile: true
  },
  function(identifier, profile, done) {
    // ...
  }
));

• HTML Form 양식

<form action="/auth/openid" method="post">
    <div>
        <label>OpenID:</label>
        <input type="text" name="openid_identifier"/><br/>
    </div>
    <div>
        <input type="submit" value="Sign In"/>
    </div>
</form>

😇 OAuth 1.0

• OAuth란 API 접근을 허가해주는 표준화된 프로토콜이다.
• npm install passport-oauth

var passport = require('passport');
var OAuthStrategy = require('passport-oauth').OAuthStrategy;

passport.use('provider', new OAuthStrategy({
    requestTokenURL: 'https://www.provider.com/oauth/request_token',
    accessTokenURL: 'https://www.provider.com/oauth/access_token',
    userAuthorizationURL: 'https://www.provider.com/oauth/authorize',
    consumerKey: '123-456-789',
    consumerSecret: 'shhh-its-a-secret'
    callbackURL: 'https://www.example.com/auth/provider/callback'
  },
  function(token, tokenSecret, profile, done) {
    User.findOrCreate(..., function(err, user) {
      done(err, user);
    });
  }
));

app.get('/auth/provider', passport.authenticate('provider'));

app.get('/auth/provider/callback',
  passport.authenticate('provider', { successRedirect: '/',
                                      failureRedirect: '/login' }));

// It can be used like this
<a href="/auth/provider">Log In with OAuth Provider</a>

😍 OAuth 2.0

• OAuth 1.0 과 실제 워크플로우는 같지만, 초기 버전의 단점들을 개선해두었다.

var passport = require('passport')
  , OAuth2Strategy = require('passport-oauth').OAuth2Strategy;

passport.use('provider', new OAuth2Strategy({
    authorizationURL: 'https://www.provider.com/oauth2/authorize',
    tokenURL: 'https://www.provider.com/oauth2/token',
    clientID: '123-456-789',
    clientSecret: 'shhh-its-a-secret'
    callbackURL: 'https://www.example.com/auth/provider/callback'
  },
  function(accessToken, refreshToken, profile, done) {
    User.findOrCreate(..., function(err, user) {
      done(err, user);
    });
  }
));

app.get('/auth/provider', passport.authenticate('provider'));

app.get('/auth/provider/callback',
  passport.authenticate('provider', { successRedirect: '/',
                                      failureRedirect: '/login' }));

// you can limit the scope of access
// it is provider-specific. so check the docs of each provider
app.get('/auth/provider',
  passport.authenticate('provider', { scope: ['email', 'sms'] })
);

😜 User Profile

• provider를 통해 유저관리를 하는 경우, 유저 정보가 제각각인 경우가 많다.
• passport는 이를 어느정도 표준화하여 제공하고 있다.
  

🧐 Google

• npm install passport-google-oauth
• google develope console에서 ID와 Key를 발급 받아야한다.
• 그리고 Google+ API 를 활성화해라.
• 안 그러면 유저의 신상 정보를 못 받을 수 있다.

OAuth 1.0 - Google

var passport = require('passport');
var GoogleStrategy = require('passport-google-oauth').OAuthStrategy;

passport.use(new GoogleStrategy({
    consumerKey: GOOGLE_CONSUMER_KEY,
    consumerSecret: GOOGLE_CONSUMER_SECRET,
    callbackURL: "http://www.example.com/auth/google/callback"
  },
  function(token, tokenSecret, profile, done) {
      User.findOrCreate({ googleId: profile.id }, function (err, user) {
        return done(err, user);
      });
  }
));

app.get('/auth/google',
  passport.authenticate('google', { scope: 'https://www.google.com/m8/feeds' });

app.get('/auth/google/callback', 
  passport.authenticate('google', { failureRedirect: '/login' }),
  function(req, res) {
    res.redirect('/');
  });

OAuth 2.0 - Google

var passport = require('passport');
var GoogleStrategy = require('passport-google-oauth').OAuth2Strategy;

passport.use(new GoogleStrategy({
    clientID: GOOGLE_CLIENT_ID,
    clientSecret: GOOGLE_CLIENT_SECRET,
    callbackURL: "http://www.example.com/auth/google/callback"
  },
  function(accessToken, refreshToken, profile, done) {
       User.findOrCreate({ googleId: profile.id }, function (err, user) {
         return done(err, user);
       });
  }
));

app.get('/auth/google',
  passport.authenticate('google', { scope: ['https://www.googleapis.com/auth/plus.login'] }));

app.get('/auth/google/callback', 
  passport.authenticate('google', { failureRedirect: '/login' }),
  function(req, res) {
    res.redirect('/');
  });

😎 Basic & Digest

• 이 두 스키마는 아이디와 패스워드를 이용하여 유저를 관리하며 API endpoint를 보호한다.
• 해킹에 취약한 서비스의 경우 OAuth 2.0을 사용할 것을 추천한다.
• Basic과 Digest 스키마는 passport-http 모듈을 통해 사용가능하다.

passport.use(new BasicStrategy(
  function(username, password, done) {
    User.findOne({ username: username }, function (err, user) {
      if (err) { return done(err); }
      if (!user) { return done(null, false); }
      if (!user.validPassword(password)) { return done(null, false); }
      return done(null, user);
    });
  }
));
app.get('/api/me',
  passport.authenticate('basic', { session: false }),
  function(req, res) {
    res.json(req.user);
  });

passport.use(new DigestStrategy({ qop: 'auth' },
  function(username, done) {
    User.findOne({ username: username }, function (err, user) {
      if (err) { return done(err); }
      if (!user) { return done(null, false); }
      return done(null, user, user.password);
    });
  },
  function(params, done) {
    // validate nonces as necessary
    done(null, true)
  }
));
app.get('/api/me',
  passport.authenticate('digest', { session: false }),
  function(req, res) {
    res.json(req.user);
  });

🤩 OAuth 2.0

• OAuth 2.0 은 토큰을 사용한다.
• 이는 두 가지 큰 장점이 있다.
• 첫째로, 토큰은 유저의 이름과 패스워드를 저장할 필요가 없다.
• 둘째로, 토큰에는 제약을 둘 수 있다(읽기-전용 처럼..)
• npm install passport-http-bearer

passport.use(new BearerStrategy(
  function(token, done) {
    User.findOne({ token: token }, function (err, user) {
      if (err) { return done(err); }
      if (!user) { return done(null, false); }
      return done(null, user, { scope: 'read' });
    });
  }
));
app.get('/api/me',
  passport.authenticate('bearer', { session: false }),
  function(req, res) {
    res.json(req.user);
  });

🥺 Login

• login 세션을 만들기 위해 login() 함수를 쓸 수 있다.
• 그렇게 저장된 user 정보는 req.user로 접근할 수 있다.
• passport.authenticate() 미들웨어를 쓰면 req.login()이 자동으로 실행된다.
• 그래서 이 함수는 보통 회원가입 기능을 구현할 때만 사용된다.

req.login(user, function(err) {
  if (err) { return next(err); }
  return res.redirect('/users/' + req.user.username);
});

😤 Logout

app.get('/logout', function(req, res){
  req.logout();
  res.redirect('/');
});

🤗 Authorize

• google, facebook 등을 통해 가입한 회원을 하나로 통합해야할 때가 있다.
• passport.authorize()으로 이를 처리할 수 있다.
• 그 정보들은 req.account에 저장된다.

app.get('/connect/twitter',
  passport.authorize('twitter-authz', { failureRedirect: '/account' })
);

app.get('/connect/twitter/callback',
  passport.authorize('twitter-authz', { failureRedirect: '/account' }),
  function(req, res) {
    var user = req.user;
    var account = req.account;

    // Associate the Twitter account with the logged-in user.
    account.userId = user.id;
    account.save(function(err) {
      if (err) { return self.error(err); }
      self.redirect('/');
    });
  }
);

passport.use('twitter-authz', new TwitterStrategy({
    consumerKey: TWITTER_CONSUMER_KEY,
    consumerSecret: TWITTER_CONSUMER_SECRET,
    callbackURL: "http://www.example.com/connect/twitter/callback"
  },
  function(token, tokenSecret, profile, done) {
    Account.findOne({ domain: 'twitter.com', uid: profile.id }, function(err, account) {
      if (err) { return done(err); }
      if (account) { return done(null, account); }

      var account = new Account();
      account.domain = 'twitter.com';
      account.uid = profile.id;
      var t = { kind: 'oauth', token: token, attributes: { tokenSecret: tokenSecret } };
      account.tokens.push(t);
      return done(null, account);
    });
  }
));

passport.use(new TwitterStrategy({
    consumerKey: TWITTER_CONSUMER_KEY,
    consumerSecret: TWITTER_CONSUMER_SECRET,
    callbackURL: "http://www.example.com/auth/twitter/callback",
    passReqToCallback: true
  },
  function(req, token, tokenSecret, profile, done) {
    if (!req.user) {
      // Not logged-in. Authenticate based on Twitter account.
    } else {
      // Logged in. Associate Twitter account with user.  Preserve the login
      // state by supplying the existing user after association.
      // return done(null, req.user);
    }
  }
));