Comment vérifier un mot de passe salé dans Spring Security?

Question

J'utilise Spring 3 et j'obtiens des utilisateurs d'une base de données MySQL.

À l'heure actuelle, lors des tests, j'ai un utilisateur avec un mot de passe MD5. Et je peux m'authentifier très bien en utilisant ça. Cependant, nous voulons être un peu plus en sécurité dans la façon dont nous haillons les mots de passe. Nous voulons:

MD5(username + salt + password) 

Le sel est une chaîne aléatoire stockée dans l'enregistrement utilisateur. Mais je n'arrive pas à comprendre où et comment le faire. Voilà ce que j'ai jusqu'à présent:

UserDao

public class UserDao { 

    public static Users findUserByUsername(String paUsername) { 
     String hql = "from Users where username = :username"; 

     List<Users> list = null; 
     Users user = null; 

     try { 
      IO io = new IO("web"); // custom Hibernate framework 
      IOQuery query = new IOQuery(); 
      query.setStatement(hql); 
      query.setParameter(new IOParameter("username", paUsername)); 

      list = io.runQuery(query); 

      if (list.isEmpty()) { 
       return null; 
      } 

      return list.get(0); 

     } catch (Exception ex) { 
      return null; 
     } 
    } 
} 

UserDetailsServiceImpl

@Service("userDetailsService") 
public class UserDetailsServiceImpl implements UserDetailsService { 

    @Autowired 
    private UserDao userDao; 

    @Override 
    public UserDetails loadUserByUsername(String paUsername) throws UsernameNotFoundException { 
     Users user = userDao.findUserByUsername(paUsername); 

     if(user == null) { 
      throw new UsernameNotFoundException("User not found"); 
     } 

     return new User(
       user.getUsername(), 
       user.getPassword(), 
       user.getEnabled(), 
       true, 
       true, 
       true, 
       getAuthorities(Enums.UserRoles.IT)); 
    } 

    private Collection<? extends GrantedAuthority> getAuthorities(Enums.UserRoles paRole) { 
     List<GrantedAuthority> authList = getGrantedAuthorities(getRoles(paRole)); 
     return authList; 
    } 

    private List<String> getRoles(Enums.UserRoles paRole) { 
     List<String> roles = new ArrayList<>(); 

     if (paRole.equals(Enums.UserRoles.USER)) { 
      roles.add(Enums.UserRoles.USER.name()); 
     } else if (paRole.equals(Enums.UserRoles.IT)) { 
      roles.add(Enums.UserRoles.USER.name()); 
      roles.add(Enums.UserRoles.IT.name()); 
     } 

     return roles; 
    } 

    private static List<GrantedAuthority> getGrantedAuthorities(List<String> paRoles) { 
     List<GrantedAuthority> authorities = new ArrayList<>(); 
     for (String role : paRoles) { 
      authorities.add(new SimpleGrantedAuthority(role)); 
     } 
     return authorities; 
    } 
} 

UserDetailsService

public class UserDetailService implements UserDetailsService { 

    @Override 
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { 
     return new UserDetailsServiceImpl().loadUserByUsername(username);   
    } 
} 

sécurité app-contexte

<beans:bean id="loginSuccessHandler" class="com.myapp.security.LoginSuccessHandler" /> 
<beans:bean id="loginFailureHandler" class="com.myapp.security.LoginFailureHandler" /> 
<beans:bean id="detailsService" class="com.myapp.security.UserDetailService" /> 

Toutes les idées sur ce que je dois faire?

Merci

Answer 1

C'est un fragment de la sécurité config mon application utilise pour définir un mot de passe encodage:

<sec:authentication-manager alias="authenticationManager"> 
    <sec:authentication-provider ref="authenticationProvider" /> 
</sec:authentication-manager> 


<bean id="authenticationProvider" class="org.springframework.security.authentication.dao.DaoAuthenticationProvider"> 
    <property name="userDetailsService" ref="userDetailsServiceImpl"/> 
    <property name="passwordEncoder" ref="cryptoPasswordEncoder" /> 
</bean> 


<bean id="cryptoPasswordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder" /> 

On n'a pas besoin de définir une source de sel dans le DaoAuthenticationProvider parce que le BCryptPasswordEncoder utilise son posséder.

Answer 2

Utilisation:

public class PasswordEncoder extends org.springframework.security.authentication.encoding.MessageDigestPasswordEncoder{    

    public PasswordEncoder() { 
     super("MD5"); 
    } 

    @Override 
    public String encodePassword(String originalPassword, Object salt) { 
      // here supply salt = username + saltString 
     String encryptedPassword = super.encodePassword(originalPassword, salt);   
     return encryptedPassword; 
    } 

}