มีไลบรารีการพิสูจน์ตัวตนผู้ใช้ที่มีอยู่สำหรับ node.js หรือไม่? โดยเฉพาะฉันกำลังมองหาบางอย่างที่สามารถทำการตรวจสอบรหัสผ่านสำหรับผู้ใช้ (ใช้ฐานข้อมูลรับรองความถูกต้องที่กำหนดเอง) และเชื่อมโยงผู้ใช้นั้นกับเซสชัน

ก่อนที่ฉันจะเขียนห้องสมุดรับรองความถูกต้องฉันคิดว่าฉันจะรู้ว่าคนรู้จักห้องสมุดที่มีอยู่หรือไม่ ไม่พบสิ่งที่ชัดเจนผ่านการค้นหาของ Google

-Shreyas

หากคุณกำลังมองหาเฟรมเวิร์กการรับรองความถูกต้องสำหรับ Connect หรือ Express Passport นั้นคุ้มค่าที่จะตรวจสอบ: https://github.com/jaredhanson/passport

(การเปิดเผยข้อมูล: ฉันเป็นผู้พัฒนา Passport)

ฉันพัฒนา Passport หลังจากตรวจสอบทั้ง connect-auth และ everyauth แม้ว่าพวกเขาจะเป็นทั้งโมดูลที่ยอดเยี่ยม แต่ก็ไม่เหมาะกับความต้องการของฉัน ฉันต้องการบางสิ่งที่มีน้ำหนักเบากว่าและไม่เป็นการรบกวน

Passport ถูกแบ่งออกเป็นโมดูลที่แยกต่างหากดังนั้นคุณสามารถเลือกใช้เฉพาะสิ่งที่คุณต้องการ (OAuth เฉพาะในกรณีที่จำเป็น) Passport ยังไม่เมานต์เส้นทางใด ๆ ในแอปพลิเคชันของคุณทำให้คุณมีความยืดหยุ่นในการตัดสินใจว่าคุณต้องการรับรองความถูกต้องเมื่อใดและที่ไหนและขอให้ควบคุมสิ่งที่เกิดขึ้นเมื่อการรับรองความถูกต้องสำเร็จหรือล้มเหลว

ตัวอย่างเช่นต่อไปนี้เป็นกระบวนการสองขั้นตอนในการตั้งค่าการรับรองความถูกต้องแบบฟอร์ม (ชื่อผู้ใช้และรหัสผ่าน):

passport.use(new LocalStrategy(
  function(username, password, done) {
    // Find the user from your DB (MongoDB, CouchDB, other...)
    User.findOne({ username: username, password: password }, function (err, user) {
      done(err, user);
    });
  }
));

app.post('/login', 
  passport.authenticate('local', { failureRedirect: '/login' }),
  function(req, res) {
    // Authentication successful. Redirect home.
    res.redirect('/');
  });

สามารถใช้กลยุทธ์เพิ่มเติมสำหรับการตรวจสอบสิทธิ์ผ่าน Facebook, Twitter และอื่น ๆ กลยุทธ์ที่กำหนดเองสามารถเชื่อมต่อได้หากจำเป็น

เซสชัน + ถ้า

ฉันคิดว่าเหตุผลที่คุณไม่พบห้องสมุดที่ดีจำนวนมากคือการใช้ห้องสมุดสำหรับการตรวจสอบความถูกต้องส่วนใหญ่เป็นวิศวกรรม

สิ่งที่คุณกำลังมองหาเป็นเพียงแค่ session-binder :) เซสชันที่มี:

if login and user == xxx and pwd == xxx 
   then store an authenticated=true into the session 
if logout destroy session

แค่นั้นแหละ.

ฉันไม่เห็นด้วยกับข้อสรุปของคุณว่าปลั๊กอินการเชื่อมต่อรับรองความถูกต้องเป็นวิธีที่จะไป

ฉันใช้การเชื่อมต่อด้วยแต่ฉันไม่ได้ใช้การเชื่อมต่อรับรองความถูกต้องด้วยเหตุผลสองประการ:

1. IMHO แบ่งการเชื่อมต่อรับรองความถูกต้องของสถาปัตยกรรมหัวหอมที่มีประสิทธิภาพและอ่านง่ายของการเชื่อมต่อ A no-go - ความคิดเห็นของฉัน :) คุณสามารถค้นหาบทความที่ดีมากและสั้น ๆ เกี่ยวกับงานวิธีการเชื่อมต่อและความคิดแหวนหอมที่นี่

2. หากคุณ - ตามที่เขียน - เพียงต้องการใช้การเข้าสู่ระบบพื้นฐานหรือ http กับฐานข้อมูลหรือไฟล์ การเชื่อมต่อรับรองความถูกต้องใหญ่เกินไป มันมีประโยชน์มากกว่าสำหรับ OAuth 1.0, OAuth 2.0 & Co

การรับรองความถูกต้องง่าย ๆ ด้วยการเชื่อมต่อ

(มันเสร็จสมบูรณ์เพียงแค่เรียกใช้สำหรับการทดสอบ แต่ถ้าคุณต้องการที่จะใช้ในการผลิตให้ใช้ https) (และเพื่อให้เป็นไปตามหลักการ REST-Principle-Compliant คุณควรใช้ POST-Request แทน GET-Request b / c คุณเปลี่ยนสถานะ :)

var connect = require('connect');
var urlparser = require('url');

var authCheck = function (req, res, next) {
    url = req.urlp = urlparser.parse(req.url, true);

    // ####
    // Logout
    if ( url.pathname == "/logout" ) {
      req.session.destroy();
    }

    // ####
    // Is User already validated?
    if (req.session && req.session.auth == true) {
      next(); // stop here and pass to the next onion ring of connect
      return;
    }

    // ########
    // Auth - Replace this example with your Database, Auth-File or other things
    // If Database, you need a Async callback...
    if ( url.pathname == "/login" && 
         url.query.name == "max" && 
         url.query.pwd == "herewego"  ) {
      req.session.auth = true;
      next();
      return;
    }

    // ####
    // This user is not authorized. Stop talking to him.
    res.writeHead(403);
    res.end('Sorry you are not authorized.\n\nFor a login use: /login?name=max&pwd=herewego');
    return;
}

var helloWorldContent = function (req, res, next) {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('authorized. Walk around :) or use /logout to leave\n\nYou are currently at '+req.urlp.pathname);
}

var server = connect.createServer(
      connect.logger({ format: ':method :url' }),
      connect.cookieParser(),
      connect.session({ secret: 'foobar' }),
      connect.bodyParser(),
      authCheck,
      helloWorldContent
);

server.listen(3000);

บันทึก

ฉันเขียนคำสั่งนี้เมื่อปีที่แล้วและขณะนี้ไม่มีโครงการโหนดที่ใช้งานอยู่ ดังนั้นอาจมีการเปลี่ยนแปลง API ใน Express กรุณาเพิ่มความคิดเห็นหากฉันควรจะเปลี่ยนแปลงอะไร

ดูเหมือนว่าปลั๊กอินการเชื่อมต่อรับรองความถูกต้องกับการเชื่อมต่อมิดเดิลแวร์เป็นสิ่งที่ฉันต้องการ: http://wiki.github.com/ciaranj/connect-auth/creating-a-form-based-strategy

