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




express http-authentication (7)

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

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

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

ऐसा लगता है कि एक्सप्रेस वी 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!
}));

मैंने जवाब खोजने के लिए मूल basicAuth के लिए कोड का उपयोग किया:

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

    if (user === undefined || user['name'] !== 'username' || user['pass'] !== 'password') {
        res.statusCode = 401;
        res.setHeader('WWW-Authenticate', 'Basic realm="MyRealmName"');
        res.end('Unauthorized');
    } else {
        next();
    }
});

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

//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


मैं एक्सप्रेस 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);

वेनिला जावास्क्रिप्ट (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 पुस्तकालय पुस्तकालय का उपयोग करने की सलाह देता है।

यहां उपयोग करने का एक उदाहरण दिया गया है:

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

// Create server
var server = http.createServer(function (req, res) {
  var credentials = auth(req)

  if (!credentials || credentials.name !== 'aladdin' || credentials.pass !== 'opensesame') {
    res.statusCode = 401
    res.setHeader('WWW-Authenticate', 'Basic realm="example"')
    res.end('Access denied')
  } else {
    res.end('Access granted')
  }
})

// Listen
server.listen(3000)

इस रूट के लिए अनुरोध भेजने के लिए आपको बुनियादी लेख के लिए स्वरूपित प्राधिकरण शीर्षलेख शामिल करना होगा।

पहले एक कर्ल अनुरोध भेजना आपको name:pass के आधार base64 एन्कोडिंग लेना होगा name:pass या इस मामले में aladdin:opensesame जो aladdin:opensesame बराबर है

आपका कर्ल अनुरोध तब दिखेगा:

 curl -H "Authorization: Basic YWxhZGRpbjpvcGVuc2VzYW1l" http://localhost:3000/






http-authentication