Autenticação HTTP básica com Node e Express 4

107

Parece que implementar a autenticação HTTP básica com Express v3 era trivial:

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

A versão 4 (estou usando a 4.2) removeu o basicAuthmiddleware, então estou um pouco preso. Eu tenho o seguinte código, mas não faz com que o navegador solicite ao usuário as credenciais, que é o que eu gostaria (e o que imagino que o método antigo fizesse):

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();
    }
});
Dov
fonte
2
Plugue sem vergonha: mantenho um módulo bastante popular que torna isso fácil e tem a maioria dos recursos padrão de que você precisa: express-basic-auth
LionC
Recentemente fiz um fork do pacote da @LionC porque tive que adaptá-lo (habilitando os autorizadores cientes do contexto) em um espaço de tempo ultracurto
castarco

Respostas:

108

Autenticação básica simples com JavaScript vanilla (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" pode ser usado em qualquer manipulador. Basta remover next()e inverter a lógica. Veja o exemplo de 1 afirmação abaixo ou o histórico de edição desta resposta.

Por quê?

  • req.headers.authorizationcontém o valor " Basic <base64 string>", mas também pode estar vazio e não queremos que falhe, daí a estranha combinação de|| ''
  • Node não sabe atob()e btoa(), portanto, oBuffer

ES6 -> ES5

consté apenas var.. tipo de
(x, y) => {...}é apenas function(x, y) {...}
const [login, password] = ...split()está apenas dois vartrabalhos em um

fonte de inspiração (usa pacotes)


O exemplo acima é um exemplo super simples que foi planejado para ser super curto e rapidamente implantado em seu servidor de playground. Mas, como foi apontado nos comentários, as senhas também podem conter caracteres de dois pontos :. Para extraí-lo corretamente do b64auth , você pode usar isso.

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

Autenticação básica em uma declaração

... por outro lado, se você usa apenas um ou poucos logins, este é o mínimo necessário: (você nem mesmo precisa analisar as credenciais)

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: você precisa ter caminhos "seguros" e "públicos"? Considere usar em seu 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
Qwerty
fonte
2
Melhor do lote ... :)
Anupam Basak
2
Não use .split(':')porque ele irá engasgar com senhas que contenham pelo menos dois pontos. Essas senhas são válidas de acordo com RFC 2617 .
Distortum
1
Você também pode usar RegExp const [_, login, password] = strauth.match(/(.*?):(.*)/) || []para a parte dos dois pontos.
adabru
3
Usar !==para comparar senhas deixa você vulnerável a ataques de sincronização. en.wikipedia.org/wiki/Timing_attack certifique-se de usar uma comparação de string de tempo constante.
hraban 01 de
1
Use Buffer.from() // for stringsou Buffer.alloc() // for numbersas Buffer()está obsoleto devido a problemas de segurança.
Sr. Alien
71

TL; DR:

express.basicAuthse foi
basic-auth-connectestá obsoleto
basic-authnão tem nenhuma lógica
http-authé um exagero
express-basic-authé o que você quer

Mais informações:

Como você está usando o Express, pode usar o express-basic-authmiddleware.

Veja a documentação:

Exemplo:

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!
}));
rsp
fonte
17
Levei um tempo para descobrir sobre a challenge: trueopção
Vitalii Zurian
1
@VitaliiZurian Boa observação - adicionei à resposta. Obrigado por apontar isso.
rsp
4
@rsp Você sabe como aplicar isso apenas a rotas específicas?
Jorge L Hernandez
Se você não quiser adicionar outras dependências, é muito fácil escrever autenticação básica manualmente em uma linha ...
Qwerty
como ficaria o url do cliente?
GGEv
57

Muito do middleware foi retirado do núcleo do Express na v4 e colocado em módulos separados. O módulo de autenticação básico está aqui: https://github.com/expressjs/basic-auth-connect

Seu exemplo só precisa mudar para este:

var basicAuth = require('basic-auth-connect');
app.use(basicAuth('username', 'password'));
Brian Prodoehl
fonte
19
Este módulo afirma estar obsoleto (embora a alternativa que ele sugere pareça insatisfatória)
Arnout Engelen
3
^^ absolutamente insatisfatório como em densamente indocumentado. nenhum exemplo de uso como middleware, para o qual provavelmente é bom, mas a chamada não está disponível. o exemplo que eles fornecem é ótimo para generalidade, mas não para informações de uso.
Wylie Kulik,
Sim, este está obsoleto e, embora o recomendado esteja com poucos documentos, o código é muito simples github.com/jshttp/basic-auth/blob/master/index.js
Loourr
1
Descrevi como usar a basic-authbiblioteca nesta resposta
Loourr
Como existe um módulo inteiro baseado em colocar a senha em texto não criptografado no código ? Ao menos obscurecê-lo comparando em base64 parece um pouco melhor.
user1944491
33

Usei o código do original basicAuthpara encontrar a resposta:

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();
    }
});
Dov
fonte
10
este módulo é considerado obsoleto, use jshttp / basic-auth em seu lugar (a mesma API, então a resposta ainda se aplica)
Michael
32

Mudei no express 4.0 a autenticação básica com http-auth , o código é:

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);
WarsClon
fonte
1
Isso é literalmente plug and play. Excelente.
Sidonaldson
20

Parece haver vários módulos para fazer isso, alguns estão obsoletos.

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

Aqui está um exemplo 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

Certifique-se de colocar o authmiddleware no lugar correto, qualquer middleware anterior não será autenticado.

Michael
fonte
Na verdade, eu sou a favor de 'basic-auth-connect', o nome é ruim, mas em termos de funcionalidade é melhor do que 'basic-auth'. Tudo o que o último faz é analisar o cabeçalho de autorização. Você ainda precisa implementdo protocolo (também conhecido como enviar cabeçalho correto)
FDIM
Perfeito! Obrigado por isso. Isso funcionou e explicou tudo muito bem.
Tania Rascia
Eu tentei isso, mas ele continua me pedindo para fazer o login via loop contínuo.
jdog
6

Podemos implementar a autorização básica sem precisar de nenhum 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);

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

VIKAS KOHLI
fonte
1

O Express removeu essa funcionalidade e agora recomenda que você use a biblioteca basic-auth .

Aqui está um exemplo de como usar:

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 uma solicitação para esta rota, você precisa incluir um cabeçalho de autorização formatado para autenticação básica.

Enviando uma solicitação curl primeiro, você deve usar a codificação base64name:pass ou, neste caso, aladdin:opensesameque é igual aYWxhZGRpbjpvcGVuc2VzYW1l

Sua solicitação curl ficará assim:

 curl -H "Authorization: Basic YWxhZGRpbjpvcGVuc2VzYW1l" http://localhost:3000/
Loourr
fonte
0
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);
subair adams ohikere
fonte
Espero que isso resolva o problema, mas acrescente uma explicação do seu código para que o usuário compreenda perfeitamente o que ele realmente deseja.
Jaimil Patel