Spring Security - Random salt + Hash + Custom UserDetailsService - spring

Question

Last question on this from me hopefully. So far I've implemented my own custom UserDetails and UserDetailsService classes so that I can pass the random salt that was used at the time of password creation. Hash of password is SHA512. However upon trying to login I always get user/pw combination incorrect and I can't seem to figure out why.
I store the hash and salt in the db as blobs, any ideas on where the issue lies?
Security-applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans
xmlns:sec="http://www.springframework.org/schema/security"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.0.xsd">
<sec:http auto-config='true' access-denied-page="/access-denied.html">
<!-- NO RESTRICTIONS -->
<sec:intercept-url pattern="/login.html" access="IS_AUTHENTICATED_ANONYMOUSLY" />
<sec:intercept-url pattern="/*.html" access="IS_AUTHENTICATED_ANONYMOUSLY" />
<!-- RESTRICTED PAGES -->
<sec:intercept-url pattern="/admin/*.html" access="ROLE_ADMIN" />
<sec:intercept-url pattern="/athlete/*.html" access="ROLE_ADMIN, ROLE_STAFF" />
<sec:form-login login-page="/login.html"
login-processing-url="/loginProcess"
authentication-failure-url="/login.html?login_error=1"
default-target-url="/member" />
<sec:logout logout-success-url="/login.html"/>
</sec:http>
<beans:bean id="customUserDetailsService" class="PATH.TO.CustomUserDetailsService"/>
<beans:bean id="passwordEncoder" class="org.springframework.security.authentication.encoding.ShaPasswordEncoder">
<beans:constructor-arg value="512"/>
</beans:bean>
<sec:authentication-manager>
<sec:authentication-provider user-service-ref="customUserDetailsService">
<sec:password-encoder ref="passwordEncoder">
<sec:salt-source user-property="salt"/>
</sec:password-encoder>
</sec:authentication-provider>
</sec:authentication-manager>
</beans:beans>
CustomUserDetails.java
public class CustomUserDetails implements UserDetails {
private int userID;
private String username;
private String password;
private Collection<GrantedAuthority> authorities;
private boolean accountNonExpired;
private boolean accountNonLocked;
private boolean credentialsNonExpired;
private boolean enabled;
private String salt;
public CustomUserDetails() {
}
public CustomUserDetails(int userID, Collection<GrantedAuthority> authorities, String username, String password, boolean accountNonExpired, boolean accountNonLocked, boolean credentialsNonExpired, boolean enabled, String salt) {
this.userID = userID;
this.authorities = authorities;
this.username = username;
this.password = password;
this.accountNonExpired = accountNonExpired;
this.accountNonLocked = accountNonLocked;
this.credentialsNonExpired = credentialsNonExpired;
this.enabled = enabled;
this.salt = salt;
}
#Override
public Collection<GrantedAuthority> getAuthorities() {
return authorities;
}
public int getUserID() {
return userID;
}
public void setUserID(int userID) {
this.userID = userID;
}
#Override
public String getPassword() {
return password;
}
#Override
public String getUsername() {
return username;
}
#Override
public boolean isAccountNonExpired() {
return accountNonExpired;
}
#Override
public boolean isAccountNonLocked() {
return accountNonLocked;
}
#Override
public boolean isCredentialsNonExpired() {
return credentialsNonExpired;
}
#Override
public boolean isEnabled() {
return enabled;
}
public String getSalt() {
return salt;
}
public void setAccountNonExpired(boolean accountNonExpired) {
this.accountNonExpired = accountNonExpired;
}
public void setAccountNonLocked(boolean accountNonLocked) {
this.accountNonLocked = accountNonLocked;
}
public void setAuthorities(Collection<GrantedAuthority> authorities) {
this.authorities = authorities;
}
public void setCredentialsNonExpired(boolean credentialsNonExpired) {
this.credentialsNonExpired = credentialsNonExpired;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public void setPassword(String password) {
this.password = password;
}
public void setUsername(String username) {
this.username = username;
}
public void setSalt(String salt) {
this.salt = salt;
}
}
CustomUserDetailsService.java
public class CustomUserDetailsService implements UserDetailsService {
private User_dao userDao;
#Autowired
public void setUserDao(User_dao userDao) {
this.userDao = userDao;
}
#Override
public CustomUserDetails loadUserByUsername(String username) throws UsernameNotFoundException, DataAccessException {
MyUser myUser = new MyUser();
myUser.setUsername(username);
try {
userDao.getUserByUsername(myUser);
} catch (Throwable e) {
}
if (myUser == null) {
throw new UsernameNotFoundException("Username not found", username);
} else {
List<GrantedAuthority> authList = new ArrayList<GrantedAuthority>();
authList.add(new GrantedAuthorityImpl(myUser.getUserRole().getAuthority()));
int userID = myUser.getUserID();
boolean accountNonExpired = true;
boolean accountNonLocked = myUser.isNonLocked();
boolean credentialsNonExpired = true;
boolean enabled = myUser.isEnabled();
String password = "";
String salt = "";
password = new String(myUser.getHash);
salt = new String(myUser.getSalt());
CustomUserDetails user = new CustomUserDetails(userID, authList, username, password, accountNonExpired, accountNonLocked, credentialsNonExpired, enabled, salt);
return user;
}
}
}
Password Creation
public byte[] generateSalt() throws NoSuchAlgorithmException {
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
byte[] salt = new byte[20];
random.nextBytes(salt);
return salt;
}
public byte[] generateHash(byte[] salt, String pass) throws NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance("SHA-512");
digest.update(salt);
byte[] hash = digest.digest(pass.getBytes());
return hash;
}
Call in method:
byte[] salt = generateSalt();
byte[] hash = generateHash(salt, password);
Which I then store in the db.

Answer 1

I had the same original problem, which was never answered, so in the hopes that this might save someone time in the future:
Spring-Security adds braces by default prior to comparing digests. I missed that and spun my wheels for hours (d'oh).
Make sure you store (or generate) your salt values enclosed with curly braces (i.e., when Spring says '{salt}' they sincerely mean 'open curly brace + your salt value + close curly brace'.
I suppose this was obvious to most people, but I didn't notice it until I finally debugged down into it.

Answer 2

It's worth pointing out, I think, that storing the salt used for each user's password in a salt column in the database (although common) present a vulnerability. The reason for salting in the first place is to prevent dictionary attacks against a compromised database. If an attacker had access to your database and no salt were used, they could apply common hash algorithms to every word in a standard dictionary to create new dictionaries of hashes. When they find a match for one of those words in the database, they consult the mappings in their own dictionary to find the original unhashed word that produces that hash when the algorithm is applied. And voila! The attacker has a password.
Now... if you apply a salt and the salt is different for each user, you throw a massive monkey wrench into that attack plan. BUT... if you STORE the salt for each user in the database (and make it obvious by naming the column "salt") you're not actually interfering all that much with this attack plan.
The most secure approach I know of is this.
Have no salt column in your user table.
Implement a getSalt() method on your UserDetails class. Have it return some other user attribute that was set when the user registered and will NEVER change. e.g. join date. Concatenate that with a string literal/constant that's hard-coded in your UserDetails class.
In this manner, salts will be unique to every user. What value was used as a salt will not be evident from looking at the database. And even if an attacker guessed what was used for part of the salt, he/she would ALSO need access to your source code to know the REST of the salt. This means your database AND application code would BOTH need to be compromised before you end up with a real issue on your hands.
Assuming you understand the merits of everything I just said, there's also a considerable advantage here in that what I just said is actually easier to implement than what you're already doing. Love it when the right thing turns out to be the easier thing!