Salt (cryptography)

Short description: Random data used as an additional input to a hash function

In cryptography, a salt is random data fed as an additional input to a one-way function that hashes data, a password or passphrase.[1] Salting helps defend against attacks that use precomputed tables (e.g. rainbow tables), by vastly growing the size of table needed for a successful attack.[2][3][4] It also helps protect passwords that occur multiple times in a database, as a new salt is used for each password instance.[5] Additionally, salting does not place any burden on users.

The way salting is typically done is that a new salt is randomly generated for each password. The salt and the password (or its version after key stretching) are concatenated and fed to a cryptographic hash function, and the output hash value is then stored with the salt in a database. The salt does not need to be encrypted, because knowing the salt would not help the attacker.[5]

Salting is broadly used in cybersecurity, from Unix system credentials to Internet security.

Salts are related to cryptographic nonces.

## Contents

* 1 Example
* 2 Common mistakes
* 2.1 Salt re-use
* 2.2 Salt length
* 3 Benefits
* 4 Unix implementations
* 4.1 1970s–1980s
* 4.2 1980s–
* 5 Web-application implementations
* 6 See also
* 7 References
* 8 External links

## Example

Without a salt, identical passwords will map to identical hash values, which could make it easier for a hacker to guess the passwords from their hash value.

Username  | String to be hashed  | Hashed value = SHA256

|
|

`user1` | `password123` | `EF92B778BAFE771E89245B89ECBC08A44A4E166C06659911881F383D4473E94F`
`user2` | `password123` | `EF92B778BAFE771E89245B89ECBC08A44A4E166C06659911881F383D4473E94F`

Instead, a salt is generated and appended to each password, which causes the resultant hash to output different values for the same original password.

Username  | Salt value  | String to be hashed  | Hashed value = SHA256 (Password + Salt value)

|
|
|

`user1` | `D;%yL9TS:5PalS/d` | `password123D;%yL9TS:5PalS/d` | `9C9B913EB1B6254F4737CE947EFD16F16E916F9D6EE5C1102A2002E48D4C88BD`
`user2` | `)<,-<U(jLezy4j>*` | `password123)<,-<U(jLezy4j>*` | `6058B4EB46BD6487298B59440EC8E70EAE482239FF2B4E7CA69950DFBD5532F2`

