Como posso atualizar tokens na segurança do Spring
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
Existem 2 abordagens principais para lidar com tais situações:
Gerenciar tokens de acesso e atualização
Neste caso, o fluxo é o seguinte:
O usuário faz login no aplicativo (incluindo
username
epassword
)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.
A partir de agora, seu aplicativo de front-end usará
access token
oAuthorization
cabeç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 401
assim, 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()
..
}
}
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.