node.js - नोड और एक्सप्रेस 4 के साथ मूल HTTP प्रमाणीकरण




express http-authentication (6)

ऐसा लगता है कि एक्सप्रेस वी 3 के साथ मूल HTTP प्रमाणीकरण लागू करना छोटा था:

app.use(express.basicAuth('username', 'password'));

संस्करण 4 (मैं 4.2 का उपयोग कर रहा हूं) basicAuth मिडलवेयर हटा दिया, हालांकि, मैं थोड़ा फंस गया हूँ। मेरे पास निम्न कोड है, लेकिन यह ब्राउज़र को उपयोगकर्ता को क्रेडेंशियल्स के लिए संकेत नहीं देता है, जो मैं चाहता हूं (और जो मैंने पुरानी विधि की कल्पना की थी):

app.use(function(req, res, next) {
    var user = auth(req);

    if (user === undefined || user['name'] !== 'username' || user['pass'] !== 'password') {
        res.writeHead(401, 'Access invalid for user', {'Content-Type' : 'text/plain'});
        res.end('Invalid credentials');
    } else {
        next();
    }
});

टी एल; डॉ:

express.basicAuth चला गया है
basic-auth-connect को बहिष्कृत किया गया है
basic-auth में कोई तर्क नहीं है
http-auth एक ओवरकिल है
express-basic-auth वह है जो आप चाहते हैं

और जानकारी:

चूंकि आप एक्सप्रेस का उपयोग कर रहे हैं तो आप express-basic-auth मिडलवेयर का उपयोग कर सकते हैं।

दस्तावेज़ देखें:

उदाहरण:

const app = require('express')();
const basicAuth = require('express-basic-auth');

app.use(basicAuth({
    users: { admin: 'supersecret123' },
    challenge: true // <--- needed to actually show the login dialog!
}));

वेनिला जावास्क्रिप्ट (ES6) के साथ सरल बेसिक ऑथ

app.use((req, res, next) => {

  // -----------------------------------------------------------------------
  // authentication middleware

  const auth = {login: 'yourlogin', password: 'yourpassword'} // change this

  // parse login and password from headers
  const b64auth = (req.headers.authorization || '').split(' ')[1] || ''
  const [login, password] = new Buffer(b64auth, 'base64').toString().split(':')

  // Verify login and password are set and correct
  if (!login || !password || login !== auth.login || password !== auth.password) {
    res.set('WWW-Authenticate', 'Basic realm="401"') // change this
    res.status(401).send('Authentication required.') // custom message
    return
  }

  // -----------------------------------------------------------------------
  // Access granted...
  next()

})

क्यूं कर?

  • req.headers.authorization में " Basic <base64 string> " मान होता है, लेकिन यह खाली भी हो सकता है और हम इसे असफल नहीं करना चाहते हैं, इसलिए अजीब कॉम्बो || '' || ''
  • नोड atob() और btoa() , इसलिए Buffer नहीं जानता है

ES6 -> ES5

const सिर्फ var .. प्रकार है
(x, y) => {...} बस function(x, y) {...}
const [login, password] = ...split() एक में केवल दो var असाइनमेंट है

प्रेरणा का स्रोत (पैकेज का उपयोग करता है)

उपर्युक्त एक सुपर सरल उदाहरण है जिसका उद्देश्य आपके खेल के मैदान सर्वर पर सुपर शॉर्ट और जल्दी से तैनाती योग्य होना था। लेकिन जैसा टिप्पणियों में बताया गया था, पासवर्ड में कोलन वर्ण भी हो सकते हैं:। B64auth से इसे सही तरीके से निकालने के लिए, आप इसका उपयोग कर सकते हैं।

  // parse login and password from headers
  const b64auth = (req.headers.authorization || '').split(' ')[1] || ''
  const strauth = new Buffer(b64auth, 'base64').toString()
  const splitIndex = strauth.indexOf(':')
  const login = strauth.substring(0, splitIndex)
  const password = strauth.substring(splitIndex + 1)

