Comment utiliser Spring Boot pour implémenter l'authentification de sécurité et la gestion des autorisations

Avec le développement d'Internet, la sécurité des applications est devenue très importante et chaque programmeur doit prêter attention aux problèmes de sécurité. Étant donné que le framework Spring est largement utilisé dans les applications d'entreprise à grande échelle, Spring Boot est un choix très populaire pour développer des applications Web. Dans cet article, nous apprendrons comment utiliser Spring Boot pour implémenter l'authentification de sécurité et la gestion des autorisations.

1. Authentification et autorisation

Avant de commencer à discuter de la mise en œuvre par Spring Boot de l'authentification et de l'autorisation de sécurité, nous devons comprendre ce que sont l'authentification et l'autorisation.

L'authentification consiste à confirmer si l'identité d'une entité est légale. Dans les applications Web, il s'agit généralement de confirmer si l'utilisateur est un utilisateur légitime.

L'autorisation consiste à accorder des autorisations d'exploitation spécifiques à une entité après avoir confirmé qu'elle est légale. Dans les applications Web, il est courant de confirmer que l'utilisateur dispose des droits d'accès appropriés à la ressource demandée.

2. Spring Boot Security Framework

Spring Boot fournit un cadre de sécurité qui peut facilement mettre en œuvre l'authentification de sécurité et la gestion des autorisations pour les applications Web. Spring Security fait partie du cadre de sécurité Spring Boot. Il fournit un cadre configurable pour garantir que les applications peuvent s'exécuter en toute sécurité.

Spring Security fournit les fonctions suivantes :

1. Authentification et autorisation de sécurité

2 Prise en charge HTTPS

3. Prise en charge des demandes inter-domaines

5. Prise en charge LDAP

7, prise en charge OpenID

8, prise en charge OAuth 2.0

3. Configuration de la sécurité Spring Boot

Avant de commencer à utiliser Spring Boot pour implémenter l'authentification et l'autorisation de sécurité, nous devons comprendre la configuration de sécurité de Spring Boot.

Spring Boot utilise la configuration et les annotations Java pour configurer la sécurité. La configuration de la sécurité est définie dans une classe annotée avec @EnableWebSecurity pour activer la sécurité, puis définit une classe qui hérite de WebSecurityConfigurerAdapter pour configurer la sécurité.

Voici un exemple de configuration de sécurité de base de Spring Boot :

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasAnyRole("ADMIN", "USER")
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }
    
    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
                .withUser("admin").password("admin").roles("ADMIN")
                .and()
                .withUser("user").password("user").roles("USER");
    }
}

Dans la configuration ci-dessus, nous activons la sécurité à l'aide de l'annotation @EnableWebSecurity, puis définissons une classe qui hérite de WebSecurityConfigurerAdapter. La méthode

configure() sera appelée lorsque l'application démarrera pour définir les règles de sécurité des requêtes HTTP. Dans cet exemple, nous définissons trois règles :

1. Toute URL commençant par /admin/ n'est accessible qu'aux utilisateurs ayant le rôle d'ADMIN.

2. Toute URL commençant par /user/ permet aux utilisateurs ayant le rôle d'ADMIN ou d'UTILISATEUR d'accéder.

3. Toutes les autres demandes nécessitent une authentification.

La méthode formLogin() définit l'emplacement du formulaire de connexion et permet à tous les utilisateurs d'y accéder.

La méthode logout() définit la fonction de déconnexion et permet l'accès à tous les utilisateurs. La méthode

configureGlobal() configure un schéma d'authentification en mémoire, comprenant le nom d'utilisateur et le mot de passe ainsi que les rôles attribués.

Ceci n'est qu'un exemple simple, des configurations de sécurité plus complexes peuvent être configurées à l'aide de diverses options Spring Security.

4. Fournisseur d'authentification

Dans l'exemple de configuration ci-dessus, nous avons utilisé un schéma d'authentification en mémoire. Cependant, en réalité, nous utilisons généralement une base de données pour stocker les informations des utilisateurs. Spring Security nous fournit des fournisseurs d'authentification pour gérer l'authentification.