ฉันใช้ express [ http://expressjs.com ] ดังนั้นปลั๊กอินเชื่อมต่อจึงเข้ากันได้เป็นอย่างดีเนื่องจาก express นั้นมีคลาสย่อย (ok - prototyped) จากการเชื่อมต่อ

โดยพื้นฐานแล้วฉันกำลังมองหาสิ่งเดียวกัน โดยเฉพาะฉันต้องการสิ่งต่อไปนี้:

1. หากต้องการใช้ express.js ซึ่งตัดความสามารถมิดเดิลแวร์ของ Connect
2. การรับรองความถูกต้อง "ตามรูปแบบ"
3. ควบคุมรายละเอียดของเส้นทางที่รับรองความถูกต้อง
4. ฐานข้อมูลส่วนหลังสำหรับผู้ใช้ / รหัสผ่าน
5. ใช้เซสชัน

สิ่งที่ฉันทำคือการสร้างฟังก์ชั่นมิดเดิลแวร์ของตัวเองcheck_authที่ฉันผ่านเป็นข้อโต้แย้งไปยังแต่ละเส้นทางที่ฉันต้องการรับรองความถูกต้อง check_authเพียงตรวจสอบเซสชั่นและหากผู้ใช้ไม่ได้เข้าสู่ระบบแล้วเปลี่ยนเส้นทางพวกเขาไปที่หน้าเข้าสู่ระบบเช่นโดย:

function check_auth(req, res, next) {

  //  if the user isn't logged in, redirect them to a login page
  if(!req.session.login) {
    res.redirect("/login");
    return; // the buck stops here... we do not call next(), because
            // we don't want to proceed; instead we want to show a login page
  }

  //  the user is logged in, so call next()
  next();
}

สำหรับแต่ละเส้นทางฉันแน่ใจว่าฟังก์ชั่นนี้ผ่านเป็นมิดเดิลแวร์ ตัวอย่างเช่น:

app.get('/tasks', check_auth, function(req, res) {
    // snip
});

สุดท้ายเราต้องจัดการกระบวนการเข้าสู่ระบบจริง ตรงไปตรงมา:

app.get('/login', function(req, res) {
  res.render("login", {layout:false});
});

app.post('/login', function(req, res) {

  // here, I'm using mongoose.js to search for the user in mongodb
  var user_query = UserModel.findOne({email:req.body.email}, function(err, user){
    if(err) {
      res.render("login", {layout:false, locals:{ error:err } });
      return;
    }

    if(!user || user.password != req.body.password) {
      res.render("login",
        {layout:false,
          locals:{ error:"Invalid login!", email:req.body.email }
        }
      );
    } else {
      // successful login; store the session info
      req.session.login = req.body.email;
      res.redirect("/");
    }
  });
});

อย่างไรก็ตามวิธีการนี้ส่วนใหญ่ได้รับการออกแบบให้มีความยืดหยุ่นและเรียบง่าย ฉันแน่ใจว่ามีวิธีมากมายในการปรับปรุง หากคุณมีฉันต้องการความคิดเห็นของคุณ

แก้ไข: นี่คือตัวอย่างที่ง่าย ในระบบที่ใช้งานจริงคุณไม่ต้องการจัดเก็บและเปรียบเทียบรหัสผ่านเป็นข้อความธรรมดา ในฐานะที่เป็นผู้แสดงความคิดเห็นชี้ให้เห็นว่ามี libs ที่สามารถช่วยจัดการความปลอดภัยของรหัสผ่าน

ดูทุก ๆ อย่างถ้าคุณต้องการการรวมเข้าสู่ระบบเครือข่ายบุคคล / สังคมออนไลน์

นี่คือรหัสสำหรับการรับรองความถูกต้องเบื้องต้นจากหนึ่งในโครงการของฉัน ฉันใช้กับ CouchDB ด้วยและแคชข้อมูลเพิ่มเติมรับรองความถูกต้อง แต่ฉันถอดรหัสนั้น

ล้อมรอบวิธีการตรวจสอบความถูกต้องรอบตัวคุณเพื่อขอการจัดการและจัดเตรียมการติดต่อกลับเป็นครั้งที่สอง การโทรกลับสำเร็จจะได้รับชื่อผู้ใช้เป็นพารามิเตอร์เพิ่มเติม อย่าลืมจัดการคำขอด้วยข้อมูลประจำตัวที่ผิดหรือขาดหายไปในการติดต่อกลับที่ล้มเหลว:

/**
 * Authenticate a request against this authentication instance.
 * 
 * @param request
 * @param failureCallback
 * @param successCallback
 * @return
 */
Auth.prototype.authenticate = function(request, failureCallback, successCallback)
{
    var requestUsername = "";
    var requestPassword = "";
    if (!request.headers['authorization'])
    {
        failureCallback();
    }
    else
    {
        var auth = this._decodeBase64(request.headers['authorization']);
        if (auth)
        {
            requestUsername = auth.username;
            requestPassword = auth.password;
        }
        else
        {
            failureCallback();
        }
    }


    //TODO: Query your database (don't forget to do so async)


    db.query( function(result)
    {
        if (result.username == requestUsername && result.password == requestPassword)
        {
            successCallback(requestUsername);
        }
        else
        {
            failureCallback();
        }
    });

};


/**
 * Internal method for extracting username and password out of a Basic
 * Authentication header field.
 * 
 * @param headerValue
 * @return
 */
Auth.prototype._decodeBase64 = function(headerValue)
{
    var value;
    if (value = headerValue.match("^Basic\\s([A-Za-z0-9+/=]+)$"))
    {
        var auth = (new Buffer(value[1] || "", "base64")).toString("ascii");
        return {
            username : auth.slice(0, auth.indexOf(':')),
            password : auth.slice(auth.indexOf(':') + 1, auth.length)
        };
    }
    else
    {
        return null;
    }

};

การรับรองความถูกต้องที่แตกต่างกันคือรหัสผ่านซึ่งเป็นโมดูลการตรวจสอบความถูกต้องของโทเค็นสำหรับการส่งผ่านซึ่งเป็นการหลีกเลี่ยงปัญหาที่เกิดจากรหัสผ่าน [1] มันใช้งานได้อย่างรวดเร็วไม่จำเป็นต้องมีรูปแบบมากเกินไปและให้ความปลอดภัยที่ดีขึ้นสำหรับผู้ใช้โดยเฉลี่ย (การเปิดเผยอย่างเต็มรูปแบบ: ฉันเป็นผู้เขียน)

[1]: รหัสผ่านล้าสมัย

ไม่กี่ปีที่ผ่านมาและฉันต้องการแนะนำวิธีตรวจสอบสิทธิ์สำหรับ Express มันเรียกว่าLockit คุณสามารถค้นหาโครงการGitHubและแนะนำสั้น ๆ ที่บล็อกของฉัน

ดังนั้นอะไรคือความแตกต่างของโซลูชั่นที่มีอยู่

• ง่ายต่อการใช้: การตั้งค่าฐานข้อมูลของคุณ NPM ติดตั้งrequire('lockit'), lockit(app)ทำ
• เส้นทางที่มีอยู่แล้วภายใน (/ สมัครสมาชิก / เข้าสู่ระบบ / ลืมรหัสผ่าน ฯลฯ )
• มุมมองที่มีอยู่แล้วในตัว (ขึ้นอยู่กับ Bootstrap แต่คุณสามารถใช้มุมมองของคุณเองได้อย่างง่ายดาย)
• รองรับการสื่อสาร JSON สำหรับแอปหน้าเดียวของ AngularJS / Ember.js
• ไม่รองรับ OAuth และ OpenID เท่านั้นและusernamepassword
• มันทำงานได้กับฐานข้อมูลหลายแห่ง (CouchDB, MongoDB, SQL) นอกกรอบ
• มันมีการทดสอบ (ฉันไม่พบการทดสอบใด ๆ สำหรับ Drywall)
• มันได้รับการบำรุงรักษาอย่างแข็งขัน (เทียบกับทุก ๆ อย่าง)
• การยืนยันอีเมลและกระบวนการลืมรหัสผ่าน (ส่งอีเมลด้วยโทเค็นไม่รองรับ Passport)
• ต้นแบบ: ใช้เฉพาะสิ่งที่คุณต้องการ
• ความยืดหยุ่น: ปรับแต่งทุกสิ่ง

ลองดูที่เป็นตัวอย่าง

มีโครงการที่ชื่อว่าDrywallที่ใช้ระบบเข้าสู่ระบบของผู้ใช้กับPassportและยังมีแผงการจัดการผู้ใช้ หากคุณกำลังมองหาระบบรับรองความถูกต้องและการจัดการผู้ใช้ที่มีคุณสมบัติครบถ้วนคล้ายกับสิ่งที่ Django มี แต่สำหรับ Node.js นี่คือสิ่งนี้ ฉันพบว่ามันเป็นจุดเริ่มต้นที่ดีมากสำหรับการสร้างแอปโหนดที่ต้องใช้การรับรองความถูกต้องของผู้ใช้และระบบการจัดการ ดูคำตอบของ Jared Hansonสำหรับข้อมูลว่า Passport ทำงานอย่างไร

นี่คือสองไลบรารี Github ยอดนิยมสำหรับการพิสูจน์ตัวตนของโหนด js:

https://github.com/jaredhanson/passport (แนะนำ)

https://nodejsmodules.org/pkg/everyauth

ตัวอย่างง่ายๆอย่างรวดเร็วโดยใช้ mongo สำหรับ API ที่ให้ผู้ใช้รับรองความถูกต้องเช่น Angular client

ใน app.js

var express = require('express');
var MongoStore = require('connect-mongo')(express);

// ...

app.use(express.cookieParser());
// obviously change db settings to suit
app.use(express.session({
    secret: 'blah1234',
    store: new MongoStore({
        db: 'dbname',
        host: 'localhost',
        port: 27017
    })
}));

app.use(app.router);

สำหรับเส้นทางของคุณบางอย่างเช่นนี้:

// (mongo connection stuff)

exports.login = function(req, res) {

    var email = req.body.email;
    // use bcrypt in production for password hashing
    var password = req.body.password;

    db.collection('users', function(err, collection) {
        collection.findOne({'email': email, 'password': password}, function(err, user) {
            if (err) {
                res.send(500);
            } else {
                if(user !== null) {
                    req.session.user = user;
                    res.send(200);
                } else {
                    res.send(401);
                }
            }
        });
    });
};

จากนั้นในเส้นทางของคุณที่ต้องการการรับรองความถูกต้องคุณสามารถตรวจสอบเซสชันผู้ใช้ได้:

if (!req.session.user) {
    res.send(403);
}

นี่คือไลบรารีการพิสูจน์ตัวตนใหม่ที่ใช้โทเค็นการประทับเวลา โทเค็นสามารถส่งอีเมลหรือส่งข้อความถึงผู้ใช้โดยไม่จำเป็นต้องเก็บไว้ในฐานข้อมูล สามารถใช้สำหรับการพิสูจน์ตัวตนด้วยรหัสผ่านหรือสำหรับการพิสูจน์ตัวตนแบบสองปัจจัย

https://github.com/vote539/easy-no-password

การเปิดเผยข้อมูล: ฉันเป็นผู้พัฒนาห้องสมุดนี้

หากคุณต้องการการรับรองความถูกต้องด้วย SSO (Single Sign On) ด้วยบัญชีผู้ใช้ Microsoft Windows คุณอาจจะให้ลองไปhttps://github.com/jlguenego/node-expose-sspi

มันจะให้req.ssoวัตถุที่มีข้อมูลผู้ใช้ของลูกค้าทั้งหมด (เข้าสู่ระบบชื่อที่แสดง sid กลุ่ม)

const express = require("express");
const { sso, sspi } = require("node-expose-sspi");

sso.config.debug = false;

const app = express();

app.use(sso.auth());

app.use((req, res, next) => {
  res.json({
    sso: req.sso
  });
});

app.listen(3000, () => console.log("Server started on port 3000"));

ข้อจำกัดความรับผิดชอบ: ฉันเป็นผู้แต่ง node-expose-sspi

หวานรับรองความถูกต้อง

โมดูลการพิสูจน์ตัวตนผู้ใช้ที่มีน้ำหนักเบาและไม่เป็นศูนย์ มันไม่ต้องการฐานข้อมูลแบบกระจาย

https://www.npmjs.com/package/sweet-auth

ง่ายเหมือน:

app.get('/private-page', (req, res) => {

    if (req.user.isAuthorized) {
        // user is logged in! send the requested page
        // you can access req.user.email
    }
    else {
        // user not logged in. redirect to login page
    }
})