PHP crypt() Function

What You’ll Learn

The crypt() function performs one-way hashing of strings using salt-based algorithms like bcrypt and SHA-512. It is the low-level foundation behind password storage in PHP—though modern apps should prefer password_hash().

Definition and Usage

In PHP, crypt() hashes a string using the algorithm encoded in the $salt parameter. The returned hash includes the salt and algorithm identifier at the start (for example $2y$10$... for bcrypt), so you can store one string in your database and use it later for verification.

📝 Syntax

The crypt() function requires both a string and a salt:

string crypt(string $string, string $salt)

Parameters

• $string — the plain text to hash (typically a password). bcrypt truncates input to 72 bytes.
• $salt — a salt string that selects the algorithm. Examples: $2y$10$... (bcrypt), $6$... (SHA-512), $5$... (SHA-256). Required since PHP 8.0.

Return Value

Returns the hashed string on success. On failure, returns a string shorter than 13 characters that is guaranteed to differ from the salt. There is no decrypt function—hashing is one-way.

Supported Salt Prefixes

• $2y$ — bcrypt (Blowfish), recommended for legacy crypt usage
• $6$ — SHA-512 crypt
• $5$ — SHA-256 crypt
• $1$ — MD5 crypt (legacy, avoid for new code)
• Two-character salt — standard DES (obsolete, avoid)

Examples Gallery

Run these examples in PHP 8+. Each demonstrates a common pattern beginners encounter with crypt().

<?php
$password = "rasmuslerdorf";

// bcrypt: $2a$ + 2-digit cost + $ + 22-char salt
$salt = '$2a$07$usesomesillystringf';
$hash = crypt($password, $salt);

echo "Hash:   $hash\n";
echo "Length: " . strlen($hash) . " characters\n";
echo "Prefix: " . substr($hash, 0, 7) . " (bcrypt, cost 07)\n";
?>

Hash:   $2a$07$usesomesillystringfOu/e.n18Q4.2pLQOa1fH/QEYQ6
Length: 60 characters
Prefix: $2a$07$ (bcrypt, cost 07)

<?php
$userInput       = 'rasmuslerdorf';
$hashed_password = '$6$rounds=1000000$NJy4rIPjpOaU$0ACEYGg/aKCY3v8O8AfyiO7CTfZQ8/W231Qfh2tRLmfdvFD6XfHk12u6hMr9cYIA4hnpjLNSTRtUwYr9km9Ij/';

if (hash_equals($hashed_password, crypt($userInput, $hashed_password))) {
    echo "Password verified!\n";
} else {
    echo "Password incorrect.\n";
}
?>

Password verified!

<?php
// --- Registration: hash and store in database ---
$password = "MySecretPass!";
$salt     = '$2y$10$' . bin2hex(random_bytes(11)); // 22 hex chars
$stored   = crypt($password, $salt);

// --- Login: user submits a password ---
function checkPassword(string $input, string $storedHash): bool
{
    return hash_equals($storedHash, crypt($input, $storedHash));
}

echo "Correct password: " . (checkPassword("MySecretPass!", $stored) ? "OK\n" : "FAIL\n");
echo "Wrong password:   " . (checkPassword("WrongPass!", $stored) ? "OK\n" : "FAIL\n");
?>

Correct password: OK
Wrong password:   FAIL

<?php
$password = "SecurePassword123";

// Modern approach (recommended)
$hash1 = password_hash($password, PASSWORD_DEFAULT);
$ok1   = password_verify($password, $hash1);

// Low-level crypt() equivalent (manual salt)
$salt  = '$2y$10$' . bin2hex(random_bytes(11));
$hash2 = crypt($password, $salt);
$ok2   = hash_equals($hash2, crypt($password, $hash2));

echo "password_hash verify: " . ($ok1 ? "yes\n" : "no\n");
echo "crypt verify:         " . ($ok2 ? "yes\n" : "no\n");
echo "password_verify works with crypt hashes: "
   . (password_verify($password, $hash2) ? "yes\n" : "no\n");
?>

password_hash verify: yes
crypt verify:         yes
password_verify works with crypt hashes: yes

<?php
$stored = crypt("demoPass", '$2y$10$usesomesillystringf');
$input  = "demoPass";
$computed = crypt($input, $stored);

// Both return true for a correct password:
$plainCompare = ($computed === $stored);
$safeCompare  = hash_equals($stored, $computed);

echo "=== comparison:        " . ($plainCompare ? "match\n" : "no match\n");
echo "hash_equals():         " . ($safeCompare ? "match\n" : "no match\n");
echo "\nUse hash_equals() in production to reduce timing-attack risk.\n";
?>

=== comparison:        match
hash_equals():         match

Use hash_equals() in production to reduce timing-attack risk.

🚀 Common Use Cases

• Password storage — hash user passwords before saving to a database (prefer password_hash()).
• Legacy system maintenance — verify passwords stored in crypt format by older PHP apps.
• Cross-platform compatibility — validate hashes created by Unix crypt utilities or other languages.
• Understanding password_hash() — learn what happens under the hood when PHP hashes passwords.
• Custom salt strategies — control algorithm and cost when you cannot use the password API.

📝 Notes

• crypt() is hashing, not encryption—there is no decrypt function.
• The $salt parameter is required since PHP 8.0 (the old reference showing crypt($password) alone is outdated).
• Use a unique random salt per password in production—never reuse demo salts like usesomesillystringf.
• MD5 crypt ($1$) and DES are legacy and weak—avoid for new applications.
• Always compare hashes with hash_equals(), not ===, in security-sensitive code.

💡 Best Practices