Dans Spring Security, un fournisseur d'authentification est une interface dans laquelle la méthode Authenticate() doit être implémentée pour effectuer l'authentification. Les fournisseurs d'authentification peuvent être en mémoire, sur une base de données relationnelle ou basés sur LDAP, etc.

Voici un exemple de fournisseur d'authentification basé sur une base de données :

@Service
public class UserDetailsServiceImp implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByName(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }
        return new org.springframework.security.core.userdetails.User(user.getName(), user.getPassword(),
                AuthorityUtils.createAuthorityList(user.getAuthorities()));
    }
}

Dans le code ci-dessus, nous avons défini une classe UserDetailsServiceImp qui implémente l'interface UserDetailsService. La méthode loadUserByUsername() charge les informations utilisateur à partir de la base de données et renvoie l'objet UserDetails de Spring Security, qui contient le nom d'utilisateur, le mot de passe et l'autorisation.

5. Gestion des autorisations

Dans Spring Boot, nous pouvons utiliser Spring Security pour la gestion des autorisations basée sur les rôles. Spring Security propose deux méthodes de gestion des autorisations : déclarative et programmatique.

1. Déclarative

Dans l'autorisation déclarative, nous pouvons utiliser les annotations @PreAuthorize et @PostAuthorize pour définir des règles de contrôle d'accès. @PreAuthorize est utilisé pour spécifier les conditions qui doivent être remplies avant d'accéder à la méthode, tandis que @PostAuthorize est utilisé pour spécifier les conditions qui doivent être remplies avant de revenir.

Ce qui suit est un exemple de gestion des autorisations basée sur la déclaration :

@Service
public class ProductService {
    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public void addProduct() {
        // add product
    }
    
    @PreAuthorize("hasRole('ROLE_USER')")
    @PostAuthorize("returnObject.owner == authentication.name")
    public Product findProductByName(String name) {
        // find product by name
    }
}

Dans le code ci-dessus, nous avons ajouté des annotations @PreAuthorize aux méthodes addProduct() et findProductByName() pour définir des règles de contrôle d'accès.

Dans la méthode addProduct(), nous limitons l'accès des utilisateurs ayant le rôle ROLE_ADMIN à cette méthode.

Dans la méthode findProductByName(), nous limitons l'accès à la méthode aux utilisateurs dotés du rôle ROLE_USER et définissons une autre règle de contrôle d'accès à l'aide de l'annotation @PostAuthorize pour garantir que seul le propriétaire du produit retourné est authentifié. Le produit sera uniquement renvoyé. quand les utilisateurs sont les mêmes.

2. Programmatique

Dans l'autorisation programmatique, nous pouvons utiliser l'API Spring Security pour définir des règles de contrôle d'accès.

Ce qui suit est un exemple de gestion des autorisations programmatiques :

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserService userService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasAnyRole("ADMIN", "USER")
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll()
                .and()
            .csrf().disable()
            .exceptionHandling().accessDeniedHandler(accessDeniedHandler());
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
    }
    
    @Bean
    public AccessDeniedHandler accessDeniedHandler(){
        return new CustomAccessDeniedHandler();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

在上面的代码中，我们定义了一个UserService类来处理用户信息，并在configure()方法中使用了accessDeniedHandler()方法来定制访问被拒绝时的错误信息。

我们还实现了一个CustomAccessDeniedHandler类来自定义访问被拒绝时的响应。

最后，我们使用了PasswordEncoder来编码密码。

六、结论

在本文中，我们了解了如何使用Spring Boot实现安全认证和授权管理。我们已经讨论了Spring Boot安全框架、安全配置、身份验证提供器和授权管理等关键概念。我们还讨论了如何使用声明式和编程式授权管理。通过使用Spring Boot的安全框架，我们可以轻松地为Web应用程序提供安全性，并确保应用程序可以安全地运行。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!