JSON Web Token (JWT), é um padrão que define uma forma segura de transmitir mensagens utilizando um token compacto e self-contained no formato de um objeto JSON.
É compacto porque além de leve, pode ser enviado através de um HTTP header, via URL, ou como parâmetro no corpo de uma requisição HTTP. Dizemos que um JWT é self-contained porque seu payload possui toda informação necessária para autenticar um usuário, assim, não é necessário fazer mais que uma única consulta na base de dados.
JSON Web Tokens são comumente utilizados quando precisamos de autenticação em aplicações com arquiteturas stateless (REST por exemplo). JWTs nos permitem autenticar um usuário e garantir que as demais requisições serão feitas de forma autenticada, sendo possível restringir acessos a recursos e serviços com diferentes níveis de permissões.
O código fonte completo do exemplo apresentado neste post pode ser encontrado neste repositório do Github: https://github.com/andreybleme/jwt-me
Estrutura do JSON Web Token
Um JWT é composto por três partes separadas por ponto.
hhh.ppp.sss
- H eader
- P ayload
- S ignature
O header consiste em duas partes diferentes: o tipo do token (no caso JWT), e o nome do algorítimo responsável pelo hashing, HMAC SHA256 ou RSA.
Esse JSON será encoded via Base64Url e irá compor a primeira parte do token.
O payload contém o que chamamos de claims. Claims são atributos da entidade (no caso usuário) e metadados. Um exemplo de payload:
Essse JSON será encoded via Base64Url e irá compor a segunda parte do token.
A signature verifica que o remetente do JWT é quem diz ser para garantir que a mensagem não foi alterada durante o tráfego. Para criar a assinatura (signature), utiliza-se o header Base64 encoded, o payload também Base64 encoded, e o algorítimo especificado no header. Utilizando o algorítimo HMAC SHA256, a signature ficaria assim:
Por fim teremos uma String em Base64 separada por pontos, compondo o JSON Web Token.
eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsImV4cCI6MTQ5MTUyMjg2NH0.OZQPWEgs-JaABOCEodulSiN-yd-T1gmZzrswY4kaNKNI_FyOVFJPaBsAqkcD3SgN010Y4VSFSNh6DXNqHwNMIw
Para testar esses conceitos e montar um JWT, você pode usar o JWT Debugger e ver o token sendo formado na prática.
Criando o projeto Spring boot
A ideia é implementar autenticação para uma aplicação Springboot. Para criar um novo projeto spring boot basta acessar https://start.spring.io/ e no campo “dependencies”, adicionar apenas “Web”. Fazendo isso, um novo projeto pronto para ser executado será criado já com todas as dependências que precisamos para executar a aplicação.
Feito isso, criaremos uma rota /home para verificarmos o funcionamento correto da nossa aplicação, mais tarde criaremos outras rotas. Quando queremos criar métodos que representem endpoints no Spring, precisamos criar um RestController. Por hora, vamos adicionar o endpoint na única classe que temos no projeto, a classe principal.
Executando o método main, acessando o endereço localhost:8080/home devemos ver a mensagem ““Hello buddy!”.
Agora vamos extender um pouco mais, criando a classe UserController. Essa classe também será anotada com @RestController, vamos mapear a URL /users retornando um JSON simples quando ela for acessada.
Como fizemos na nossa classe principal, aqui também criamos um endpoint. A diferença é que nosso método retorna um JSON. Por essa razão adicionamos a anotação @ResponseBody. Com essa anotação, quando uma requisição especificar em seu header que aceita application/json , os dados serão retornados para o client em formato JSON.
Adicionando segurança às rotas
Até esse momento, os recursos da nossa aplicação estão expostos para todos. Qualquer pessoa pode acessar a lista de usuários do nosso servidor. Para que esse recurso seja restrito apenas a usuários autenticados, vamos adicionar segurança à nossa aplicação com JSON Web Tokens!
Nesse exemplo, vamos expor publicamente apenas os recursos disponíveis em /home e /login. Para acessar /users será necessário que o usuário envie ao nosso servidor um token JWT válido. Para isso, vamos adicionar duas dependências ao pom.xml. A primeira é spring-boot-starter-security que nos permite trabalhar com autenticação no Spring, e a segunda, é jjwt que vai gerenciar nossos JWTs.
Adicionadas as dependências, a primeira coisa que queremos fazer é deixar de expor os recursos de /users publicamente. Por tanto, vamos criar uma configuração que restrinja esse acesso criando uma nova classe chamada WebSecurityConfig. Essa nova classe vai ser uma classe filha da classe WebSecurityConfigurerAdapter do Spring security. Nesse exemplo, vamos cria-la em um novo pacote com.jwtme.security.
Aqui estamos usando anotações do Spring Security e do próprio Spring Boot. Se quiser aprender mais sobre estas anotações e outras features interessantes do Spring, recomendo este livro do Henrique Lobo: Vire o jogo com Spring e Spring in Action.
Nessa classe definimos que todos podem acessar /home, e que o endpoint /login está disponível apenas via requisições do tipo POST. Para todas as demais rotas a autenticação é necessária. Não se preocupe com erros de compilação, já que ainda não criamos as classes JWTLoginFilter e JWTAuthenticationFilter. Vamos cria-las em breve. Elas serão as classes responsáveis por filtrar as requisições feitas em /login e em todas as outras rotas, para decidir como essas requisições deverão ser tratadas. Repare que também adicionamos uma conta default aqui, para testarmos o funcionamento da autenticação.
Uma grande vantagem de estarmos utilizando o Spring boot aqui, é que em momento algum foi necessário mudar o código já existente das rotas, nem adicionar arquivos .xml de configuração! Tudo foi feito pragmaticamente com uma classe de configuração anotada com @Configuration.
As classes JWTLoginFilter e JWTAuthenticationFilter serão responsáveis por lidar com login e validação da autenticação dos usuários quando acessarem outras rotas. Por tanto, antes nos preocuparmos com elas, vamos ter que criar as classes que irão lidar com os JWTs.
Criando os JWT Services no Spring boot
Nossos JWT services serão responsáveis por gerara e validar nossos JWT tokens. Nesse exemplo vamos criar um token baseado em username e um expiration_time, em seguida iremos assiná-lo com uma palavra chave secret.
Para criar e verificar nossos tokens, vamos criar a classe TokenAuthenticationService dentro do mesmo pacote com.jwtme.security. Nela vamos utilizar a classe que incluímos como dependência io.jsonwebtoken.Jwts para validar os tokens.
Recomendo o livro Spring in Action para mais detalhes sobre as classes do Spring Security.
Autenticando os JWTs
Já temos tudo que precisamos para usar os JWTs no processo de autenticação. Agora vamos criar a classe JWTLoginFilter para interceptar as requisições do tipo POST feitas em /login e tentar autenticar o usuário. Quando o usuário for autenticado com sucesso, um método irá retornar um JWT com a autorização Authorization no cabeçalho da resposta.
Aqui o método attemptAuthentication é quem lida com a tentativa de autenticação. Pegamos o usernamee password da requisição, e utilizamos o AuthenticationManager para verificar se os dados são correspondentes aos dados do nosso usuário existente. Caso os dados estejam corretos, invocamos o método successfulAuthentication para enviar ao service TokenAuthenticationService o username do usuário para que este service adicione um JWT à nossa resposta (response).
Agora sim, criaremos a classe JWTAuthenticationFilter.
Nessa classe validamos a existência de um JWT nas requisições, com ajuda do service TokenAuthenticationService.
Agora só falta criarmos a classe AccountCredentials, que será utilizada para enviarmos as credenciais da conta a ser validada quando fizermos requisições do tipo POST à URL /login. Requests de login portanto, devem ser feitas com um objeto do tipo AccountCredentials em seu body.
Executando a autenticação
Nossa aplicação agora está segura e podemos realizar autenticações com JWT! Após reiniciar a aplicação vamos tentar acessar o endereço http://localhost:8080/users. Se tudo estiver funcionando corretamente, a resposta deve ser Access Denied.
Para nos autenticarmos corretamente, vamos enviar uma requisição do tipo POST para o endereço http://localhost:8080/login com as credencias do nosso usuário default no body. Usando o Postman a requisição feita com sucesso deve se parecer com isso:
No header da resposta dessa requisição temos nosso token com o prefixo Bearer. Para buscar os usuários, agora precisamos enviar no header da requisição nosso token incluindo o cabeçalho Authorization com o JWT que recebemos quando realizamos a autenticação com sucesso.
E é isso! Se quiser ir além e aprender mais sobre Spring Framework, indico a leitura dos livros:
