api-rest-autenticacao-json-web-token

Eu sempre tive uma treta séria com autenticação. Quando precisei autenticar em uma API REST, então, aí ferrou! Mas existe uma luz ao fim do túnel, e ela se chama JSON Web Token, ou JWT.

Não vou entrar em detalhes da minha briga com métodos de autenticar - no momento, mas acredite quando digo que testei e usei vários. Eis o por que do JWT.

Analisando a Demanda:

  • Necessidade: Gerenciar rotas protegidas por login e níveis de usuário de uma API REST em NodeJS.

  • Requisitos: Não depender de sessão (rest é sessionless, lembra?), permitir identificar o usuário (e seu nível), não utilizar Providers de terceiros, integrar com qualquer plataforma frontend.

JSON Web Token: o que é JWT?

JWT pronuncia-se ‘JõT’.

É um jeito simples de encaminhar informações que podem ser confiadas, pois são assinadas e confirmadas.

Isso é um JWT:

1
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjEzODY4OTkxMzEsImlzcyI6ImppcmE6MTU0ODk1OTUiLCJxc2giOiI4MDYzZmY0Y2ExZTQxZGY3YmM5MGM4YWI2ZDBmNjIwN2Q0OTFjZjZkYWQ3YzY2ZWE3OTdiNDYxNGI3MTkyMmU5IiwiaWF0IjoxMzg2ODk4OTUxfQ.uKqU9dTB6gKwG6jQCuXYAiMNdfNRw98Hw_IWuA5MaMo

São 3 partes, separadas por um ., encodadas por base64 individualmente:

<base64-encoded header>.<base64-encoded claims>.<base64-encoded assinatura>

Mas atenção: JWT não encripta o payload, apenas o assina. O que isso quer dizer é que você não deve enviar informações confidenciais por JWT. Apenas informações que devem ser verificadas/confiadas.

Por exemplo: Não é uma boa idéia passar uma senha por JWT, mas enviar o ID do usuário APÓS o login, vai permitir que ele faça requisições autenticadas :D, saca só:

Fluxo de uso de JWT para um client

  1. Quero acessar uma rota protegida, tipo /users

  2. Faço o login, enviando (de forma segura, por https) usuário e senha.

  3. Login com sucesso, recebo o ‘TOKEN’. Guardo pra usar depois ;)

  4. Faço a requisição que eu queria na /users porém, com o http Header x-access-token : meutokenaqui

  5. Com o token enviado, o servidor me identifica e autoriza (ou não) meu acesso, retornando a resposta à minha requisição.

Fluxo de uso de JWT para o SERVER

  1. Se tentarem acessar uma rota protegida sem token, não autoriza.

  2. Se tentar acessar com um token, verifica se é válido. Se for, consegue identificar o usuário pelo TOKEN e libera o acesso.

  3. Quando um usuário faz login, geramos um token, para ele poder fazer requisições autenticadas.

Nossa, Rômulo, que legal, cara! Agora me diz, como eu faço isso?

Como fazer a autenticação de uma API REST com Json Web Token em NodeJs?

Bom, pra explicar legal mesmo a gente vai começar junto, e de mãos dadas, iremos até o fim :P (aperta o cinto, porque vai ser longa a jornada)

O resultado de nossa empreitada esta neste repositório do github

À partir de agora, serei seu guia pelo lindo mundo das APIs com NodeJS, e faremos:

  1. Um servidorzinho

  2. Algumas rotas: POST E GET de usuarios, POST de login

  3. Conexão com o MongoDB do Mongolabs

  4. Criar usuários

  5. Encriptar senhas

  6. Implementar JWT durante o login

  7. Passar middleware que tornará a rota passível de autenticação. E vai conferir o JWT

Vamos lá?

0) Requisitos:

NodeJs
POSTMAN, para testar a API e métodos GET e POST
MongoLabs um db gratuito resolve

1) Servidor em NodeJs.

Já com o Node instalado, vamos criar uma nova pasta.
Nela, crie um arquivo chamado package.json, insira:

[package.json]
1
2
3
4
5
6
7
8
9
10
11
12
13
{
  "name": "teste-api-jwt",
  "version": "1.0.0",
  "main": "server.js",
  "dependencies": {
    "express": "^4.11.2",
    "body-parser": "^1.11.0",
    "mongoose": "^3.8.23",
    "bcrypt-nodejs": "0.0.3",
    "jwt-simple": "^0.2.0",
    "moment": "^2.9.0",
  }
}