दूसरी ओर, यदि आप केवल एक या बहुत कम लॉग इन का उपयोग करते हैं, तो यह न्यूनतम न्यूनतम आवश्यकता है:
(आपको प्रमाण-पत्रों को पार्स करने की आवश्यकता नहीं है)

//btoa('yourlogin:yourpassword') -> "eW91cmxvZ2luOnlvdXJwYXNzd29yZA=="

// Verify login and password is correct
if (req.headers.authorization !== 'Basic eW91cmxvZ2luOnlvdXJwYXNzd29yZA==') {
  // ...send('Authentication required.')
  return
}

बीटीडब्लू, क्या आपको सुरक्षित और "सार्वजनिक" दोनों पथ रखने की ज़रूरत है? इसके बजाय express.router का उपयोग करने पर विचार करें।

var securedRoutes = require('express').Router()

securedRoutes.use(/* auth-middleware from above */)
securedRoutes.get('path1', /* ... */) 

app.use('/secure', securedRoutes)
app.get('public', /* ... */)

// example.com/public       // no-auth
// example.com/secure/path1 // requires auth

ऐसा करने के लिए कई मॉड्यूल प्रतीत होते हैं, कुछ को बहिष्कृत किया जाता है।

यह सक्रिय दिखता है:
jshttp/basic-auth

यहां एक उदाहरण उदाहरण है:

// auth.js

var auth = require('basic-auth');

var admins = {
  '[email protected]': { password: 'pa$$w0rd!' },
};


module.exports = function(req, res, next) {

  var user = auth(req);
  if (!user || !admins[user.name] || admins[user.name].password !== user.pass) {
    res.set('WWW-Authenticate', 'Basic realm="example"');
    return res.status(401).send();
  }
  return next();
};




// app.js

var auth = require('./auth');
var express = require('express');

var app = express();

// ... some not authenticated middlewares

app.use(auth);

// ... some authenticated middlewares

सुनिश्चित करें कि आपने सही जगह पर auth मिडलवेयर डाला है, इससे पहले कि कोई भी मिडलवेयर प्रमाणीकृत नहीं होगा।


मैं एक्सप्रेस 4.0 में http-auth साथ मूल प्रमाणीकरण में बदल गया, कोड है:

var auth = require('http-auth');

var basic = auth.basic({
        realm: "Web."
    }, function (username, password, callback) { // Custom authentication method.
        callback(username === "userName" && password === "password");
    }
);

app.get('/the_url', auth.connect(basic), routes.theRoute);

वी 4 में एक्सप्रेस कोर से बहुत सारे मिडलवेयर निकाले गए थे, और अलग मॉड्यूल में डाल दिए गए थे। मूल ऑथ मॉड्यूल यहां है: https://github.com/expressjs/basic-auth-connect

आपका उदाहरण सिर्फ इसमें बदलना होगा:

var basicAuth = require('basic-auth-connect');
app.use(basicAuth('username', 'password'));

हम किसी भी मॉड्यूल की आवश्यकता के बिना मूल प्राधिकरण को लागू कर सकते हैं

//1.
var http = require('http');

//2.
var credentials = {
    userName: "vikas kohli",
    password: "vikas123"
};
var realm = 'Basic Authentication';

//3.
function authenticationStatus(resp) {
    resp.writeHead(401, { 'WWW-Authenticate': 'Basic realm="' + realm + '"' });
    resp.end('Authorization is needed');

};

//4.
var server = http.createServer(function (request, response) {
    var authentication, loginInfo;

    //5.
    if (!request.headers.authorization) {
        authenticationStatus (response);
        return;
    }

    //6.
    authentication = request.headers.authorization.replace(/^Basic/, '');

    //7.
    authentication = (new Buffer(authentication, 'base64')).toString('utf8');

    //8.
    loginInfo = authentication.split(':');

    //9.
    if (loginInfo[0] === credentials.userName && loginInfo[1] === credentials.password) {
        response.end('Great You are Authenticated...');
         // now you call url by commenting the above line and pass the next() function
    }else{

    authenticationStatus (response);

}

});
 server.listen(5050);

स्रोत: - http://www.dotnetcurry.com/nodejs/1231/basic-authentication-using-nodejs







http-authentication