Sign up ×

I've always been curious... Which is better when salting a password for hashing: prefix, or postfix? Why? Or does it matter, so long as you salt?

To explain: We all (hopefully) know by now that we should salt a password before we hash it for storage in the database [Edit: So you can avoid things like what happened to Jeff Atwood recently]. Typically this is done by concatenating the salt with the password before passing it through the hashing algorithm. But the examples vary... Some examples prepend the salt before the password. Some examples add the salt after the password. I've even seen some that try to put the salt in the middle.

So which is the better method, and why? Is there a method that decreases the chance of a hash collision? My Googling hasn't turned up a decent analysis on the subject.

Edit: Great answers folks! I'm sorry I could only pick one answer. :)

share|improve this question
See also:… –  Jacco Aug 11 '10 at 7:49
@Jaccco: awesome input. Thanks! –  Randolpho Aug 11 '10 at 14:32
The best practice is to use a cryptographic function that does the salting for you, using either PBKDF2 (the standard), bcrypt or even scrypt. Thanks to Stephen for pointing that out. –  Maarten Bodewes Aug 13 '12 at 0:04
Pretty much all standard password hashing constructions take care of combining salt and password, so you shouldn't worry about this. If you don't use a standard password hash, migrate to one. –  CodesInChaos Aug 16 '13 at 16:06
@Omu Bad recommendation. 1) A single iteration of SHA-1 is too fast, you should use at least 10000, and even that's pretty weak. 2) Default salt is too small. 8 bytes is minimum and 16 is recommended. –  CodesInChaos Aug 16 '13 at 16:09

8 Answers 8

up vote 71 down vote accepted

Prefix or suffix is irrelevant, it's only about adding some entropy and length to the password.

You should consider those three things:

  1. The salt has to be different for every password you store. (This is quite a common misunderstanding.)
  2. Use a cryptographically secure random number generator.
  3. Choose a long enough salt. Think about the birthday problem.

There's an excellent answer by Dave Sherohman to another question why you should use randomly generated salts instead of a user's name (or other personal data). If you follow those suggestions, it really doesn't matter where you put your salt in.

share|improve this answer
I've added a link to an old question, read those answers. Basically, by not using a different random salt per password you're taking an unnecessary security risk, that might be a real problem in the future. –  Georg Schölly Mar 23 '09 at 19:59
Site-wide random salt is bad, since an attacker can precompute rainbow tables and grab your entire user database. If you don't understand this, please don't write login/security systems :) - you NEED per-user salts. –  snemarch Mar 23 '09 at 20:52
Yes, per-user salt. Ideally, with per-user iterations stored (so you can increase the number of iterations used over time). Any decent framework will have this built-in. (.NET has PasswordDeriveBytes which will handle everything for you.) –  MichaelGG Mar 23 '09 at 23:27
If you're designing any kind of security system, it's braindead not using per-user salt. your site might not be super-interesting, but consider users using the same password on multiple sites... trying to keep the database safe tends to fail :) –  snemarch Mar 24 '09 at 0:30
Of course salts protect against dictionary attacks, precisely by making them much slower. The use of salts in passwords far predates rainbow tables. Salts were added specifically to slow down dictionary attacks, by preventing attackers from hashing a password once then comparing it against all users. –  Glenn Maynard Mar 5 '12 at 16:20

I think it's all semantics. Putting it before or after doesn't matter except against a very specific threat model.

The fact that it's there is supposed to defeat rainbow tables.

The threat model I alluded to would be the scenario where the adversary can have rainbow tables of common salts appended/prepended to the password. (Say the NSA) You're guessing they either have it appended or prepended but not both. That's silly, and it's a poor guess.

It'd be better to assume that they have the capacity to store these rainbow tables, but not, say, tables with strange salts interspersed in the middle of the password. In that narrow case, I would conjecture that interspersed would be best.

Like I said. It's semantics. Pick a different salt per password, a long salt, and include odd characters in it like symbols and ASCII codes: ©¤¡

share|improve this answer
@onebyone, damn! He's discovered my salt of 'passwordsalt'! –  Samuel Mar 23 '09 at 23:44
@Samuel: I don't know about you guys, but we use '12345' for our salt. :) –  Randolpho Mar 24 '09 at 13:35
@onebyone valid. I really meant "common" as "all salts under length X in characterset Y" where X, Y are reasonable; say 20 chars and alphanumeric upper/lowercase. Extendable to say all hexadecimal strings under length Z (say 160) since I think a rainbow table of hashed hashes would be useful.. –  Tom Ritter Mar 24 '09 at 13:51
@Randolpho: Hey, that's my salt, too! What're the odds? –  Adrien May 26 '09 at 23:08
And make sure the salt is non-predictable/Random :… –  Jacco Dec 26 '09 at 13:25

The real answer, which nobody seems to have touched upon, is that both are wrong. If you are implementing your own crypto, no matter how trivial a part you think you're doing, you are going to make mistakes.

HMAC is a better approach, but even then if you're using something like SHA-1, you've already picked an algorithm which is unsuitable for password hashing due to its design for speed. Use something like bcrypt or possibly scrypt and take the problem out of your hands entirely.

Oh, and don't even think about comparing the resulting hashes for equality with with your programming language or database string comparison utilities. Those compare character by character and short-circuit as false if a character differs. So now attackers can use statistical methods to try and work out what the hash is, a character at a time.

share|improve this answer

It shouldn't make any difference. The hash will be no more easily guessable wherever you put the salt. Hash collisions are both rare and unpredictable, by virtue of being intentionally non-linear. If it made a difference to the security, that would suggest a problem with the hashing, not the salting.

share|improve this answer
Hash collisions depend on the size of the hash. Thanks to the birthday problem collisions are quite likely. –  Georg Schölly Mar 24 '09 at 7:19
Only if you truncate the result. Anyway, I still stand by the point that it won't make a difference where the salt is, because the point of the hash is to make the relationship between input and output contain no patterns. –  Phil H Mar 24 '09 at 9:27

If using a cryptographically secure hash, it shouldn't matter whether you pre- or postfix; a point of hashing is that a single bit change in the source data (no matter where) should produce a different hash.

What is important, though, is using long salts, generating them with a proper cryptographic PRNG, and having per-user salts. Storing the per-user salts in your database is not a security issue, using a site-wide hash is.

share|improve this answer
Wrong anwser: an attacker could precompute MD(pass) for many frequently used passwords and then compute MD(pass+salt) very cheaply because message digest work in an incremental way so as to support streaming. –  Erwan Legrand Dec 18 '13 at 13:16

BCrypt hash if the platform has a provider. I love how you don't worry about creating the salts and you can make them even stronger if you want.

share|improve this answer
As var as I know, BCrypt Hash needs salting, just like any other hashing scheme. –  Jacco Aug 11 '10 at 20:06

First of all, the term "rainbow table" is consistently misused. A "rainbow" table is just a particular kind of lookup table, one that allows a particular kind of data compression on the keys. By trading computation for space, a lookup table that would take 1000 TB can be compressed a thousand times so that it can be stored on a smaller drive drive.

You should be worried about hash to password lookup tables, rainbow or otherwise.

The attacker has 'rainbow tables' consisting not of the hashes of dictionary words, but of the state of the hash computation just before finalising the hash calculation.

It could then be cheaper to brute-force a password file entry with postfix salt than prefix salt: for each dictionary word in turn you would load the state, add the salt bytes into the hash, and then finalise it. With prefixed salt there would be nothing in common between the calculations for each dictionary word.

For a simple hash function that scans linearly through the input string, such as a simple linear congruential generator, this is a practical attack. But a cryptographically secure hash function is deliberately designed to have multiple rounds, each of which uses all the bits of the input string, so that computing the internal state just prior to the addition of the salt is not meaningful after the first round. For example, SHA-1 has 80 rounds.

Moreover password hashing algorithms like PBKDF compose their hash function multiple times (it is recommended to iterate PBKDF-2 a minimum of 1000 times, each iteration applying SHA-1 twice) making this attack doubly impractical.

share|improve this answer
You should double check the description of rounds. The rounds are on a per chunk basis, not the entire message. (Otherwise, hashing streaming data would require rewinding again and again.) But using iterations does prevent the problem onebyone mentions. –  MichaelGG Mar 25 '09 at 15:20

Inserting the salt an arbitrary number of characters into the password is the least expected case, and therefore the most "secure" socially, but it's really not very significant in the general case as long as you're using long, unique-per-password strings for salts.

share|improve this answer

Your Answer


