{"componentChunkName":"component---src-templates-blog-post-js","path":"/spring-security-jwt/","result":{"data":{"markdownRemark":{"html":"

Implementar segurança em aplicações não é algo simples e requer atenção em muitos detalhes.

\n

Pensando nisso o Spring Security surgiu para descomplicar muitos pontos e juntamente com o Spring Boot deixou o desenvolvimento de aplicações seguras muito mais produtivo e descomplicado, nesse post iremos implementar em uma aplicação uma API REST para autenticação e geração de um token JWT para completar as requisições de forma segura.

\n

Criando o projeto

\n

Usando o site spring initializr criamos um projeto base e já adicionamos as dependências do Spring Security, Spring Web e adicionamos a dependência do Json Web Token; como estamos criando um projeto Maven o pom.xml ficará assim:

\n
<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http://maven.apache.org/POM/4.0.0\"\n\txmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n\txsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd\">\n\t<modelVersion>4.0.0</modelVersion>\n\t<parent>\n\t\t<groupId>org.springframework.boot</groupId>\n\t\t<artifactId>spring-boot-starter-parent</artifactId>\n\t\t<version>2.4.0</version>\n\t\t<relativePath /> <!-- lookup parent from repository -->\n\t</parent>\n\t<groupId>com.irs.register</groupId>\n\t<artifactId>register</artifactId>\n\t<version>0.0.1-SNAPSHOT</version>\n\t<name>register</name>\n\t<description>Register Service</description>\n\n\t<properties>\n\t\t<java.version>11</java.version>\n\t</properties>\n\n\t<dependencies>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.boot</groupId>\n\t\t\t<artifactId>spring-boot-starter-actuator</artifactId>\n\t\t</dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.boot</groupId>\n\t\t\t<artifactId>spring-boot-starter-security</artifactId>\n\t\t</dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.boot</groupId>\n\t\t\t<artifactId>spring-boot-starter-web</artifactId>\n\t\t</dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.boot</groupId>\n\t\t\t<artifactId>spring-boot-starter-data-jpa</artifactId>\n\t\t</dependency>\n\t\t<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->\n\t\t<dependency>\n\t\t\t<groupId>mysql</groupId>\n\t\t\t<artifactId>mysql-connector-java</artifactId>\n\t\t\t<version>8.0.22</version>\n\t\t</dependency>\n\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.boot</groupId>\n\t\t\t<artifactId>spring-boot-devtools</artifactId>\n\t\t\t<scope>runtime</scope>\n\t\t\t<optional>true</optional>\n\t\t</dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.projectlombok</groupId>\n\t\t\t<artifactId>lombok</artifactId>\n\t\t\t<optional>true</optional>\n\t\t</dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.boot</groupId>\n\t\t\t<artifactId>spring-boot-starter-test</artifactId>\n\t\t\t<scope>test</scope>\n\t\t</dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.security</groupId>\n\t\t\t<artifactId>spring-security-test</artifactId>\n\t\t\t<scope>test</scope>\n\t\t</dependency>\n\t\t<dependency>\n\t\t\t<groupId>io.jsonwebtoken</groupId>\n\t\t\t<artifactId>jjwt</artifactId>\n\t\t\t<version>0.9.1</version>\n\t\t</dependency>\n\t</dependencies>\n\n\t<build>\n\t\t<plugins>\n\t\t\t<plugin>\n\t\t\t\t<groupId>org.springframework.boot</groupId>\n\t\t\t\t<artifactId>spring-boot-maven-plugin</artifactId>\n\t\t\t</plugin>\n\t\t</plugins>\n\t</build>\n\n</project>
\n

No nosso pom.xml podemos ver além das dependências que foram mencionadas a cima, as dependências do Lombok, Spring Data, Actuator e DevTools que irão ajudar no desenvolvimento.

\n

Habilitando o contexto de segurança

\n

Para começarmos a configurar o Spring Security vamos criar uma classe e adicionaremos as anotações @EnableWebSecurity e @Configuration para que ela seja carregada e esteja configurada no inicio da aplicação. Além disso estendemos a classe WebSecurityConfigurerAdapter que expõe três métodos para fazer as configurações necessárias:

\n
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {\n\t\n    //Configurations for authentication\n    @Override\n    protected void configure(AuthenticationManagerBuilder auth) throws Exception {\n    }\n\n    //Configuration for authorization\n    @Override\n    protected void configure(HttpSecurity http) throws Exception {\n    }\n\n    //Configuration for static resources\n    @Override\n    public void configure(WebSecurity web) throws Exception {\n    }\n}
\n

Podemos observar que temos três métodos chamados configure mas que recebem parâmetros diferentes:

\n\n

Como estamos usando o Actuator já recebemos alguns endpoints para monitorar a saúde da nossa aplicação, entre eles temos o /actuator/health que retorna se a aplicação está no ar ou instável, se iniciarmos a aplicação e tentarmos acessar esse endpoint receberemos a seguinte mensagem:

\n
{\n    \"timestamp\": \"2020-12-11T22:29:51.654+00:00\",\n    \"status\": 403,\n    \"error\": \"Forbidden\",\n    \"message\": \"Access Denied\",\n    \"path\": \"/actuator/health\"\n}
\n

\"BLOCK!!!\"

\n

Recebemos o status code 403 Forbidden nos indicando que a url não pode ser acessada pois o acesso foi negado.

\n

Configurando Endpoint de Autenticação

\n

Já temos as urls protegidas, agora vamos configurar a autenticação. Primeiramente vamos criar um Controller que receba uma requisição de login de um usuário:

\n
@RestController\n@RequestMapping(\"/auth\")\npublic class AuthenticationController {\n\t\n\t@Autowired\n\tprivate AuthenticationManager authenticationManager;\n\t\n\t@Autowired\n\tprivate TokenService tokenService;\n\t\n\t@PostMapping\n\tpublic ResponseEntity<TokenDTO> auth(@RequestBody @Validated LoginDTO loginDTO){\n\t\tUsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(loginDTO.getUser(), loginDTO.getPass());\n\t\t\n\t\tAuthentication authentication = authenticationManager.authenticate(usernamePasswordAuthenticationToken);\n\t\t\n\t\tString token = tokenService.generateToken(authentication);\n\t\t\n\t\treturn ResponseEntity.ok(TokenDTO.builder().type(\"Bearer\").token(token).build());\n\t\t\n\t}\n\n}
\n

Esse Controller é um endpoint REST mapeado para /auth que tem uma entrada do tipo POST que recebe um objeto do tipo LoginDTO que possui o email e a senha e realiza a autenticação e devolve o token de acesso, podemos ver que já existem as classes de serviço do token e de autenticação, mais detalhes a diante.

\n

Se tentarmos fazer um requisição do tipo POST com um usuário e senha vamos tomar um erro 403 Forbidden mas por que isso acontece?

\n

\"Hummm???\"

\n

Bom antes de mais nada devemos voltar para a nossa classe SecurityConfiguration e precisamos configurar quais rotas serão protegidas e quais rotas podem estar disponíveis, como é o caso da rota de login que deve estar aberta pois sem ela não há como um usuário se autenticar, vamos colocar também a configuração de sessão. Como estamos estamos usando a estratégia de token a configuração de sessão será STATELESS que significa que não será guardado estado como era feito antigamente, onde um usuário logado ficava com seus dados guardados no servidor e era enviado algum tipo de identificador, Cookie, para o client ou front-end para que nas próximas requisições fosse enviado esse Cookie para o servidor e ele saber quem é aquele usuário.

\n
    //Configuration for authorization\n    @Override\n    protected void configure(HttpSecurity http) throws Exception {\n        http.authorizeRequests()\n        \t.antMatchers(HttpMethod.POST, \"/auth\").permitAll()\n        \t.anyRequest().authenticated()\n        \t.and().csrf().disable()\n        \t.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);\n    }
\n

O objeto HttpSecurity possui uma API fluída o que significa que os métodos podem ser chamados em sequência e essa sequência forma uma frase explícita da intenção.

\n

Lendo o código a cima temos a seguinte intenção: Autorize, os requests com o padrão /auth são permitidos, qualquer outro é necessário estar autenticado, desabilite a política CSRF e no gerenciamento de sessão use a política STATELESS

\n

Obs: CSRF (Cross-site request forgery) ou XSRF é tipo de ataque na web porém para o tipo de autenticação com web token estamos livre desse tipo de problema.

\n

Configuração de autenticação

\n

Feito isso podemos chamar o nosso endpoint porém ainda é necessário fazer mais configurações pois temos que criar as classes de serviços para fazer a autenticação.

\n

Voltando para o Controller temos duas classes sendo injetadas

\n
    @Autowired\n\tprivate AuthenticationManager authenticationManager;\n\t\n\t@Autowired\n\tprivate TokenService tokenService;
\n

A primeira é uma classe do próprio Spring Security e só injetaremos ela aqui mas precisamos fazer as configurações pertinentes a ela lá na nossa classe de configuração no método configure que recebe um objeto do tipo AuthenticationManagerBuilder e é o método responsável por lidar com a autenticação:

\n
    @Autowired\n\tprivate AuthenticationService authenticationService;\n\n    //Configurations for authentication\n    @Override\n    protected void configure(AuthenticationManagerBuilder auth) throws Exception {\n    \tauth.userDetailsService(authenticationService).passwordEncoder(new BCryptPasswordEncoder());\n    }
\n

Esse método será chamado durante a autenticação e para validação dos dados de usuário irá chamar a classe AuthenticationService, importante também verificar que estamos usando um encoder para o nosso password pois não queremos ser capazes de armazenar o password em texto simples, mas para entender melhor precisamos entrar nessa classe de serviço e verificar o que é feito.

\n
@Service\npublic class AuthenticationService implements UserDetailsService{\n\t\n\t@Autowired\n\tprivate UserRepositoryPort repository;\n\n\t@Override\n\tpublic UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {\n\t\tOptional<User> optional = repository.findByEmail(username);\n\t\t\n\t\tif(optional.isPresent()) {\n\t\t\treturn optional.get();\n\t\t}\n\t\t\n\t\tthrow new UsernameNotFoundException(\"User not found\");\n\t}\t\n\n}
\n

A primeira coisa que percebemos é que essa classe implementa a interface UserDetailsService que possui o método loadUserByUsername e devolve um objeto do tipo UserDetails.

\n

O que basicamente acontece aqui é que ele vai buscar em algum repositório por esse usuário e verificar se ele existe e devolver para o processo de autenticação, mas ainda não temos nada disso criado, então vamos criar o nosso repositório agora.

\n

Criando Repositório para autenticação

\n

O repositório será um banco de dados que armazena os usuários dessa aplicação, então segue o mapeamento da classe User que implementa a classe UserDetails do Spring Security:

\n
@Data\n@AllArgsConstructor\n@NoArgsConstructor\n@Entity\n@Table(name = \"User\")\npublic class User implements UserDetails{\n\t\n\t/**\n\t * \n\t */\n\tprivate static final long serialVersionUID = 1L;\n\n\t@Id @GeneratedValue(strategy = GenerationType.IDENTITY)\n\tprivate Integer id;\n\t\n\tprivate String email;\n\t\n\tprivate String pass;\n\t\n\t@ManyToMany(fetch = FetchType.EAGER)\n\tprivate Set<Perfil> perfis;\n\n\t@Override\n\tpublic Collection<? extends GrantedAuthority> getAuthorities() {\n\t\treturn this.perfis;\n\t}\n\n\t@Override\n\tpublic String getPassword() {\n\t\treturn this.pass;\n\t}\n\n\t@Override\n\tpublic String getUsername() {\n\t\treturn this.email;\n\t}\n\n\t@Override\n\tpublic boolean isAccountNonExpired() {\n\t\treturn true;\n\t}\n\n\t@Override\n\tpublic boolean isAccountNonLocked() {\n\t\treturn true;\n\t}\n\n\t@Override\n\tpublic boolean isCredentialsNonExpired() {\n\t\treturn true;\n\t}\n\n\t@Override\n\tpublic boolean isEnabled() {\n\t\treturn true;\n\t}\n\n}
\n

O fato de implementarmos UserDetails faz com que implementemos alguns métodos para fazer a checagem se o usuário existe e se ele pode se autenticar. Também é necessário informar as permissões de acesso para esse usuário através do método getAuthorities e para fazer esse mapeamento foi criado a classe Perfil:

\n
@Data\n@AllArgsConstructor\n@NoArgsConstructor\n@Entity\n@Table(name = \"Perfil\")\npublic class Perfil implements GrantedAuthority{\n\t\n\n\tprivate static final long serialVersionUID = 1L;\n\n\t@Id @GeneratedValue(strategy = GenerationType.IDENTITY)\n\tprivate Integer id;\n\t\n\tprivate String name;\n\n\t@Override\n\tpublic String getAuthority() {\n\t\treturn this.name;\n\t}\n\n}
\n

Essa classe por sua vez implementa a interface GrantedAuthority que representa as permissões concedidas para um usuário.

\n

Agora criamos a interface que será o serviço de Repository para buscar essas informações:

\n
@Repository\npublic interface UserRepository extends CrudRepository<User, Integer>{\n\t\n\tOptional<User> findByEmail(String email);\n\n}
\n

Com isso agora a nossa classe AuthenticationService vai funcionar quando for chamada em uma requisição com usuário e senha.

\n

Devolvendo JSON Web Token

\n

Após a autenticação ser efetuada o nosso Controller irá retornar o JWT para que seja usado em próximas requisições, precisamos agora fazer a configuração para retornar esse token para o usuário.

\n

No Controller temos o seguinte trecho de código:

\n
\t@PostMapping\n\tpublic ResponseEntity<TokenDTO> auth(@RequestBody @Validated LoginDTO loginDTO){\n\t\tUsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(loginDTO.getUser(), loginDTO.getPass());\n\t\t\n\t\tAuthentication authentication = authenticationManager.authenticate(usernamePasswordAuthenticationToken);\n\t\t\n\t\tString token = tokenService.generateToken(authentication);\n\t\t\n\t\treturn ResponseEntity.ok(TokenDTO.builder().type(\"Bearer\").token(token).build());\n\t\t\n\t}
\n

Aqui usamos a classe TokenService para gerar o token, essa classe recebe um objeto do tipo Authentication que é retornado após realizar todos os passos de autenticação.

\n
@Service\npublic class TokenService {\n\n\t@Value(\"${jwt.expiration}\")\n\tprivate String expiration;\n\n\t@Value(\"${jwt.secret}\")\n\tprivate String secret;\n\n\tpublic String generateToken(Authentication authentication) {\n\n\t\tUser usuario = (User) authentication.getPrincipal();\n\n\t\tDate now = new Date();\n\t\tDate exp = new Date(now.getTime() + Long.parseLong(expiration));\n\n\t\treturn Jwts.builder().setIssuer(\"MinhaAplicacao\")\n                             .setSubject(usuario.getId().toString())\n                             .setIssuedAt(new Date())\n\t\t\t\t             .setExpiration(exp)\n                             .signWith(SignatureAlgorithm.HS256, secret).compact();\n\t}\n\n}
\n

Aqui recebemos o objeto Authentication e dentro dele temos o método getPrincipal onde temos o nosso User e vamos devolver o nosso JWT com algumas informações:

\n\n

As variáveis expiration e secret foram definidas no arquivos *application.yml *

\n

Com isso já teremos o retorno do JWT que pode ser usado nas próxima requests.

\n

Autorizando JWT

\n

Agora já conseguimos autenticar com usuário e senha e devolver um token para ser usado nas próximas requisições, mas precisamos configurar essa parte na aplicação.

\n

Como estamos usando gerenciamento de sessão Stateless cada requisição é “nova” para a aplicação, a aplicação não tem conhecimento que o usuário já realizou anteriormente a autenticação. Por isso usamos o token que contém informações para permitir o acesso do usuário aos recursos da aplicação.

\n

\"Passport!!!\"

\n

O que podemos fazer é verificar se uma requisição que está tentando acessar algum recurso possui um token e se esse token é válido.

\n

Podemos fazer isso interceptando uma requisição.

\n
public class TokenAuthenticationFilter extends OncePerRequestFilter {\n\t\n\t@Override\n\tprotected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)\n\t\t\tthrows ServletException, IOException {\n\n\t\tfilterChain.doFilter(request, response);\n\t}\n\n}
\n

Criamos a classe TokenAuthenticationFilter que estende de OncePerRequestFilter que já faz a interceptação das requisições e temos o método doFilterInternal onde podemos manipular vários dados.

\n

Fora isso temos que informar para o Spring Security que temos um Filter e que ele deve ser processado em ordem, vamos voltar na classe SecurityConfiguration e adicionar no método configure:

\n
    //Configuration for authorization\n    @Override\n    protected void configure(HttpSecurity http) throws Exception {\n        http.authorizeRequests()\n        \t.antMatchers(HttpMethod.POST, \"/auth\").permitAll()\n        \t.anyRequest().authenticated()\n        \t.and().csrf().disable()\n        \t.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)\n            //Configuração do Filtro\n        \t.and().addFilterBefore(new TokenAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);\n    }
\n

Aqui adicionamos a configuração de filtro e que ele deve ser antes do filtro do Spring Security UsernamePasswordAuthenticationFilter, agora voltando para a classe de filtro precisamos configurá-la para extrair o token da requisição e validar:

\n
\t@Override\n\tprotected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)\n\t\t\tthrows ServletException, IOException {\n\n\t\tString token = request.getHeader(\"Authorization\");\n\t\tif(token == null || token.isEmpty() || !token.startsWith(\"Bearer \")) {\n\t\t\ttoken = null;\n\t\t}\n\t\t\n\t\ttoken = token.substring(7, token.length());\n\n\t\tfilterChain.doFilter(request, response);\n\t}
\n

No código a cima conseguimos extrair o token do cabeçalho Authorization e verificamos se ele existe e se ele é um token do tipo Bearer, agora precisamos verificar se ele é válido. Para isso precisamos da secret que foi usada quando geramos o token então essa lógica vai ficar na classe TokenService no método isValid que recebe a String do token e retorna um boolean.

\n
\tpublic boolean isTokenValid(String token) {\n\t\ttry {\n\t\t\tJwts.parser().setSigningKey(secret).parseClaimsJws(token);\n\t\t\treturn true;\n\t\t} catch (Exception e) {\n\t\t\treturn false;\n\t\t}\n\t}
\n

Esse método faz uso da biblioteca jsonwebtoken e aqui fazemos uso do método parseClaimsJws, caso não consiga fazer o parse do token com a secret irá lançar uma Exception, caso não dê erro é por que o token é válido.

\n
\t@Override\n\tprotected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)\n\t\t\tthrows ServletException, IOException {\n\t\t\n\t\tString tokenFromHeader = getTokenFromHeader(request);\n\t\tboolean tokenValid = tokenService.isTokenValid(tokenFromHeader);\n\t\tif(tokenValid) {\n\t\t\tthis.authenticate(tokenFromHeader);\n\t\t}\n\n\t\tfilterChain.doFilter(request, response);\n\t}\n\n\tprivate void authenticate(String tokenFromHeader) {\n\t\tInteger id = tokenService.getTokenId(tokenFromHeader);\n\t\t\n\t\tOptional<User> optionalUser = repository.findById(id);\n\t\t\n\t\tif(optionalUser.isPresent()) {\n\t\t\t\n\t\t\tUser user = optionalUser.get();\n\t\t\t\n\t\t\tUsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(user, null, user.getPerfis());\n\t\t\tSecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);\n\t\t}\n\t}\n\n\tprivate String getTokenFromHeader(HttpServletRequest request) {\n\t\tString token = request.getHeader(\"Authorization\");\n\t\tif(token == null || token.isEmpty() || !token.startsWith(\"Bearer \")) {\n\t\t\treturn null;\n\t\t}\n\t\t\n\t\treturn token.substring(7, token.length());\n\t}
\n

Aqui acima temos o uso dos dois métodos e de mais um novo que é o authenticate que usa o método getTokenId para extrair o id que é enviado no token, no Subject e após isso faz uma busca por esse id no repositório. Caso encontre instânciamos um objeto UsernamePasswordAuthenticationToken passando o user, null no parâmetro da senha pois não precisamos dela nesse ponto e a lista de perfis. Passamos ele para o objeto SecurityContextHolder que é objeto que lida com o contexto de segurança da aplicação.

\n

Analisando a TokenService no método getTokenId:

\n
\tpublic Integer getTokenId(String token) {\n\t\tClaims body = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();\n\t\treturn Integer.valueOf(body.getSubject());\n\t}
\n

Vemos que aqui novamente fazemos uso da biblioteca jsonwebtoken mas agora pegamos o body para recuperar o Subject.

\n

Após iniciarmos a aplicação e autenticarmos com um usuário já cadastrado conseguimos acessar a rota que o Actuator expõe e até o momento estava inacessível.

\n

Aqui fazemos a autenticação e recebemos o token na resposta.

\n

\n \n \n

\n

E agora com o JWT no Header de Authorization fazemos o GET para a url protegida.

\n

\n