Já pode acessar a pasta pelo terminal, e instalar as dependências, com o comando:

[com o terminal, na mesma pasta do package.json, execute o comando:]
1
$ npm install

Enquanto você espera instalar, veja o que cada item faz:
O express é o framework para App. Vai gerenciar nossas rotas e middlewares.
O body-parser, antigamente incluso no express, vai parsear nossas requisições, permitindo que usemos urls complexas e trabalhar com formulários.
O mongoose é o ORM que vai interagir com o MongoDb pra gente.
O bcrypt-nodejs vai encriptar nossa senha. NUNCA salve a senha sem encriptar.
O jwt-simple vai gerar e conferir nossos JSON Web Token (ou você achou que ia fazer todo aquele processo acima na unha? hehe)
O moment vai nos ajudar a trabalhar com data de expiração do JWT.

Agora, criemos o server.js

[server.js][crie na mesma pasta do package.json]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var express = require('express')
  , app = express()
  , bodyParser = require('body-parser')
  , mongoose = require('mongoose')
  , jwt = require('jwt-simple');
  var db = '';//coloque a url do db aqui
  app.use(bodyParser.urlencoded({ extended: true }));
  app.use(bodyParser.json());
  var port = process.env.PORT || 8080;
  var router = express.Router();
  app.use('/api', router);
  /*Aqui criaremos as rotas*/
  mongoose.connect(db);
  app.listen(port);
  console.log('conectado a porta ' + port);

Note que a var db é a url do nosso banco de dados. Vc pode criar uma conta grátis no MongoLab, acessá-la, clicar em create database nomeie teste-jwt deixando com a opção single node (gratis).
Após criada, clique nela, aí em create user e crie um usuário para o nosso DB.
A url deve ser algo como mongodb://usuario:senha@ds053668.mongolab.com:53668/teste-jwt

Após colocar a url na var db, salve o arquivo, acesse a pasta com o terminal e rode:

1
2
$ node server
conectado a porta 8080

Sinal que deu boa ^_^

2) Criando algumas rotas

Logo abaixo de /*Aqui criaremos as rotas*/, insira:

[server.js][insira abaixo do comentário]
1
2
3
4
5
6
7
8
9
10
11
(...)
/*Aqui criaremos as rotas*/
var rotas = require('./rotas')
  router.route('/usuarios')
    .get(rotas.getUsuarios)
    .post(rotas.postUsuarios);
  router.route('/login')
    .post(rotas.login);

  mongoose.connect(db);
(...)

Crie um arquivo chamado rotas.js na mesma pasta.

[rotas.js][crie o arquivo na mesma pasta]
1
2
3
4
5
6
7
8
9
10
11
module.exports = {
  getUsuarios: function(req, res){
    res.json({message: "rota para GET do /usuarios"})
  },
  postUsuarios: function(req, res){
    res.json({message: "rota para POST do /usuarios"})
  },
  login: function(req, res){
  res.json({message; 'rota de login'})
  }
}

Salvando tudo, você pode executar node server novamente, fazer um get para http://localhost:8080/api/usuarios e depois um post para conferir se funcionou
(Pra isso, use algo como o postman (clique para baixar)) ou faz no curl se for macho(a).

3) Criando o Model usuário

Crie o arquivo ModelUsuario.js, na mesma pasta.

[ModelUsuario.js] [Crie o arquivo]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
var mongoose = require('mongoose');
var bcrypt = require('bcrypt-nodejs');
//1
var UsuarioSchema = new mongoose.Schema({
  username: {
    type: String,
    unique: true,
    required: true
  },
  password: {
    type: String,
    required: true
  }
});
//2
UsuarioSchema.pre('save', function(next) {
  var user = this;
  if (!user.isModified('password')) return next();
  bcrypt.genSalt(5, function(err, salt) {
    if (err) return next(err);
    bcrypt.hash(user.password, salt, null, function(err, hash) {
      if (err) return next(err);
      user.password = hash;
      next();
    });
  });
});
//3
UsuarioSchema.methods.verificaSenha = function(password, next) {
  bcrypt.compare(password, this.password, function(err, isMatch) {
    if (err) return next(err);
    next(isMatch);
  });
};
module.exports = mongoose.model('Usuario', UsuarioSchema);

…

…Vish.

