[JAVA] Comment implémenter le processus d'authentification en spécifiant le nom d'utilisateur et le mot de passe dans Spring Boot

introduction

Dans le processus d'authentification de Spring Boot, j'ai étudié comment spécifier le mot de passe, ce que je me demandais depuis longtemps.

Aperçu

Nous vous montrerons comment implémenter le traitement d'authentification avec un nom d'utilisateur et un mot de passe dans Spring Boot et Spring Security.

L'environnement prérequis est le suivant.

[Problème] Le mot de passe ne peut pas être spécifié dans `ʻUserDetailsService``

Si vous allez dans "Spring Boot Authentication Process", vous trouverez de nombreux exemples utilisant loadUserByUsername de `ʻUserDetailsService`` [^ fqcn-uds]. J'ai aussi écrit. → Utiliser l'authentification de base avec Spring Boot

Cependant, comme indiqué ci-dessous, le seul argument pour loadUserByUsername est `ʻusername``.

UserDetailsService

UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;

Pour cette raison, il n'est pas possible de gérer les cas où le ** traitement d'authentification avec un nom d'utilisateur et un mot de passe spécifiés ** est requis. Par exemple, dans les cas suivants, `` loadUserByUsername '' ne peut pas être utilisé.

• Le hachage du mot de passe est effectué côté DB [^ cript], et il est nécessaire d'inclure le mot de passe dans la valeur du paramètre SQL.
• L'authentification est effectuée dans une bibliothèque externe et il est nécessaire de transmettre un nom d'utilisateur et un mot de passe à l'API.

[^ cript]: fonction `` crypt '' de PostgreSQL, etc.

[Solution] Utilisez `ʻAbstractUserDetailsAuthenticationProvider``

Utilisez ʻAbstractUserDetailsAuthenticationProvider`` [^ fqcn-audap] au lieu de ʻUserDetailsService. Plus précisément, en créant un Bean de `ʻAuthenticationProvider en utilisant` ʻAbstractUserDetailsAuthenticationProvider``, vous pouvez facilement implémenter ** le processus d'authentification en utilisant le nom d'utilisateur et le mot de passe **.

Exemple de code

Enregistrer le fournisseur d'authentification avec Java Config

@Configuration
public class MyConfigure extends WebSecurityConfigurerAdapter {
  //* L'authentification de base est requise pour toutes les URL pour vérifier le fonctionnement.
  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.httpBasic().realmName("My sample realm"); //Paramètres d'authentification de base
    http.authorizeRequests().anyRequest().authenticated(); //Définition des demandes nécessitant une authentification
  }


  // ----------------------------------------
  //Définition du haricot
  // ----------------------------------------

  @Bean
  public AuthenticationProvider getAuthenticationProvider() {
    //Utilisez votre propre fournisseur d'authentification
    return new MyUserDetailsAuthenticationProvider();
  }
}

Définition de votre propre fournisseur d'authentification

//En héritant de AbstractUserDetailsAuthenticationProvider, il est possible d'implémenter uniquement retrieveUser
public class MyUserDetailsAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider {
  private static final String DUMMY_PASSWORD = "DUMMY_PASSWORD"; //* Comme il n'est pas utilisé pour l'authentification, n'importe quelle valeur peut être utilisée.(les chaînes de caractères nulles et vides sont NG)
  private static final List<GrantedAuthority> AUTH_USER = AuthorityUtils.createAuthorityList("USER"); //* Dans cet exemple, tous ont cette autorité.

  // <<< N/A >>>
  @Override protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {}
  //---

  @Override
  protected UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
    String userId = username;
    String password = (String) authentication.getCredentials();

    //Vérifiez l'ID utilisateur et le mot de passe
    boolean isValid = AuthApi.isValidUserIdAndPassword(userId, password); //* Pseudo code qui s'authentifie avec l'API de la bibliothèque externe
    if (!isValid) { throw new UsernameNotFoundException(username); }

    //Implémentation des détails utilisateur(User)Est généré et utilisé comme valeur de retour
    return new User(username, DUMMY_PASSWORD, AUTH_USER);
  }
}

finalement

Comme je l'ai écrit au début, il y a beaucoup d'échantillons utilisant loadUserByUsername, mais pour une raison quelconque, il semblait y avoir peu d'échantillons utilisant des mots de passe pour le traitement de l'authentification, alors je l'ai recherché et l'ai écrit. Si vous avez des erreurs ou des améliorations, veuillez nous en informer.