理解护照序列化反序列化

Question

您将如何向外行解释 Passport 的序列化和反序列化方法的工作流程。

1. 调用passport.serializeUser后user.id go 在哪里？
   

2. 我们在它之后立即调用passport.deserializeUser它适合工作流程的什么地方？

    // used to serialize the user for the session passport.serializeUser(function(user, done) { done(null, user.id); // where is this user.id going? Are we supposed to access this anywhere? }); // used to deserialize the user passport.deserializeUser(function(id, done) { User.findById(id, function(err, user) { done(err, user); }); });

我仍在努力解决这个问题。 我有一个完整的工作应用程序，并且没有遇到任何类型的错误。

我只是想了解这里到底发生了什么？

任何帮助表示赞赏。

Answer 1

1. 调用passport.serializeUser后user.id去哪里？

用户 ID（您作为done函数的第二个参数提供）保存在会话中，稍后用于通过deserializeUser函数检索整个对象。

serializeUser确定应将用户对象的哪些数据存储在会话中。 serializeUser 方法的结果作为req.session.passport.user = {}附加到会话。 例如，这将是（因为我们提供用户 ID 作为密钥） req.session.passport.user = {id: 'xyz'}

2. 我们在它适合工作流程的哪个位置之后立即调用passport.deserializeUser ？

deserializeUser的第一个参数对应于赋予done函数的用户对象的键（参见 1.）。 所以你的整个对象是在那个键的帮助下检索的。 此处的键是用户 ID（键可以是用户对象的任何键，例如姓名、电子邮件等）。 在deserializeUser ，该键与内存数组/数据库或任何数据资源匹配。

获取的对象作为req.user附加到请求对象

视觉流

passport.serializeUser(function(user, done) {
    done(null, user.id);
});              │
                 │ 
                 │
                 └─────────────────┬──→ saved to session
                                   │    req.session.passport.user = {id: '..'}
                                   │
                                   ↓           
passport.deserializeUser(function(id, done) {
                   ┌───────────────┘
                   │
                   ↓ 
    User.findById(id, function(err, user) {
        done(err, user);
    });            └──────────────→ user object attaches to the request as req.user   
});

Answer 2

对于使用 Koa 和koa-passport 的任何人：

知道在 serializeUser 方法中设置的用户密钥（通常是该用户的唯一 ID）将存储在：

this.session.passport.user

当您在done(null, user)设置done(null, user) ，其中 'user' 是数据库中的某个用户对象：

this.req.user或this.passport.user

出于某种原因，当您在this.user调用 done(null, user) 时， this.user Koa 上下文永远不会被设置。

因此，您可以在调用 app.use(passport.session()) 之后编写自己的中间件，将其放入 this.user 中，如下所示：

app.use(function * setUserInContext (next) {
  this.user = this.req.user
  yield next
})

如果您不清楚 serializeUser 和 deserializeUser 的工作方式，请在 twitter 上联系我。 @yvanscher

Answer 3

Passport 使用serializeUser函数将用户数据（成功验证后）保存到会话中。 函数deserializeUser用于从会话中检索用户数据。

serializeUser和deserializeUser函数都检查传递给它们的第一个参数，如果它是函数类型，则serializeUser和deserializeUser什么都不做，但将这些函数放在函数堆栈中，然后将被调用（当传递的第一个参数不是类型功能）。 Passport 需要以下设置来在会话中进行身份验证后保存用户数据：

app.use(session({ secret: "cats" }));
app.use(passport.initialize());
app.use(passport.session());

使用的中间件的顺序很重要。 重要的是要看到，当新的授权请求开始时会发生什么：

• session 中间件创建 session（使用sessionStore数据）。

• passport.initialize将_passport对象分配给请求对象，检查是否有会话对象，如果存在，并且字段中存在passport （如果不存在 - 创建一个），将该对象分配给_passport session字段。 最后，它看起来像这样：

   req._passport.session = req.session['passport']

  因此， session字段引用分配给req.session.passport对象。

