Parece que implementar la autenticación HTTP básica con Express v3 fue trivial:

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

Sin basicAuthembargo, la versión 4 (estoy usando 4.2) eliminó el middleware, así que estoy un poco atascado. Tengo el siguiente código, pero no hace que el navegador solicite al usuario las credenciales, que es lo que me gustaría (y lo que imagino que hizo el método anterior):

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

Autenticación básica simple con JavaScript vainilla (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

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

})

_{nota: este "middleware" se puede utilizar en cualquier controlador. Simplemente elimine next()e invierta la lógica. Vea el ejemplo de 1 declaración a continuación o el historial de edición de esta respuesta.}

¿Por qué?

• req.headers.authorizationcontiene el valor " Basic <base64 string>", pero también puede estar vacío y no queremos que falle, de ahí la extraña combinación de|| ''
• El nodo no lo sabe atob()y btoa(), por lo tanto, elBuffer

ES6 -> ES5

constes var... más
(x, y) => {...}o menos function(x, y) {...}
const [login, password] = ...split()es solo dos vartareas en una

fuente de inspiración (usa paquetes)

  // 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(/(.*?):(.*)/) || []

Autenticación básica en una declaración

... por otro lado, si solo usa uno o muy pocos inicios de sesión, este es el mínimo que necesita: (ni siquiera necesita analizar las credenciales)

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

PD: ¿necesita tener rutas "seguras" y "públicas"? Considere usar en su express.routerlugar.

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.basicAuthse ha ido
☒ basic-auth-connectestá en desuso
☒ basic-authno tiene ninguna lógica
☒ http-authes una exageración
☑ express-basic-authes lo que quieres

Más información:

Como está utilizando Express, puede utilizar el express-basic-authmiddleware.

Ver los documentos:

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

Ejemplo:

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

Gran parte del middleware se extrajo del núcleo Express en v4 y se colocó en módulos separados. El módulo de autenticación básico está aquí: https://github.com/expressjs/basic-auth-connect

Su ejemplo solo necesitaría cambiar a esto:

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

Usé el código del original basicAuthpara encontrar la respuesta:

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

Cambié en express 4.0 la autenticación básica con http-auth , el código es:

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

Parece que hay varios módulos para hacer eso, algunos están en desuso.

Este parece activo:
https://github.com/jshttp/basic-auth

Aquí hay un ejemplo de uso:

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

Asegúrese de colocar el authmiddleware en el lugar correcto, cualquier middleware anterior no será autenticado.

Podemos implementar la autorización básica sin necesidad de ningún módulo

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

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

Express ha eliminado esta funcionalidad y ahora le recomienda utilizar la biblioteca de autenticación básica .

Aquí hay un ejemplo de cómo usarlo:

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)

Para enviar una solicitud a esta ruta, debe incluir un encabezado de autorización con el formato de autenticación básica.

Al enviar una solicitud curl primero, debe tomar la codificación base64 de name:passo, en este caso, aladdin:opensesameque es igual aYWxhZGRpbjpvcGVuc2VzYW1l

Su solicitud de curl se verá así:

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