Acima temos 3 coisas acontecendo. Nesse arquivo, usamos o mongoose e o bcrypt.

  1. var UsuarioSchema
    Primeiro, var UsuarioSchema definimos a estrutura, com os campo username e password.

  2. UsuarioSchema.pre(‘save’….
    Depois, setamos uma função .pre('save') nessa var que criamos: UsuarioSchema.pre('save', function(.......
    Toda vez que formos salvar, essa função .pre() verifica:

    • SE(if) o password não foi alterado. Se ele não foi alterado, retorna next(), ou seja: continua o fluxo do save().
      Se acontecer outra coisa com o password (criado, alterado..) ele gera o salt com bcrypt.genSalt(). Se der boa, ele usa o bcrypt.hash() e encripta nosso password com o salt q ele gerou. Se der erro, retorna next(err). Se não, chama o next()

  3. UsuarioSchema.methods.verificaSenha = function(senha, next){}
    Aí estamos criando um metodo chamado verificaSenha(), que recebe a senha, usa o bcrypt.compare(). Retorna next(isMatch) se der certo.

E por último module.exports exporta o model com o nome ‘Usuario’.

Pra facilitar estamos colocando tudo na mesma pasta. O ideal, seria ter uma pasta /model, mas não vamos fazer isso nesse artigo.

Agora já temos nosso model, precisamos criar a funçaõ que cria um novo usuário… aff tá cansando né?

O controller criaUsuario()

Esse cara vai criar nossos usuários. Basicamente ele pega os campos username e password, que receberemos na rota, e insere no banco de dados.

Crie o arquivo controllerCriaUsuario.js

[controllerCriaUsuario.js][Crie, na mesma pasta]
1
2
3
4
5
6
7
8
9
10
11
12
var Model = require('./ModelUsuario');
module.exports = function(req, res){
      var data = new Model({
        username: req.body.username,
        password: req.body.password
        });
        data.save(function(err) {
          if (err)
            res.send(err);
          res.json({ message: 'Novo Usuário', data: data });
        });
    };

Maneiro. Aí estamos apenas gerando um new Model e depois dando um .save() nele. Se der tudo certo, recebemos as informações do novo usuario.

Vamos rapidinho alí no rotas.js pra usar esse controller na postUsuarios!

[rotas.js][altere apenas a postUsuarios]
1
2
3
(...),
postUsuarios: require('./controllerCriaUsuario'),
(...)

Agora podemos criar nosso usuário com senha encriptada

rode node server.

Usando o postman, ou outro, faça um POST para http://localhost:8080/api/usuarios envie username e password devidamente preenchidos:
criando-usuario-nodejs-mongodb-express-api-rest

Aeeee conseguimos! Muito legal né? Um servidor express com rotas, criando usuário e salvando no DB com a senha encriptada!

Precisamos agora, fazer o login. E, ao fazer o login, criar o TOKEN

4) O Controller de Login com gerador de Token

Crie o arquivo controllerLogin.js:

[controllerLogin.js][Crie o arquivo]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
var Usuario = require('./ModelUsuario');
  , jwt = require('jwt-simple')
  , moment = require('moment')
  , segredo = 'seusegredodetoken'
module.exports = function(req, res) {
  var username = req.body.username || '';
  var password = req.body.password || '';
  if (username == '' || password == '') {
    return res.send(401);
  }
  //1
  Usuario.findOne({username: username}, function (err, user) {
    if (err) {
      return res.end(401)
    }
    //2
    user.verificaSenha(password, function(isMatch) {
      if (!isMatch) {
        return res.send(401);
      }
    //3
    var expires = moment().add(7,'days').valueOf();
    var token = jwt.encode({
      iss: user.id,
      exp: expires
    }, segredo);
    //4
     return res.json({
      token : token,
      expires: expires,
      user: user.toJSON()
      });
      });
    });
};

Vamos pedir que a nossa rota (/login) rode-o:

[rotas.js][altere apenas a login]
1
2
3
(...),
login: require('./controllerLogin'),
(...)

Reinicie o servidor com

1
$ node server

Agora mude a url para http://localhost:8080/api/login e post seu username e password.

Viu? Que massa? Autenticamos e recebemos o token! Dividi o código acima em 3 partes principais.

Antes, da //1, setamos as dependencias que usaremos neste arquivo com os require. Depois usamos um SE o req.body.username ou o req.body.passwordforem vazios, res.send(401). Se tiverem preenchidos, prosseguimos para:

  1. Usuario.findOne()
    Buscamos por usuários com os dados informados. Se der erro, res.end(401). Se não der erro, continua, retornando o resultado como user.

  2. user.verificaSenha lembra do método que criamos no ModelUsuario? pois é. Se ele não retornar o parâmetro isMatch, res.end(401) neles!

  3. var expires: usamos o moment pra dizer ‘daqui a 7 dias’ e var token, onde criamos o token com jwt.encode(). Note a variável segredo definida no começo do arquivo. Vamos precisar dela mais pra frente :P

5) ULTIMA PARTE: O saudoso Middleware para conferir o token e fazer a segurança das rotas

Vamos criar um middleware de nível route para interceptar as requisições nas rotas protegidas e conferir o TOKEN. Basicamente, ele vai testar o token, se der certo, chama next(), senão: res.end(401) neles!

Crie o arquivo validarJWT.js

[validarJWT.js][Crie o arquivo]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
var model = require('./ModelUsuario')
  , jwt = require('jwt-simple')
  , segredo = 'seusegredodetoken';
module.exports = function(req, res, next) {
  var token = (req.body && req.body.access_token) || (req.query && req.query.access_token) || req.headers['x-access-token'];
//1
  if (token) {
  try {
    var decoded = jwt.decode(token, segredo);
    console.log('decodando ' + decoded);
   //2
    if (decoded.exp <= Date.now()) {
      res.json(400, {error: 'Acesso Expirado, faça login novamente'});
    }
    //3
    model.findOne({ _id: decoded.iss }, function(err, user) {
      if(err)
        res.status(500).json({message: "erro ao procurar usuario do token."})
      req.user = user;
      console.log('achei usuario ' + req.user)
      return next();
    });
  //4
  } catch (err) {
    return res.status(401).json({message: 'Erro: Seu token é inválido'});
  }
} else {
  res.json(401, {message: 'Token não encontrado ou informado'})
}
};

No //1 SE existir um token, rodamos a funçaõ jwt.decode().

No //2 , usamos o resultado do jwt.decode() para verificar se o token expirou.

no //3 pesquisamos no MongoDB pelo _id que veio no JWT

no //4 ficamos de olho por erros, caso aconteça, 401 neles.

Agora iremos inserir o validarJWT nas rotas à proteger isso será feito em nosso server.js. Iremos proteger apenas a rota .get() do /usuarios:

[server.js][Insira o middleware validarJWT.js nas rotas protegidas]
1
2
3
4
5
(...)
 router.route('/usuarios')
    .get(require('./validarJWT'), rotas.getUsuarios) //alteramos esta
    .post(rotas.postUsuarios);
(...)

Novamente não é boa prática usar o require como parâmetro de função. Pelo bem do fluxo do tutorial e arquivo final, estou fazendo, mas o ideal seria criar var validarJWT = require('./validarJWT')….

Anyway, reinicie o server, faça um GET para http://localhost:8080/api/usuarios . Viu: Ele disse “TOKEN NAO ENCONTRADO”

Tudo pronto!!! Vamos usar nosso token :D

Dessa vez não precisa nem reiniciar o server. Faça um POST para http://localhost:8080/api/login com seu username e password.

[resposta do login]
1
2
3
4
5
6
7
8
9
10
{
    "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiI1NGRjM2RkODU5ZTQwNmZjMWE3YWJiOGIiLCJleHAiOjE0MjQzMjgxMzI0NzN9._RcLvHkjttELVpeNtYuCdn3ZkojwSKLA42V6ChZLi4s",
    "expires": 1424328132473,
    "user": {
        "_id": "54dc3dd859e406fc1a7abb8b",
        "username": "rcdev",
        "password": "$2a$05$mXgWbp14wuvDmj3pX0NFBOgIeSyIACAmEOmYgr/41gUManjIVYJ9.",
        "__v": 0
    }
}

Vamos copiar o token (sim, ele inteiro) e adicionar como header x-access-tokenem nossa próxima requisição.

Faça um GET para /api/usuarios novamente, dessa vez com o token recebido como header chamada x-access-token:

token-sucesso

Parabéns e obrigado à você que acompanhou até aqui :P

Espero poder ter ajudado. Se tiver dicas, dúvidas ou observações, por favor comente :)

O resultado de nossa empreitada esta neste repositório do github