In questo articolo illustrerò come realizzare un’autenticazione via REST ad un web-service realizzato in Spring, usando un token JWT. Si tratta di un articolo di esempio e la soluzione proposta non è che una delle molteplici possibili grazie alla flessibilità del framework.
Questo articolo è parte di una serie dedicata al celebre framework Java ed è di supporto alle lezioni che tengo offline. Tuttavia, la lettura è libera per chiunque sia interessato. Buona lettura!
Immaginiamo di avere un’applicazione REST realizzata con Spring. Vogliamo rendere quest’applicazione sicura e per farlo abbiamo deciso di implementare un login che restituisca un token JWT, che andrà poi aggiunto ad ogni request successiva.
Cos’è il JWT?
L’acronimo JWT sta per JSON Web Token ed è uno standard per i token di autenticazione in voga ormai da qualche anno. Un token JWT è una lunga stringa, divisa in tre parti dal carattere punto (.): header, body e signature. Il token è codificato con un algoritmo predefinito e solitamente “porta” nel body informazioni quali il nome utente e/o i permessi di quest’ultimo. Quando si fa uso di token JWT, infatti, solitamente significa che facciamo uso di server stateless, in modo da evitare i problemi e gli attacchi legati all’uso di quest’ultima. ATTENZIONE: il token è codificato, non è cifrato. Questo significa che chiunque intercetti il token può decodificarlo e leggere le informazioni ivi contenute. Un token, infine, ha solitamente un tempo massimo di validità, oltre il quale è necessario un nuovo token per accedere alle risorse protette.
1. Dipendenze
pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.0</version>
</dependency>2. Configurazione Security
Come prima cosa occorre configurare la Security.
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
public void configureAuthentication(AuthenticationManagerBuilder authenticationManagerBuilder, UserDetailsService userDetailService) throws Exception {
authenticationManagerBuilder
.userDetailsService(userDetailService)
.passwordEncoder(passwordEncoder());
}
@Bean
public AuthenticationManager customAuthenticationManager() throws Exception {
return authenticationManager();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public JwtAuthenticationTokenFilter authenticationTokenFilterBean() throws Exception {
return new JwtAuthenticationTokenFilter();
}
// configurazione Cors per poter consumare le api restful con richieste ajax
@Bean
CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration configuration = new CorsConfiguration();
configuration.addAllowedOrigin("*");
configuration.setAllowedMethods(Arrays.asList("POST, PUT, GET, OPTIONS, DELETE"));
configuration.addAllowedHeader("*");
configuration.addAllowedMethod("*");
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", configuration);
return source;
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity
.csrf().disable()
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
.cors().and()
.addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class)
.authorizeRequests()
.antMatchers("/login")
.permitAll()
.anyRequest().authenticated();
httpSecurity.headers().cacheControl();
}
}Il Sistema viene impostato stateless e un apposito filtro viene configurato all’inizio di ogni Request (add before): JwtAuthenticationTokenFilter,
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
private static final Logger logger = LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class);
@Autowired
private JwtTokenUtil jwtTokenUtil;
@Value("${jwt.header}")
private String tokenHeader;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
String authToken = request.getHeader(this.tokenHeader);
UserDetails userDetails = null;
if(authToken != null){
userDetails = jwtTokenUtil.getUserDetails(authToken);
}
if (userDetails != null && SecurityContextHolder.getContext().getAuthentication() == null) {
// Ricostruisco l userdetails con i dati contenuti nel token
// controllo integrita' token
if (jwtTokenUtil.validateToken(authToken, userDetails)) {
UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
SecurityContextHolder.getContext().setAuthentication(authentication);
}
}
chain.doFilter(request, response);
}
}Questo filtro ha il compito di verificare l’esistenza e la validità del token JWT.
3. Integrare JWT
Il filtro fa uso di una classe di appoggio chiamata JwtTokenUtil, che contiene tutti i metodi necessari per la codifica, decodifica, validazione e generazione del token.
@Component
public class JwtTokenUtil implements Serializable {
private static final long serialVersionUID = -3301605591108950415L;
static final String CLAIM_KEY_USERNAME = "sub";
static final String CLAIM_KEY_AUDIENCE = "audience";
static final String CLAIM_KEY_CREATED = "iat";
static final String CLAIM_KEY_AUTHORITIES = "roles";
static final String CLAIM_KEY_IS_ENABLED = "isEnabled";
private static final String AUDIENCE_MOBILE = "mobile";
private static final String AUDIENCE_TABLET = "tablet";
@Value("${jwt.secret}")
private String secret;
@Autowired
ObjectMapper objectMapper;
@Value("${jwt.expiration}")
private Long expiration;
public String getUsernameFromToken(String token) {
String username;
try {
final Claims claims = getClaimsFromToken(token);
username = claims.getSubject();
} catch (Exception e) {
username = null;
}
return username;
}
public JwtUser getUserDetails(String token) {
if(token == null){
return null;
}
try {
final Claims claims = getClaimsFromToken(token);
List<SimpleGrantedAuthority> authorities = null;
if (claims.get(CLAIM_KEY_AUTHORITIES) != null) {
authorities = ((List<String>) claims.get(CLAIM_KEY_AUTHORITIES)).stream().map(role-> new SimpleGrantedAuthority(role)).collect(Collectors.toList());
}
return new JwtUser(
claims.getSubject(),
"",
authorities,
(boolean) claims.get(CLAIM_KEY_IS_ENABLED)
);
} catch (Exception e) {
return null;
}
}
public Date getCreatedDateFromToken(String token) {
Date created;
try {
final Claims claims = getClaimsFromToken(token);
created = new Date((Long) claims.get(CLAIM_KEY_CREATED));
} catch (Exception e) {
created = null;
}
return created;
}
public Date getExpirationDateFromToken(String token) {
Date expiration;
try {
final Claims claims = getClaimsFromToken(token);
expiration = claims.getExpiration();
} catch (Exception e) {
expiration = null;
}
return expiration;
}
public String getAudienceFromToken(String token) {
String audience;
try {
final Claims claims = getClaimsFromToken(token);
audience = (String) claims.get(CLAIM_KEY_AUDIENCE);
} catch (Exception e) {
audience = null;
}
return audience;
}
private Claims getClaimsFromToken(String token) {
Claims claims;
try {
claims = Jwts.parser()
.setSigningKey(secret)
.parseClaimsJws(token)
.getBody();
} catch (Exception e) {
claims = null;
}
return claims;
}
private Date generateExpirationDate() {
return new Date(System.currentTimeMillis() + expiration * 1000);
}
private Boolean isTokenExpired(String token) {
final Date expiration = getExpirationDateFromToken(token);
return expiration.before(new Date());
}
private Boolean ignoreTokenExpiration(String token) {
String audience = getAudienceFromToken(token);
return (AUDIENCE_TABLET.equals(audience) || AUDIENCE_MOBILE.equals(audience));
}
public String generateToken(UserDetails userDetails) throws JsonProcessingException {
Map<String, Object> claims = new HashMap<>();
claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
claims.put(CLAIM_KEY_CREATED, new Date());
List<String> auth =userDetails.getAuthorities().stream().map(role-> role.getAuthority()).collect(Collectors.toList());
claims.put(CLAIM_KEY_AUTHORITIES, auth);
claims.put(CLAIM_KEY_IS_ENABLED,userDetails.isEnabled());
return generateToken(claims);
}
String generateToken(Map<String, Object> claims) {
return Jwts.builder()
.setClaims(claims)
.setExpiration(generateExpirationDate())
.signWith(SignatureAlgorithm.HS256, secret)
.compact();
}
public Boolean canTokenBeRefreshed(String token) {
return (!isTokenExpired(token) || ignoreTokenExpiration(token));
}
public String refreshToken(String token) {
String refreshedToken;
try {
final Claims claims = getClaimsFromToken(token);
claims.put(CLAIM_KEY_CREATED, new Date());
refreshedToken = generateToken(claims);
} catch (Exception e) {
refreshedToken = null;
}
return refreshedToken;
}
public Boolean validateToken(String token, UserDetails userDetails) {
JwtUser user = (JwtUser) userDetails;
final String username = getUsernameFromToken(token);
return (
username.equals(user.getUsername())
&& !isTokenExpired(token));
}
}La classe è etichettata come @Component per poter essere iniettata comodamente laddove ce ne sia bisogno. Infine la classe JwtUser, di cui la precedente ha bisogno, che implementa UserDetails
Manca ancora il servizio UserDetailsService, responsabile del caricamento dell’utente dal DB ed altri dettagli per il caricamento dell’utente. Non li riporto in quanto dipendono molto da scelte arbitrarie e non sono parte del cuore di questo esempio. Chi fosse interessato può trovare il progetto completo sul mio repository github.
4. Il Controller
Infine, il controller per l’autenticazione e la rigenerazione del token (token refresh):
@RestController
public class AuthenticationRestController {
private static final Logger logger = LoggerFactory.getLogger(AuthenticationRestController.class);
@Value("${jwt.header}")
private String tokenHeader;
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private JwtTokenUtil jwtTokenUtil;
@Autowired
private UserDetailsService userDetailsService;
@RequestMapping(value = "/login", method = RequestMethod.POST)
public ResponseEntity<?> createAuthenticationToken(@RequestBody JwtAuthenticationRequest authenticationRequest, HttpServletResponse response) throws AuthenticationException, JsonProcessingException {
final Authentication authentication = authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(
authenticationRequest.getUsername(),
authenticationRequest.getPassword()
)
);
SecurityContextHolder.getContext().setAuthentication(authentication);
// Genero Token
final UserDetails userDetails = userDetailsService.loadUserByUsername(authenticationRequest.getUsername());
final String token = jwtTokenUtil.generateToken(userDetails);
response.setHeader(tokenHeader,token);
// Ritorno il token
return ResponseEntity.ok(new JwtAuthenticationResponse(userDetails.getUsername(),userDetails.getAuthorities()));
}
@RequestMapping(value = "protected/refresh-token", method = RequestMethod.GET)
public ResponseEntity<?> refreshAndGetAuthenticationToken(HttpServletRequest request, HttpServletResponse response) {
String token = request.getHeader(tokenHeader);
UserDetails userDetails =
(UserDetails)SecurityContextHolder.getContext().getAuthentication().getPrincipal();
if (jwtTokenUtil.canTokenBeRefreshed(token)) {
String refreshedToken = jwtTokenUtil.refreshToken(token);
response.setHeader(tokenHeader,refreshedToken);
return ResponseEntity.ok(new JwtAuthenticationResponse(userDetails.getUsername(), userDetails.getAuthorities()));
} else {
return ResponseEntity.badRequest().body(null);
}
}
}application.properties:
jwt.header=Authorization
jwt.secret=....
jwt.expiration=7200Conclusioni
Spring Security è un potente insieme di librerie che semplificano molto la gestione della sicurezza nelle nostre applicazioni. Nell’esempio di questo articolo abbiamo visto come implementare la sicurezza per delle applicazioni REST usando un token JWT. Si tratta di una configurazione piuttosto comune, che è bene conoscere.
Spero di esservi stato utile!