• passport.session外观为user领域req._passport.session ，如果找到一个，它传递给deserializeUser功能和调用它。 deserializeUser功能受让人req._passport.session.user到user请求对象的字段（如果在查找一个req._passport.session.user ）。 这就是为什么，如果我们像这样在serializeUser函数中设置用户对象：

   passport.serializeUser(function(user, done) { done(null, JSON.strignify(user)); });

  然后我们需要解析它，因为它在user字段中保存为JSON ：

   passport.deserializeUser(function(id, done) { // parsed user object will be set to request object field `user` done(err, JSON.parse(user)); });

所以， deserializeUser函数首先调用，当你设置护照，把你的回调_deserializers函数栈。 第二次，它会在passport.session中间件中调用以将user字段分配给请求对象。 在分配user字段之前，这也会触发我们的回调（我们放入passport.deserializeUser() ）。

在设置 Passport 时首先调用serializeUser函数（类似于deserializeUser函数），但它将用于序列化用户对象以保存在会话中。 第二次，它将在login/logIn (alias)方法中调用，由 Passport 附加，用于在会话中保存用户对象。 serializeUser函数还检查_serializers堆栈，其中已推送给它的函数（其中一个添加，当我们设置 Passport 时）：

passport.serializeUser(function(user, done) ...

并调用它们，然后将用户对象（strignified）或用户 ID 分配给req._passport.session.user 。 重要的是要记住session字段直接引用req.session对象中的passport字段。 以这种方式用户保存在会话中（因为req._passport.session引用了对象req.session.passport ，并且在每个传入请求中都由passport.initialize中间件修改了req._passport.session ）。 当请求结束时， req.session数据将存储在sessionStore 。

成功授权后，当第二个请求开始时会发生什么：

• session中间件从sessionStore获取 session，我们的用户数据已经保存在其中
• passport.initialize检查是否有会话并将req.session.passport分配给req._passport.session
• passport.session检查req._passport.session.user并反序列化它。 在这个阶段（如果req._passport.session.user是真的），我们将有req.user和req.isAuthenticated()返回true 。

Answer 4

您可以使用此代码升级旧的序列化和反序列化，请更新此帖子以获得新的解决方案。

        passport.serializeUser(function(user, cb) {
          process.nextTick(function() {
            cb(null, { id: user.id, username: user.username });
          });
        });
        
        passport.deserializeUser(function(user, cb) {
          process.nextTick(function() {
            return cb(null, user);
          });
        });

Answer 5

基本上，我们只是使用序列化器将用户 ID 存储在 session 中，当我们需要用户 model 实例时，我们使用该用户 ID 在数据库中搜索，这是使用反序列化器完成的。

只要 session 处于活动状态并且用户已通过身份验证，

req.session.passport.user

将始终对应于用户 model 实例。

如果我们不将 user-id 保存到 session 中，并且如果有任何重定向，我们将无法知道用户是否已通过身份验证。

一旦用户通过身份验证req.session.passport.user将被设置。 因此所有未来的请求都会知道用户已经过身份验证。

希望这能简化。

Answer 6

所以我在这个问题上卡住了很长一段时间，所以我制作了一个快速设置文件，这样就再也没有人会卡在这个垃圾上了

护照管理.js

const localStrategy = require('passport-local').Strategy;
const bcrypt = require('bcrypt');
const User = require('./db-schemas/models').UserModel;
/*
const mongoose = require('mongoose')
mongoose.connect("mongodb://localhost:27017/database_name");

const UserSchema = new mongoose.Schema({
    username: {
        type: String,
        required: true
    },
    password: {
        type: String,
        required: true
    },
    email: {
        type: String,
        required: true
    }
});
const UserModel = mongoose.model('collection_name', UserSchema);
*/
const passport = require('passport');

function passportSetupUwU(app) {
    const cookieParser = require('cookie-parser');
    const session = require('express-session');
    const MongoDBStore = require('connect-mongodb-session')(session);

    app.use(cookieParser());
    app.set('trust proxy', 1);
    app.use(session({
    secret: "secret",
    resave: false,
    saveUninitialized: false,
    store: new MongoDBStore({
        uri: "mongodb://localhost:27017/database_name",
        collection: "collection_name"
    })
    }));

    // Passport.js
    app.use(passport.initialize());
    app.use(passport.session());
}

passport.serializeUser(function(user, cb) {
    console.log("serializing user uwu:" + JSON.stringify(user))
    process.nextTick(function() {
        return cb(null, user.id)
    })
})

passport.deserializeUser(function (id, cb) {
    console.log("deserializing user owo:" + JSON.stringify(id))
    User.findOne({id:id}, function (err, user) {
        if (err) { return cb(err)}
        return cb(null, user);
    })
});

passport.use(new localStrategy(function (username, password, done) {
    console.log("attempted login with %s:%s", username, password);
    User.findOne({ username: username }, function (err, user) {
        if (err) return done(err);
        if (!user) return done(null, false, { message: 'No such user exists.' });

        bcrypt.compare(password, user.password, function (err, res) {
            if (err) return done(err);
            if (res === false) return done(null, false, { message: 'Incorrect password.' });
            
            return done(null, user);
        });
    });
}));

module.exports = {setup: passportSetupUwU}

现在只需在 app.js 中导入并运行 passportSetupUwU function 就可以了 go：

app.js 摘录

// some example middleware and stuff i happened to have
const PPSetup = require('./passportmgmt').setup
app.use(logger('dev'));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(express.static(path.join(__dirname, 'public')));

//
// <- PUT IT LIKE HERE OR SOMETHING
//
PPSetup(app);

// some example routes and api endpoints i happened to have
app.use('/api/', apiRouter);
apiRouter.use('/', indexRouter);
apiRouter.use('/users', usersRouter);

apiRouter.post('/login', passport.authenticate('local', {

Answer 7

Passport 的序列化和反序列化方法的可视化工作流程：

1. 用户登录到您的应用程序并提供其凭据。
2. Passport 使用 serializeUser function 将用户 object 转换为 session object。
3. Passport 将 session object 存储在服务器上，并向用户的浏览器发送一个 session cookie。 4.用户向您的应用程序提出请求。 5.Passport使用反序列化用户function将session object转换回用户object。
4. Passport 将用户 object 传递给您的应用程序，然后应用程序可以使用它来确定用户是否已通过身份验证。
5. 如果用户通过身份验证，您的应用程序将允许他们访问所请求的资源。
6. 如果用户未通过身份验证，您的应用程序将拒绝访问并将他们重定向到登录页面。

这是工作流程的可视化表示：

    +------------+             +---------------+
|            |             |               |
| User Login |             | Session Object |
|            |    serializeUser    |               |
+-----+------+   ------------------>   +---------+
      |                                 |           |
      |                                 | Store on  |
      |                                 | Server    |
      |                                 |           |
+-----+------+   <------------------   +---------+
|            |             |               |
| User Request |    deserializeUser    |               |
|            |   ------------------>   |             |
+------------+             |               +-----------+
      |                   |
      |                   |
      |                   |
+-----+------+   <------------------   +---------+
|            |             |               |
| Authenticated |             |     User     |
|  or not       |             |             |
|            |             |               |
+------------+             +---------------+

我希望这有助于阐明 Passport 的序列化和反序列化方法的工作流程！