Spring Security

Configuration de Spring Security

La configuration de Spring Security est essentielle pour sécuriser les applications Spring. Ce guide couvre les bases de la configuration, y compris l'authentification et l'autorisation, ainsi que la création des entités nécessaires. Vous apprendrez également à configurer les couches Repository et Service, et à mettre en place la sécurité au niveau de l'application.

Introduction à Spring Security

Spring Security est un framework de sécurité léger qui fournit des mécanismes d'authentification et d'autorisation pour sécuriser les applications Spring. Il répond à deux questions majeures :

• Qui peut accéder à l’application ? Cela concerne l'authentification.
• Est-ce que l’utilisateur connecté a le droit d’accéder à cette ressource ? Cela concerne l'autorisation, qui détermine si un utilisateur peut accéder à une ressource spécifique.

Configuration de Spring Security

Dépendances

Pour configurer la sécurité dans un projet Spring Boot, il est nécessaire d'ajouter les dépendances Spring Security dans le fichier pom.xml. Après cela, il suffit de faire un clean install et un maven update du projet.

Création des entités User et Role

Pour gérer l'authentification et l'accès aux différentes fonctionnalités, il est nécessaire de créer deux entités : User et Role.

• Chaque utilisateur a des attributs pour se connecter, tels que username et password.
• Les utilisateurs peuvent avoir des rôles tels que ADMIN ou SUPERADMIN.
• L'association entre utilisateurs et rôles est de type ManyToMany.

Voici un exemple de code pour créer les entités :

@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Role implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;
    @Enumerated(EnumType.STRING)
    private RoleName role;
}

@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;
    private String userName;
    private String email;
    private String password;
    private String name;
    private String lastName;
    private Boolean active;
    @ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.EAGER)
    private Set<Role> roles;
}

Configuration de la couche Repository

Dans la couche Repository, il faut créer les interfaces UserRepository et RoleRepository :

@Repository
public interface UserRepository extends CrudRepository<User, Long> {
    User findByUserName(String userName);
}

@Repository
public interface RoleRepository extends CrudRepository<Role, Integer> {
    Role findByRole(String role);
}

Configuration de la couche Service

Dans la couche Service, créez la classe MyUserDetailsService qui implémente UserDetailsService. Cette classe permet de retourner des informations sur l'utilisateur connecté :

@Service
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private UserService userService;

    @Override
    @Transactional
    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {
        User user = userService.findUserByUserName(userName);
        List<GrantedAuthority> authorities = getUserAuthority(user.getRoles());
        return new org.springframework.security.core.userdetails.User(user.getUserName(),
            user.getPassword(), user.getActive(), true, true, true, authorities);
    }

    private List<GrantedAuthority> getUserAuthority(Set<Role> userRoles) {
        Set<GrantedAuthority> roles = new HashSet<>();
        for (Role role : userRoles) {
            roles.add(new SimpleGrantedAuthority(role.getRole()));
        }
        return new ArrayList<>(roles);
    }
}

Configuration de la classe SecurityConfig

Dans la couche sécurité, créez la classe WebSecurityConfiguration pour configurer la sécurité de l'application :

@Configuration
@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
    @Autowired
    private MyUserDetailsService userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/registration").permitAll()
            .antMatchers("/getRevenuBrutProduit/{idProduit}/{startDate}/{endDate}").access("hasRole('SUPERADMIN')")
            .antMatchers("/retrieve-all-clients").access("hasRole('ADMIN')")
            .anyRequest().authenticated()
            .and().httpBasic().and().csrf().disable();
    }
}

Configuration de la couche Controller

Exposez le service de registration dans un contrôleur :

@RestController
public class HomeController {
    @Autowired
    UserService userService;

    @PostMapping("/registration")
    public String createNewUser(@RequestBody User user) {
        String msg = "";
        User userExists = userService.findUserByUserName(user.getUserName());
        if (userExists != null) {
            msg = "Il existe déjà un utilisateur enregistré avec ce nom d'utilisateur.";
        } else {
            userService.saveUser(user);
            msg = "OK";
        }
        return msg;
    }
}

Points clés à retenir

• Spring Security offre des mécanismes d'authentification et d'autorisation.
• Les entités User et Role sont essentielles pour gérer les utilisateurs et leurs permissions.
• La configuration des couches Repository, Service et Controller est cruciale pour une bonne mise en œuvre.

Glossaire

• Spring Security : Framework de sécurité pour les applications Spring.
• Authentication : Processus de vérification de l'identité d'un utilisateur.
• Authorization : Processus de détermination des permissions d'accès d'un utilisateur.
• UserDetailsService : Interface pour charger les détails d'un utilisateur.
• Repository : Couche d'accès aux données dans une application.

Questions fréquentes

Qu'est-ce que Spring Security ?

Spring Security est un framework qui fournit des fonctionnalités d'authentification et d'autorisation pour sécuriser les applications Spring. Il permet de contrôler l'accès aux ressources en fonction des rôles des utilisateurs.

Comment configurer les entités User et Role ?

Les entités User et Role doivent être créées avec les annotations appropriées. User contient des attributs tels que username et password, tandis que Role définit les différents rôles d'accès. L'association entre User et Role est de type ManyToMany.

Quelle est la différence entre authentification et autorisation ?

L'authentification vérifie l'identité d'un utilisateur, tandis que l'autorisation détermine les permissions d'accès de cet utilisateur aux ressources de l'application.

Comment configurer la sécurité dans une application Spring ?

La sécurité dans une application Spring se configure en créant une classe de configuration qui étend WebSecurityConfigurerAdapter. Il faut définir les chemins d'URL sécurisés et les rôles d'accès appropriés.

Quels sont les rôles disponibles dans Spring Security ?

Dans Spring Security, les rôles courants incluent ADMIN et SUPERADMIN. Ces rôles déterminent les permissions d'accès aux différentes fonctionnalités de l'application.