Die Implementierung der grundlegenden HTTP-Authentifizierung mit Express v3 war anscheinend trivial:

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

Version 4 (ich verwende 4.2) hat die basicAuthMiddleware jedoch entfernt, sodass ich ein wenig festgefahren bin. Ich habe den folgenden Code, aber er veranlasst den Browser nicht, den Benutzer zur Eingabe von Anmeldeinformationen aufzufordern. Dies ist das, was ich möchte (und was ich mir bei der alten Methode vorstelle):

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();
    }
});

Einfache Basisauthentifizierung mit Vanille-JavaScript (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] = Buffer.from(b64auth, 'base64').toString().split(':')

  // Verify login and password are set and correct
  if (login && password && login === auth.login && password === auth.password) {
    // Access granted...
    return next()
  }

  // Access denied...
  res.set('WWW-Authenticate', 'Basic realm="401"') // change this
  res.status(401).send('Authentication required.') // custom message

  // -----------------------------------------------------------------------

})

_{Hinweis: Diese "Middleware" kann in jedem Handler verwendet werden. Entfernen Sie einfach next()die Logik und kehren Sie sie um. Siehe das folgende Beispiel mit 1 Anweisung oder den Bearbeitungsverlauf dieser Antwort.}

Warum?

• req.headers.authorizationenthält den Wert " Basic <base64 string>", kann aber auch leer sein und wir möchten nicht, dass er fehlschlägt, daher die seltsame Kombination von|| ''
• Knoten weiß es nicht atob()und btoa()daher derBuffer

ES6 -> ES5

const ist nur var .. Art
(x, y) => {...}ist nur function(x, y) {...}
const [login, password] = ...split()ist nur zwei varAufgaben in einer

Inspirationsquelle (verwendet Pakete)

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

  // using shorter regex by @adabru
  // const [_, login, password] = strauth.match(/(.*?):(.*)/) || []

Grundlegende Authentifizierung in einer Anweisung

... auf der anderen Seite, wenn Sie immer nur eine oder sehr wenige Anmeldungen verwenden, ist dies das absolute Minimum, das Sie benötigen: (Sie müssen die Anmeldeinformationen überhaupt nicht analysieren)

function (req, res) {
//btoa('yourlogin:yourpassword') -> "eW91cmxvZ2luOnlvdXJwYXNzd29yZA=="
//btoa('otherlogin:otherpassword') -> "b3RoZXJsb2dpbjpvdGhlcnBhc3N3b3Jk"

  // Verify credentials
  if (  req.headers.authorization !== 'Basic eW91cmxvZ2luOnlvdXJwYXNzd29yZA=='
     && req.headers.authorization !== 'Basic b3RoZXJsb2dpbjpvdGhlcnBhc3N3b3Jk')        
    return res.status(401).send('Authentication required.') // Access denied.   

  // Access granted...
  res.send('hello world')
  // or call next() if you use it as middleware (as snippet #1)
}

PS: Müssen Sie sowohl "sichere" als auch "öffentliche" Pfade haben? Verwenden Sie express.routerstattdessen.

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

TL; DR:

☒ express.basicAuthist weg
☒ basic-auth-connectist veraltet
☒ basic-authhat keine Logik
☒ http-authist ein Overkill
☑ express-basic-authist was du willst

Mehr Info:

Da Sie Express verwenden, können Sie die express-basic-authMiddleware verwenden.

Siehe die Dokumente:

• https://www.npmjs.com/package/express-basic-auth

Beispiel:

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!
}));

Ein Großteil der Middleware wurde in Version 4 aus dem Express-Kern gezogen und in separate Module integriert. Das grundlegende Authentifizierungsmodul finden Sie hier: https://github.com/expressjs/basic-auth-connect

Ihr Beispiel müsste nur Folgendes ändern:

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

Ich habe den Code für das Original verwendet basicAuth, um die Antwort zu finden:

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();
    }
});

Ich habe in Express 4.0 die Basisauthentifizierung mit http-auth geändert , der Code lautet:

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);

Dafür scheint es mehrere Module zu geben, einige sind veraltet.

Dieser sieht aktiv aus:
https://github.com/jshttp/basic-auth

Hier ist ein Anwendungsbeispiel:

// auth.js

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

var admins = {
  'art@vandelay-ind.org': { 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

Stellen Sie sicher, dass Sie die authMiddleware an der richtigen Stelle platzieren. Alle zuvor vorhandenen Middleware werden nicht authentifiziert.

Wir können die Grundberechtigung implementieren, ohne ein Modul zu benötigen

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

Quelle: - http://www.dotnetcurry.com/nodejs/1231/basic-authentication-using-nodejs

Express hat diese Funktionalität entfernt und empfiehlt nun die Verwendung der Basic-Auth- Bibliothek.

Hier ist ein Beispiel für die Verwendung:

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)

Um eine Anfrage an diese Route zu senden, müssen Sie einen Autorisierungsheader einfügen, der für die Basisauthentifizierung formatiert ist.

Wenn Sie zuerst eine Curl-Anfrage senden, müssen Sie die Base64- Codierung von name:passoder in diesem Fall aladdin:opensesamegleich verwendenYWxhZGRpbjpvcGVuc2VzYW1l

Ihre Curl-Anfrage sieht dann so aus:

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

function auth (req, res, next) {
  console.log(req.headers);
  var authHeader = req.headers.authorization;
  if (!authHeader) {
      var err = new Error('You are not authenticated!');
      res.setHeader('WWW-Authenticate', 'Basic');
      err.status = 401;
      next(err);
      return;
  }
  var auth = new Buffer.from(authHeader.split(' ')[1], 'base64').toString().split(':');
  var user = auth[0];
  var pass = auth[1];
  if (user == 'admin' && pass == 'password') {
      next(); // authorized
  } else {
      var err = new Error('You are not authenticated!');
      res.setHeader('WWW-Authenticate', 'Basic');      
      err.status = 401;
      next(err);
  }
}
app.use(auth);