What Is Salting in Security? Definition & Examples

You’ve probably used the same password on more than one site. That’s fine—until one of those sites gets breached. Password salting is the security practice that makes sure even if hackers steal a database of hashed passwords, they can’t just look up your password in a precomputed list. Over 80% of data breaches involve weak or stolen credentials, according to the Verizon 2023 Data Breach Investigations Report, and salting is one of the most effective defenses against those attacks.

Recommended minimum salt length: 16 bytes (OWASP) · Hashing algorithms with built-in salt: bcrypt, scrypt, Argon2 · Rainbow table attack prevention: Effective with sufficient salt length · Data breaches involving weak passwords: Over 80% (Verizon DBIR 2023) · Time to crack salted SHA-256 hash: Billions of years vs minutes unsalted

The following table breaks down the key attributes of salting in security practice.

The implication: without these properties, password databases become trivial targets.

What is a salt in security?

A cryptographic salt is random data added as an additional input to a one-way function that hashes a password or passphrase (Wikipedia: Salt (cryptography)). It doesn’t need to be secret—salts are often stored in plain text with the hash. The key is that each user gets a unique random salt, so even if two people choose the same password, their hashes will be completely different.

How does a salt differ from encryption?

Encryption is reversible if you have the key. Salting is not reversible—it’s added to the input of a one-way hash function. The salt itself is not encrypted; it’s just extra randomness that makes precomputed attacks infeasible. As the Wikipedia article on cryptographic hash functions explains, a password hash requires a large random, non-secret salt value stored with the password hash.

What makes a salt random?

Salts are typically generated using cryptographically secure pseudorandom number generators (CSPRNG). The Wikipedia page on salts states that a unique salt is usually randomly generated for each password. Modern libraries like bcrypt handle this automatically.

What is password salting?

Password salting means appending or prepending a random string (the salt) to a password before hashing it. The salt and the password are concatenated and fed to a cryptographic hash function, with the output stored along with the salt (Wikipedia: Salt (cryptography)). This ensures that identical passwords produce different hashes.

Why is salting important for password security?

Without salting, an attacker who steals a database of hashed passwords can use precomputed rainbow tables to reverse many hashes in seconds. Salting greatly increases the table size needed for a successful attack (Wikipedia: Rainbow table). It also protects against duplicate-password analysis because the same password instance can have a different salt in each record (Wikipedia: Salt (cryptography)).

What algorithms support salting?

Modern password hashing algorithms build salting in by default. bcrypt uses a 16-byte salt (Wikipedia: Bcrypt). scrypt and Argon2 also automatically generate and include salts. PBKDF2 requires you to provide a salt but is designed to work with one (Wikipedia: PBKDF2).

What is an example of salting in cyber security?

Suppose your password is “mypassword” and the system generates a random salt “xYz92”. The system concatenates them: “mypasswordxYz92”, then hashes with SHA-256, producing a unique hash. The salt “xYz92” is stored alongside the hash. If another user also picks “mypassword” but gets salt “aBc01”, their hash will be completely different.

How to create a salted hash?

In practice, you don’t roll your own; you use a library. For illustration, the bcrypt algorithm automatically generates a 16-byte salt, incorporates it, and outputs a string that contains the cost factor, salt, and hash combined.

What happens without salting?

Without a salt, an attacker can precompute a rainbow table for common passwords and reverse every hash in the stolen database at once. The Wikipedia article on rainbow tables notes that a common defense is to compute password hashes with a salt so that different passwords receive different salts.

What does salting do?

Salting thwarts precomputation attacks like rainbow tables and forces attackers to brute-force each user’s hash separately. It does not increase the cryptographic complexity of the hash itself—the hash function output is the same length—but it makes precomputed tables useless.

How does salting protect against brute force?

Brute force still requires guessing passwords, but without a salt an attacker can check guesses against all users simultaneously using a precomputed dictionary. With a unique salt per user, the attacker must compute the hash for each guess for each user separately, multiplying the work by the number of users (Wikipedia: Password cracking).

Does salting increase hash complexity?

No. The hash function’s internal complexity is unchanged. But the effective security increases because the attacker cannot reuse computations across users or leverage precomputed tables. The Wikipedia article on cryptographic hash functions states that the salt alters the password-hash mapping for each password, making it infeasible to store tables of precomputed hash values.

What is salting in cryptography?

In the broader cryptographic context, a salt is a nonce—a number used once—added to the input of a hash function. It’s a fundamental primitive in password storage and key derivation. Pepper is a related concept: a secret salt stored separately from the hash, adding an extra layer of secrecy (Wikipedia: Pepper (cryptography)).

What is the difference between salt and pepper in security?

Both add randomness, but the salt is stored with the hash and isn’t secret. The pepper is kept secret (e.g., in an application secret or HSM) and is not stored alongside the hash. NIST refers to the pepper as a “secret key” rather than a pepper (Wikipedia: Pepper (cryptography)). In practice, pepper adds defense if the database alone is stolen, but the application secrets remain protected.

Why is salt considered a cryptographic primitive?

Because it’s a standard building block used in many cryptographic constructions: password hashing (bcrypt, PBKDF2, Argon2), key derivation, and even some encryption schemes. The Wikipedia article on PBKDF2 explains that it applies a pseudorandom function to the password along with a salt value, repeating many times to produce a derived key.

Expert perspectives

A cryptographic salt is random data added as an additional input to a one-way function that hashes a password or passphrase.

— Wikipedia: Salt (cryptography)

Password hashing with a unique salt per user prevents precomputed dictionaries such as rainbow tables.

— Wikipedia: Password cracking

bcrypt incorporates a salt to protect against rainbow-table attacks and is adaptive because its iteration count can be increased over time.

— Wikipedia: Bcrypt

For system architects, the implication is clear: modern password storage demands salting as a baseline, not an optional hardening measure. Without it, a single database breach can compromise every user account in minutes. With proper salting—using bcrypt, Argon2, or PBKDF2 with a unique 16+ byte salt per user—those same passwords become computationally infeasible to crack in a lifetime. For security practitioners evaluating legacy systems, the trade-off is equally stark: any user authentication system without per-user salts should be flagged as a critical vulnerability, regardless of other controls in place.

Para una explicación más detallada en español, consulte nuestra guía completa sobre salting en seguridad.

Frequently asked questions