Does complexity of salt in password hashing matter?

Question

I have no cyber security knowledge whatsoever, and am trying to safely store passwords in a database. I understood I need to use salt, to avoid rainbow table attacks and to make sure two users with the same password will have different password hashes.

However, does the complexity of the salt matter? I was planning on simply using the user's id (an integer that's incremented each time a new account is created), but is it good enough, or should I generate a more complex salt?

Answer 1

The important part

The fact that you are generating salts on your own is a red flag. The best way to do this, especially if you have little experience with security, is to use an established library for password hashing.

A well-designed library will generate and use salts automatically for you, and it will store the salt and the hash in the same string, that you put in one column in your database.

So, use a slow algorithm designed for password hashing, and use an established library, and you won't have to think about how to generate the salt.

The answer

Still, I should answer your question. Does it matter if the salt has high entropy? There are two properties that we may want the salt to have here, that randomness helps with:

• Unique, in your database, between password changes and preferably globally, so that an attacker can only crack one password at a time.
• Unknown to the attacker (before a breach), so that an attacker targeting a specific account can not start any preparatory work before the database is leaked.

Using a counter as salt is a decent solution, but not perfect. The salt is at least locally unique, but it's not globally unique or even unique over multiple installations of the same software. It's not unknown to the attacker, but that really isn't such a big issue. Once the hash is leaked, the salt will be leaked too.

But still, using a library that gives you a random salt will be better. Don't mess around with homebrew solutions for something as important as this!

Answer 2

Yes it does matter, Using a known salt or like you are using by incrementing id is not much secure. You should use a random salt. You some salt generator alog/libraries etc.

Answer 3

TL;DR: it's not good enough, instead let your salt be 10 bytes of /dev/urandom.

the salt does matter, and an user id is "not good enough" - it's much better than no salt at all, but to imagine a scenario where "uid as salt" is not good enough, imagine that multiple systems used salt is uid, and uid 0 is admin user (for example, on all linux systems, uid 0 is the admin account known as root), if Linux used uid as the salt for password hashes, i guarantee there would be rainbow tables out there for the 0-salt to attack root passwords, you'd probably even be able to google the hashes if that were the case, defeating the purpose of the salt :)

(another popular uid in Linux is uid 1000 or 1001, which is usually "the first user account", and the first user account is usually an account with sudo-access)