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]

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é.

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.

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.

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>

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.

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.

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.