Como posso atualizar tokens na segurança do Spring

Aug 15 2020

Está linha:

Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody();

Lança um erro como este quando meu token jwt expira:

JWT expirou em 2020-05-13T07:50:39Z. Hora atual: 2020-05-16T21:29:41Z.

Mais especificamente, é esta função que lança a exceção "ExpiredJwtException":

Como faço para lidar com essas exceções? Devo pegá-los e enviar de volta ao cliente uma mensagem de erro e forçá-los a fazer login novamente?

Como posso implementar um recurso de tokens de atualização? Estou usando Spring e mysql no back-end e vuejs no front-end.

Eu gero o token inicial assim:

   @Override
        public JSONObject login(AuthenticationRequest authreq) {
            JSONObject json = new JSONObject();
    
            try {
                Authentication authentication = authenticationManager.authenticate(
                        new UsernamePasswordAuthenticationToken(authreq.getUsername(), authreq.getPassword()));
    
                UserDetailsImpl userDetails = (UserDetailsImpl) authentication.getPrincipal();
                List<String> roles = userDetails.getAuthorities().stream().map(item -> item.getAuthority())
                        .collect(Collectors.toList());
    
                if (userDetails != null) {
    
                    final String jwt = jwtTokenUtil.generateToken(userDetails);
    
    
                    JwtResponse jwtres = new JwtResponse(jwt, userDetails.getId(), userDetails.getUsername(),
                            userDetails.getEmail(), roles, jwtTokenUtil.extractExpiration(jwt).toString());
    
                    return json.put("jwtresponse", jwtres);
                }
            } catch (BadCredentialsException ex) {
                json.put("status", "badcredentials");
            } catch (LockedException ex) {
                json.put("status", "LockedException");
            } catch (DisabledException ex) {
                json.put("status", "DisabledException");
            }
    
            return json;
        }

E então na classe JwtUtil:

   public String generateToken(UserDetails userDetails) {
            Map<String, Object> claims = new HashMap<>();
            return createToken(claims, userDetails.getUsername());
        }
    
   private String createToken(Map<String, Object> claims, String subject) {
            return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
                    .setExpiration(new Date(System.currentTimeMillis() + EXPIRESIN))
                    .signWith(SignatureAlgorithm.HS256, SECRET_KEY).compact();
        }

Para mais informações, aqui está minha função doFilterInternal que filtra todas as solicitações:

   @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException, ExpiredJwtException, MalformedJwtException {

        try {

            final String authorizationHeader = request.getHeader("Authorization");

            String username = null;
            String jwt = null;

            if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
                jwt = authorizationHeader.substring(7);
                username = jwtUtil.extractUsername(jwt);
            }

            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                UserDetails userDetails = userService.loadUserByUsername(username);

                boolean correct = jwtUtil.validateToken(jwt, userDetails);

                if (correct) {
                    UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                            userDetails, null, userDetails.getAuthorities());

                    usernamePasswordAuthenticationToken
                            .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);

                }
            }

            chain.doFilter(request, response);
        } catch (ExpiredJwtException ex) {
            resolver.resolveException(request, response, null, ex);
        }
    } 

Respostas

3 doctore Aug 16 2020 at 17:38

Existem 2 abordagens principais para lidar com tais situações:


Gerenciar tokens de acesso e atualização

Neste caso, o fluxo é o seguinte:

  1. O usuário faz login no aplicativo (incluindo usernamee password)

  2. Seu aplicativo de back-end retorna todas as informações de credenciais necessárias e:

    2.1 Acesse o token JWT com um tempo expirado geralmente "baixo" (15, 30 minutos, etc).

    2.2 Atualize o token JWT com um tempo expirado maior que o de acesso.

  3. A partir de agora, seu aplicativo de front-end usará access tokeno Authorizationcabeçalho para cada solicitação.

Quando o backend retornar 401, o aplicativo frontend tentará usar refresh token(usando um endpoint específico) para obter novas credenciais, sem forçar o usuário a fazer login novamente.

Fluxo de token de atualização (este é apenas um exemplo, geralmente apenas o token de atualização é enviado)

Se não houver nenhum problema, o usuário poderá continuar usando o aplicativo. Se o backend retornar um novo 401=> frontend deve redirecionar para a página de login.


Gerenciar apenas um token Jwt

Nesse caso, o fluxo é semelhante ao anterior e você pode criar seu próprio endpoint para lidar com tais situações: /auth/token/extend(por exemplo), incluindo o Jwt expirado como parâmetro da solicitação.

Agora cabe a você gerenciar:

  • Quanto tempo um token Jwt expirado será "válido" para estendê-lo?

O novo endpoint terá um comportamento semelhante ao do refresh da seção anterior, ou seja, retornará um novo token Jwt ou algo 401assim, do ponto de vista do frontend o fluxo será o mesmo.


Uma coisa importante , independentemente da abordagem que você deseja seguir, o "novo endpoint" deve ser excluído dos endpoints autenticados pelo Spring necessários, porque você mesmo gerenciará a segurança:

public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
  ..

  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.
      ..
      .authorizeRequests()
      // List of services do not require authentication
      .antMatchers(Rest Operator, "MyEndpointToRefreshOrExtendToken").permitAll()
      // Any other request must be authenticated
      .anyRequest().authenticated()
      ..
   }
}
2 QuocTruong Aug 16 2020 at 18:18

Você pode chamar a API para obter o token de atualização conforme abaixo

POST https://yourdomain.com/oauth/token 

Header
  "Authorization": "Bearer [base64encode(clientId:clientSecret)]" 

Parameters
  "grant_type": "refresh_token"
  "refresh_token": "[yourRefreshToken]"

Observe que, o

  • base64encode é o método para criptografar a autorização do cliente. Você pode usar online emhttps://www.base64encode.org/
  • o refresh_token é o valor String do grant_type
  • yourRefreshToken é o token de atualização recebido com o token de acesso JWT

O resultado pode ser visto como

{
    "token_type":"bearer",
    "access_token":"eyJ0eXAiOiJK.iLCJpYXQiO.Dww7TC9xu_2s",
    "expires_in":20,
    "refresh_token":"7fd15938c823cf58e78019bea2af142f9449696a"
}

Boa sorte.