The salt and hash are then stored in the database. To later test if a password a user enters is correct, the same process can be performed on it (appending that user's salt to the password and calculating the resultant hash): if the result doesn't match the stored hash, it could not have been the correct password that was entered.

In practice, a salt is usually generated using existing data such as a user's ID. If a completely random salt is created instead, it is stored in the hash (such as by prepending it, appending it, replacing every nth character with it, or so on) so the system can later recover it.

## Common mistakes

### Salt re-use

Using the same salt for all passwords is dangerous because a precomputed table which simply accounts for the salt will render the salt useless.

Generation of precomputed tables for databases with unique salts for every password is not viable because of the computational cost of doing so. But, if a common salt is used for all the entries, creating such a table (that accounts for the salt) then becomes a viable and possibly successful attack.[6]

Because salt re-use can cause users with the same password to have the same hash, cracking a single hash can result in other passwords being compromised too.

### Salt length

If a salt is too short, an attacker may precompute a table of every possible salt appended to every likely password. Using a long salt ensures such a table would be prohibitively large.[7][8]

## Benefits

To understand the difference between cracking a single password and a set of them, consider a file with users and their hashed passwords. Say the file is unsalted. Then an attacker could pick a string, call it `attempt[0]`, and then compute `hash(attempt[0])`. A user whose hash stored in the file is `hash(attempt[0])` may or may not have password `attempt[0]`. However, even if `attempt[0]` is not the user's actual password, it will be accepted as if it were, because the system can only check passwords by computing the hash of the password entered and comparing it to the hash stored in the file. Thus, each match cracks a user password, and the chance of a match rises with the number of passwords in the file. In contrast, if salts are used, the attacker would have to compute `hash(attempt[0] || salt[a])`, compare against entry A, then `hash(attempt[0] || salt[b])`, compare against entry B, and so on. This prevents any one attempt from cracking multiple passwords, given that salt re-use is avoided.[9]

Salts also combat the use of precomputed tables for cracking passwords.[10] Such a table might simply map common passwords to their hashes, or it might do something more complex, like store the start and end points of a set of precomputed hash chains. In either case, salting can defend against the use of precomputed tables by lengthening hashes and having them draw from larger character sets, making it less likely that the table covers the resulting hashes. In particular, a precomputed table would need to cover the string `[salt + hash]` rather than simply `[hash]`.

The modern shadow password system, in which password hashes and other security data are stored in a non-public file, somewhat mitigates these concerns. However, they remain relevant in multi-server installations which use centralized password management systems to push passwords or password hashes to multiple systems. In such installations, the root account on each individual system may be treated as less trusted than the administrators of the centralized password system, so it remains worthwhile to ensure that the security of the password hashing algorithm, including the generation of unique salt values, is adequate.[citation needed]

Another (lesser) benefit of a salt is as follows: two users might choose the same string as their password. Without a salt, this password would be stored as the same hash string in the password file. This would disclose the fact that the two accounts have the same password, allowing anyone who knows one of the account's passwords to access the other account. By salting the passwords with two random characters, even if two accounts use the same password, no one can discover this just by reading hashes. Salting also makes it extremely difficult to determine if a person has used the same password for multiple systems.[11]

## Unix implementations

### 1970s–1980s

Earlier versions of Unix used a password file `/etc/passwd` to store the hashes of salted passwords (passwords prefixed with two-character random salts). In these older versions of Unix, the salt was also stored in the passwd file (as cleartext) together with the hash of the salted password. The password file was publicly readable for all users of the system. This was necessary so that user-privileged software tools could find user names and other information. The security of passwords is therefore protected only by the one-way functions (enciphering or hashing) used for the purpose. Early Unix implementations limited passwords to eight characters and used a 12-bit salt, which allowed for 4,096 possible salt values.[12] This was an appropriate balance for 1970s computational and storage costs.[13]

### 1980s–

The shadow password system is used to limit access to hashes and salt. The salt is eight characters, the hash is 86 characters, and the password length is effectively unlimited, barring stack overflow errors.

## Web-application implementations

It is common for a web application to store in a database the hash value of a user's password. Without a salt, a successful SQL injection attack may yield easily crackable passwords. Because many users re-use passwords for multiple sites, the use of a salt is an important component of overall web application security.[14] Some additional references for using a salt to secure password hashes in specific languages or libraries (PHP, the .NET libraries, etc.) can be found in the external links section below.

## See also

* Password cracking
* Cryptographic nonce
* Initialization vector
* Padding
* "Spice" in the Hasty Pudding cipher
* Rainbow tables
* Pepper (cryptography)

## References

1. ↑ Fenton, James L.; Grassi, Paul A.; Garcia, Michael E. (June 2017). "NIST Special Publication 800-63-3". https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-63-3.pdf.
2. ↑ Anderson, Ross (2020). Security engineering: a guide to building dependable distributed systems (Third ed.). Indianapolis, Indiana. ISBN 978-1-119-64281-7. OCLC 1224516855.
3. ↑ Godwin, Anthony (10 September 2021). "Passwords Matter". http://bugcharmer.blogspot.com/2012/06/passwords-matter.html.
4. ↑ Boneh, Dan; Shoup, Victor (January 4, 2020). A Graduate Course in Applied Cryptography. pp. 693–695. https://crypto.stanford.edu/~dabo/cryptobook/BonehShoup_0_5.pdf.
5. ↑ 5.0 5.1 Rosulek, Mike (January 3, 2021). "Chapter 11: Hash Functions". The Joy of Cryptography. pp. 204–205. https://joyofcryptography.com/pdf/chap11.pdf.
6. ↑ "Secure Salted Password Hashing - How to do it Properly". https://crackstation.net/hashing-security.htm.
7. ↑ Menezes, Alfred J.; Oorschot, Paul C. van; Vanstone, Scott A. (1997). Handbook of Applied Cryptography. CRC Press. pp. 288. ISBN 0-8493-8523-7.
8. ↑ "Secure Salted Password Hashing - How to do it Properly". https://crackstation.net/hashing-security.htm#salt.
9. ↑ "Password Storage - OWASP Cheat Sheet Series". https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html.
10. ↑ "How Rainbow Tables work". http://kestas.kuliukas.com/RainbowTables/.
11. ↑ Stallings, William; Lawrie Brown (2015). Computer security: principles and practice (Third ed.). Boston. ISBN 978-0-13-377392-7. OCLC 874734678.
12. ↑ Morris, Robert; Thompson, Ken (1978-04-03). "Password Security: A Case History". http://cm.bell-labs.com/cm/cs/who/dmr/passwd.ps.
13. ↑ Simson Garfinkel; Gene Spafford; Alan Schwartz (2003). "How Unix Implements Passwords". Practical UNIX and Internet Security (3rd ed.). O'Reilly Media. ISBN 9780596003234. https://www.safaribooksonline.com/library/view/practical-unix-and/0596003234/ch04s03.html.
14. ↑ "ISC Diary – Hashing Passwords". Dshield.org. http://www.dshield.org/diary.html?storyid=11110.

## External links

* Wille, Christoph (2004-01-05). "Storing Passwords - done right!". http://www.aspheute.com/english/20040105.asp.
* OWASP Cryptographic Cheat Sheet
* how to encrypt user passwords

* v
* t
* e

Cryptographic hash functions & message authentication codes

* List
* Comparison
* Known attacks

Common functions|

* MD5
* SHA-1
* SHA-2
* SHA-3
* BLAKE2

SHA-3 finalists|

* BLAKE
* Grøstl
* JH
* Skein
* Keccak (winner)

Other functions|

* CubeHash
* ECOH
* FSB
* GOST
* HAS-160
* HAVAL
* Kupyna
* LM hash
* MD2
* MD4
* MD6
* MDC-2
* N-Hash
* RIPEMD
* RadioGatún
* SM3
* SWIFFT
* Snefru
* Streebog
* Tiger
* VSH
* Whirlpool

Key derivation functions|

* Argon2
* Balloon
* bcrypt
* crypt
* Lyra2
* PBKDF2
* scrypt

MAC functions|

* DAA
* CBC-MAC
* GMAC
* HMAC
* NMAC
* OMAC/CMAC
* PMAC
* VMAC
* UMAC
* Poly1305
* SipHash

Authenticated
encryption modes|

* CCM
* CWC
* EAX
* GCM
* IAPM
* OCB

Attacks|

* Collision attack
* Preimage attack
* Birthday attack
* Brute-force attack
* Rainbow table
* Side-channel attack
* Length extension attack

Design|

* Avalanche effect
* Hash collision
* Merkle–Damgård construction
* Sponge function
* HAIFA construction

Standardization|

* CRYPTREC
* NESSIE
* NIST hash function competition

Utilization|

* Hash-based cryptography
* Key stretching
* Merkle tree
* Message authentication
* Proof of work
* Salt
* Pepper

* v
* t
* e

Cryptography

* History of cryptography
* Cryptanalysis
* Outline of cryptography

* Symmetric-key algorithm
* Block cipher
* Stream cipher
* Public-key cryptography
* Cryptographic hash function
* Message authentication code
* Random numbers
* Steganography

* Category

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Salt (cryptography). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Salt_(cryptography)&oldid=193540"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template