sécurité de démarrage de démarrage authentification dao - autorités supprimées

Question

Développement d'une application de démarrage à ressort qui implémente la sécurité basée sur la base de données d'authentification de base basée sur la base de données de sécurité. Ont implémenté UserDetailsService et remplacer la méthode loadUserByUsername. En passant par la méthode, je trouve que le nom d'utilisateur, le mot de passe et les informations de rôle sont récupérés avec succès à partir de ma table d'utilisateur de base de données.

Code Mon UserDetailsService loadUserByUsername est

@Override 
public UserDetails loadUserByUsername(String userName) 
     throws UsernameNotFoundException { 
    UserInfo activeUserInfo = userInfoDAO.getActiveUser(userName); 
    SimpleGrantedAuthority authority = new SimpleGrantedAuthority(activeUserInfo.getRole()); 
    User(activeUserInfo.getUserName(), 
      activeUserInfo.getPassword(), Arrays.asList(authority)); 
    return userDetails; 
} 

Reculant dans DaoAUthenticationProvider retrieveUser contient les valeurs renvoyées de la table utilisateur recherche mais la méthode d'authentification AbstractUserDetailsAuthenticationProvider montre les autorités comme un tableau de longueur zéro, le nom d'utilisateur et mot de passe sont correctement revenu. Le fait de ne pas avoir la valeur d'autorité entraîne le renvoi d'une erreur 401 d'informations d'identification incorrectes.

Je suis en train de tester avec un facteur. Travailler avec MySql 5.7.11 avec une table utilisateur définie à l'aide ceci:

CREATE TABLE IF NOT EXISTS `users` (
    `username` varchar(50) NOT NULL, 
    `password` varchar(100) NOT NULL, 
    `full_name` varchar(100) NOT NULL, 
    `role` varchar(50) NOT NULL, 
    `country` varchar(100) NOT NULL, 
    `enabled` tinyint(1) NOT NULL, 
    PRIMARY KEY (`username`) 
); 

Le mot de passe est enregistré à l'aide de la BCryptPasswordEncoder et je envoie le mot de passe en texte clair via postier.

Mes application.properties sont définies comme suit:

spring.datasource.url=jdbc:mysql://localhost:3306/actotracker?useSSL=false 
spring.datasource.username=root 
spring.datasource.password=Dial0gicRots 
spring.datasource.tomcat.max-wait=20000 
spring.datasource.tomcat.max-active=50 
spring.datasource.tomcat.max-idle=20 
spring.datasource.tomcat.min-idle=15 
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQLDialect 
spring.jpa.properties.hibernate.id.new_generator_mappings = false 
spring.jpa.properties.hibernate.format_sql = true 
security.basic.enabled=true 
security.basic.realm=Spring 
logging.level.org.hibernate.SQL=DEBUG 
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE 

ont essayé régler manuellement les valeurs des autorités à « ROLE_ADMIN » sans impact sur les résultats. Pointers sur ce que je fais mal?

Java version 1.8 boot Spring 1.5.3.RELEASE

code où j'enregistrer le codeur de mot de passe:

private final Logger log = LoggerFactory.getLogger(MyApplication.class); 
@Autowired 
private AppUserDetailService appUserDetailsService; 
@Autowired 
private AppAuthenticationEntryPoint appAuthenticationEntryPoint; 
@Override 
protected void configure(HttpSecurity http) throws Exception { 
    log.info("In configure"); 
    http.csrf().disable() 
      .authorizeRequests() 
      .antMatchers("/user/**").hasAnyRole("ROLE_ADMIN","ROLE_USER") 
      .and().httpBasic().realmName("Spring") 
     // .and().httpBasic() 
      .authenticationEntryPoint(appAuthenticationEntryPoint); 
} 
@Autowired 
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { 
    log.info("configGlobal"); 
    BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder(); 
    auth.userDetailsService(appUserDetailsService).passwordEncoder(passwordEncoder); 
} 

valeurs Postman: http://localhost:8080/user/distances champ Nom d'utilisateur: tim mot de passe: mot de passe en texte clair valeur l'authentification est réglée sur l'authentification de base

Answer 1

dur était correct, le 401 était cause d par une non-concordance de mot de passe. J'avais écrit une petite routine pour prendre une chaîne de texte en clair et la chiffrer. `

 String creds = "xxxxxxx";  
     BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder(); 
     String encPassword = bCryptPasswordEncoder.encode(creds); 

I utilisé/stocké dans la valeur encPassword ma table d'authentification de l'utilisateur.

En entrant dans la classe BCryptPasswordEncoder, BCrypt.checkpw, j'ai trouvé que ma chaîne de texte brut était convertie en une valeur chiffrée différente. Mise à jour de l'entrée de la table utilisateur de la base de données avec la nouvelle valeur chiffrée et mon autorisation a été acceptée.