Question

我使用以下函数来散列用户密码，按照Express的身份验证示例：

function hash(pwd, salt, fn) {
    // Bytesize
    var len = 128,

    // Iterations. ~300ms
        iterations = 12000;

    if (3 == arguments.length) {
        crypto.pbkdf2(pwd, salt, iterations, len, fn);
    } else {
        fn = salt;
        crypto.randomBytes(len, function(err, salt){
            if (err) return fn(err);
            salt = salt.toString('base64');
            crypto.pbkdf2(pwd, salt, iterations, len, function(err, hash){
                if (err) return fn(err);
                fn(null, salt, hash);
            });
        });
    }
}

如您所见，salt将作为以base64编码的字符串返回。但是，hash以SlowBuffer的形式返回。尝试登录用户时，此功能也用于比较哈希值。

我的用户Mongoose架构指定hash应为String类型。这最终以一种奇怪的方式存储哈希，导致这样的内容对我的mongo主机造成了严重破坏：

screenshot of hash in mongodb

我的问题是，是否有更好/更智能的方法将此hash存储在我的数据库中？我尝试使用.toString('hex')对其进行编码，并且我也尝试将用户架构中的hash类型更改为buffer，但这两种方法在尝试登录时都将所有比较都设为错误用户。比较在我的authenticate函数中进行，如下所示：

function authenticate(name, pass, fn) {
    var findUser = function(username) {
        var deferred = Q.defer(),
            populateObj = [
                // list of paths to populate objects normally goes here
            ];
        User.findOne({ username: name }).populate(populateObj).exec(function (err, retrievedUser) {
            if (err || !retrievedUser) {
                console.log(err);
                deferred.reject('Cannot find user.');
            }
            else {
                deferred.resolve(retrievedUser);
            }
        });

        return deferred.promise;
    };

    findUser(name).then(function(data) {
        // apply the same algorithm to the POSTed password, applying
        // the hash against the pass / salt, if there is a match we
        // found the user
        hash(pass, data.salt, function(err, hash){
            if (err) return fn(err);
            if (hash == data.hash) return fn(null, data);
            return fn('Invalid password.');
        });
    }, function() {
        return fn('Failed to retrieve user.');
    });
}

Answer 1

将哈希值存储为数据库中的十六进制字符串对我来说没问题（将它们“原始”存储在String或Buffer属性中）：

var crypto      = require('crypto');
var mongoose    = require('mongoose');
var client      = mongoose.connect('mongodb://localhost/test');
var UserSchema  = new mongoose.Schema({
  salt  : String,
  hash  : String
});

var User = mongoose.model('User', UserSchema);

hash('secret', function(err, salt, key) {
  new User({ salt : salt, hash : key.toString('hex') }).save(function(err, doc) {
    User.findById(doc._id, function(err, doc) {
      hash('secret', doc.salt, function(err, key) {
        console.log('eq', doc.hash === key.toString('hex'));
      });
    });
  });
});

（顺便说一下，crypto.pbkdf2和crypto.randomBytes都有同步对应物）

如何在mongoDB中存储crypto pbkdf2？

1 个答案: