Définition de Spring Security
Spring Security est un Framework de sécurité léger qui fournit une authentification et un support d’autorisation afin de sécuriser les applications Spring. Il est livré avec des implémentations d’algorithmes de sécurité populaires.
Cet article nous guide tout au long du processus de création d’un simple exemple de connexion à une application avec Spring Boot, Spring Security, Spring Data JPA et MYSQL
Configuration d’application
Commençons par une application très basique (en termes d’installation nécessaire) qui démarre un contexte d’application Spring. Deux outils qui nous aideront avec cela sont Maven et Spring Boot. Je sauterai les lignes qui ne sont pas particulièrement intéressantes comme la configuration du référentiel Maven. Vous pouvez trouver le code complet sur GitHub.
Pour commencer nous allons ajouter la dépendance suivante au pom de notre application.
1. <dependency> 2. <groupId>org.springframework.boot</groupId> 3. <artifactId>spring-boot-starter-security</artifactId> 4. </dependency>
Au démarrage de notre application nous avons dans la console les informations suivantes :
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v2.0.4.RELEASE) 2023-08-10 22:44:09.059 INFO 645 --- [main] .s.s.UserDetailsServiceAutoConfiguration : Using generated security password: c657aef6-758a-409d-ac02-814ff4df55be
Spring Boot nous fournit donc un mot de passe par défaut.
Nous venons d’ajouter Spring Security au classpath de notre application, Spring instaure une configuration par défaut, désormais pour accéder à notre application nous aurons besoin d’un User et d’un mot de passe.
Donc pour accéder à notre application avec la configuration par défaut de Spring, nous entrons l’user comme nom d’utilisateur user et le mot de passe par défaut fourni par Spring, celui affiché dans la console au démarrage de notre application (ici c657aef6-758a-409d-ac02-814ff4df55be) dans le formulaire d’authentification.
Dans la suite de cet article, nous allons personnaliser cette configuration.
Création de l’entité User
Nous allons créer la classe User.java, cette classe implémente interface UserDetails.
L’interface fournit des informations sur l’utilisateur principal. Les implémentations ne sont pas utilisées directement par Spring Security à des fins de sécurité. Ils stockent simplement les informations utilisateur qui sont ensuite encapsulées dans des objets d’authentification. Cela permet de stocker des informations non liées à la sécurité (telles que les adresses e-mail etc.) dans un emplacement approprié.
@Entity
@Table(name = "USER")
public class User implements Serializable , UserDetails {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer userId;
private String username;
private String password;
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getUsername() {
return username;
}
@Override
public boolean isAccountNonExpired() {
return false;
}
@Override
public boolean isAccountNonLocked() {
return false;
}
@Override
public boolean isCredentialsNonExpired() {
return false;
}
@Override
public boolean isEnabled() {
return false;
}
public void setUsername(String username) {
this.username = username;
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return null;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
Ci-dessous les scripts d’alimentation de notre table dans la base de données embarquée H2. Le script est placé dans le fichier data.sql, les scripts situés dans le fichier data.sql sont exécutés à chaque démarrage de notre application.
INSERT INTO USER(username, password) VALUES('ADMIN', 'ADMIN')
Implémentation de La classe AppAuthenticationProvider
Spring Security fournit une variété d’options pour effectuer l’authentification. Toutes ces options suivent un contrat simple. Une demande d’authentification est traitée par un AuthenticationProvider et un objet entièrement authentifié avec des informations d’identification complètes est renvoyé.
L’implémentation standard et la plus courante est le DaoAuthenticationProvider – qui récupère les détails de l’utilisateur à partir d’un simple DAO utilisateur en lecture seule – le UserDetailsService. Ce service de détails de l’utilisateur a uniquement accès au nom d’utilisateur afin de récupérer l’entité utilisateur complète et dans un grand nombre de scénarios, cela suffit.
public class AppAuthProvider extends DaoAuthenticationProvider {
@Autowired
UserService userDetailsService;
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
UsernamePasswordAuthenticationToken auth = (UsernamePasswordAuthenticationToken) authentication;
String name = auth.getName();
String password = auth.getCredentials()
.toString();
UserDetails user = userDetailsService.loadUserByUsername(name);
if (user == null) {
throw new BadCredentialsException("Username/Password does not match for " + auth.getPrincipal());
}
return new UsernamePasswordAuthenticationToken(user, null, user.getAuthorities());
}
@Override
public boolean supports(Class<?> authentication) {
return true;
}
}
Implémentation du Repository UserRepository
Nous allons créer la classe UserRepository.java, cette classe hérite de la classe JpaRepository. La fonction findUserWithName(String name) permet de récupérer un User à partir de son nom d’utilisateur.
public interface UserRepository extends JpaRepository<User, Integer> {
@Query(" select u from User u " +
" where u.username = ?1")
Optional<User> findUserWithName(String username);
}
Implémentation du Service UserService
Nous allons créer la classe UserService.java, cette classe implémente interface UserDetailsService. L’interface UserDetailsService est utilisée pour récupérer les données liées à l’utilisateur. Il a une méthode nommée loadUserByUsername qui trouve une entité utilisateur basée sur le nom d’utilisateur et peut être substituée pour personnaliser le processus de recherche de l’utilisateur. Il est utilisé par DaoAuthenticationProvider pour charger des détails sur l’utilisateur lors de l’authentification.
@Service
@Slf4j
public class UserService implements UserDetailsService {
private final UserRepository userRepository;
@Autowired
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
Objects.requireNonNull(username);
User user = userRepository.findUserWithName(username)
.orElseThrow(() -> new UsernameNotFoundException("User not found"));
return user;
}
}
Implémentation de la classe de configuration SecurityConfig
Pour personnaliser la configuration nous allons créer une classe qui hérite de WebSecurityConfigurerAdaptater. Cette classe doit avoir les annotations @EnableWebSecurity et @Configuration. Les classes de configuration sont scannées au démarrage de l’application.
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
UserService userDetailsService;
@Autowired
private AccessDeniedHandler accessDeniedHandler;
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService);
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.csrf()
.disable()
.exceptionHandling()
.authenticationEntryPoint(new Http403ForbiddenEntryPoint() {
})
.and()
.authenticationProvider(getProvider())
.formLogin()
.loginProcessingUrl("/login")
.successHandler(new AuthentificationLoginSuccessHandler())
.failureHandler(new SimpleUrlAuthenticationFailureHandler())
.and()
.logout()
.logoutUrl("/logout")
.logoutSuccessHandler(new AuthentificationLogoutSuccessHandler())
.invalidateHttpSession(true)
.and()
.authorizeRequests()
.antMatchers("/login").permitAll()
.antMatchers("/logout").permitAll()
.antMatchers("/user").authenticated()
.anyRequest().permitAll();
}
private class AuthentificationLoginSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {
@Override
public void onAuthenticationSuccess(HttpServletRequest request,
HttpServletResponse response, Authentication authentication)
throws IOException, ServletException {
response.setStatus(HttpServletResponse.SC_OK);
}
}
private class AuthentificationLogoutSuccessHandler extends SimpleUrlLogoutSuccessHandler {
@Override
public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response,
Authentication authentication) throws IOException, ServletException {
response.setStatus(HttpServletResponse.SC_OK);
}
}
@Bean
public AuthenticationProvider getProvider() {
AppAuthProvider provider = new AppAuthProvider();
provider.setUserDetailsService(userDetailsService);
return provider;
}
}
Nous définissons la manière donc sont gérés les utilisateurs dans la méthode configure(AuthenticationManagerBuilder auth). Ici la gestion des utilisateurs est dynamique, on gère les utilisateurs via le service UserSevice.
La gestion des ressources à protéger se fait au niveau de la fonction configure(HttpSecurity http). Tout accès à url <host>/user/** nécessite d’être authentifié. L’authentification se fait via une requête de type Post à url <host>/login.
Tests Postman
Nous allons tester accès à notre application en utilisant Postman Rest qui est un client pour API web.
En accédant à GET : <host>/user/ nous avons une erreur d’authentification comme ci-dessous :
Accès à GET : <host>/user/ nécessite d’être authentifié au préalable.
Pour nous authentifier nous allons accéder à POST : <host>/login avec un User présent dans notre base de données.
Nous avons un Statut 200, authentification a donc fonctionné.
Nous allons donc à nouveau accéder à GET : <host>/user/
Le mot de la fin
Cet article nous a montré comment utiliser Spring Security pour sécuriser son application Spring Boot. Vous pouvez trouver le code complet sur GitHub.
