hash

(PHP 5 >= 5.1.2, PHP 7, PHP 8, PECL hash >= 1.1)

hash — 產生雜湊值（訊息摘要）

說明

hash(
    字串 $algo,
    字串 $data,
    布林 $binary = false,
    陣列 $options = []
): 字串

參數

algo: 選取的雜湊演算法名稱（例如 "sha256"）。如需支援的演算法列表，請參閱 hash_algos()。
data: 要雜湊的訊息。
binary: 當設定為 true 時，輸出原始二進位資料。false 輸出小寫十六進位字元。
options: 各種雜湊演算法的選項陣列。目前，只有 MurmurHash 變體支援 "seed" 參數。

傳回值

傳回包含計算出的訊息摘要的字串，以小寫十六進位字元表示，除非 binary 設定為 true，在這種情況下，將傳回訊息摘要的原始二進位表示。

更新日誌

版本	說明
8.1.0	已新增 `options` 參數。
8.0.0	如果 `algo` 未知，hash() 現在會拋出 ValueError 例外；之前，會傳回 `false`。

範例

範例 1：hash() 範例

<?php
echo hash('sha256', 'The quick brown fox jumped over the lazy dog.');
?>

上述範例會輸出

68b1282b91de2c054c36629cb8dd447f12f096d3e3c587978dc2248444633483

參見

hash_init() - 初始化增量雜湊上下文
hash_file() - 使用指定檔案的內容產生雜湊值
hash_hmac() - 使用 HMAC 方法產生金鑰雜湊值

發現問題？

瞭解如何改進此頁面 • 提交 Pull Request • 回報錯誤

＋新增註解

使用者貢獻註解 14 則註解

上

下

684

nmmm at nmmm dot nu ¶

13 年前

我對每個雜湊的「長度」很感興趣，所以我做了


<?php 
$data = "hello"; 
 
foreach (hash_algos() as $v) { 
 $r = hash($v, $data, false); 
 printf("%-12s %3d %s\n", $v, strlen($r), $r); 
} 
?> 

產生（長雜湊已裁剪）


md2 32 a9046c73e00331af68917d3804f70655
md4 32 866437cb7a794bce2b727acc0362ee27
md5 32 5d41402abc4b2a76b9719d911017c592
sha1 40 aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
sha256 64 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e730
sha384 96 59e1748777448c69de6b800d7a33bbfb9ff1b463e44354c3553
sha512 128 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2d
ripemd128 32 789d569f08ed7055e94b4289a4195012
ripemd160 40 108f07b8382412612c048d07d13f814118445acd
ripemd256 64 cc1d2594aece0a064b7aed75a57283d9490fd5705ed3d66bf9a
ripemd320 80 eb0cf45114c56a8421fbcb33430fa22e0cd607560a88bbe14ce
whirlpool 128 0a25f55d7308eca6b9567a7ed3bd1b46327f0f1ffdc804dd8bb
tiger128,3 32 a78862336f7ffd2c8a3874f89b1b74f2
tiger160,3 40 a78862336f7ffd2c8a3874f89b1b74f2f27bdbca
tiger192,3 48 a78862336f7ffd2c8a3874f89b1b74f2f27bdbca39660254
tiger128,4 32 1c2a939f230ee5e828f5d0eae5947135
tiger160,4 40 1c2a939f230ee5e828f5d0eae5947135741cd0ae
tiger192,4 48 1c2a939f230ee5e828f5d0eae5947135741cd0aefeeb2adc
snefru 64 7c5f22b1a92d9470efea37ec6ed00b2357a4ce3c41aa6e28e3b
gost 64 a7eb5d08ddf2363f1ea0317a803fcef81d33863c8b2f9f6d7d1
adler32 8 062c0215
crc32 8 3d653119
crc32b 8 3610a686
haval128,3 32 85c3e4fac0ba4d85519978fdc3d1d9be
haval160,3 40 0e53b29ad41cea507a343cdd8b62106864f6b3fe
haval192,3 48 bfaf81218bbb8ee51b600f5088c4b8601558ff56e2de1c4f
haval224,3 56 92d0e3354be5d525616f217660e0f860b5d472a9cb99d6766be
haval256,3 64 26718e4fb05595cb8703a672a8ae91eea071cac5e7426173d4c
haval128,4 32 fe10754e0b31d69d4ece9c7a46e044e5
haval160,4 40 b9afd44b015f8afce44e4e02d8b908ed857afbd1
haval192,4 48 ae73833a09e84691d0214f360ee5027396f12599e3618118
haval224,4 56 e1ad67dc7a5901496b15dab92c2715de4b120af2baf661ecd92
haval256,4 64 2d39577df3a6a63168826b2a10f07a65a676f5776a0772e0a87
haval128,5 32 d20e920d5be9d9d34855accb501d1987
haval160,5 40 dac5e2024bfea142e53d1422b90c9ee2c8187cc6
haval192,5 48 bbb99b1e989ec3174019b20792fd92dd67175c2ff6ce5965
haval224,5 56 aa6551d75e33a9c5cd4141e9a068b1fc7b6d847f85c3ab16295
haval256,5 64 348298791817d5088a6de6c1b6364756d404a50bd64e645035f

上

下

155

Kai Petzke ¶

15 年前

在新的應用程式中，應避免使用廣為人知的雜湊函數 MD5 和 SHA1。針對 MD5 的碰撞攻擊已在密碼學文獻中有詳細記錄，並且已在實務中證明。因此，MD5 對於某些應用程式而言不再安全。

針對 SHA1 的碰撞攻擊也已發表，儘管它們仍然需要計算能力，這在某種程度上超出了範圍。隨著計算能力隨著時間的推移而增強，攻擊也可能變得更好，因此在未來幾年內，針對依賴 SHA1 來確保安全性的系統進行攻擊可能變得可行。

並不缺乏潛在的替代雜湊演算法，如同 PHP 的 hash() 函數的「algo」參數的許多選項所暗示的那樣。不幸的是，缺乏分析，以瞭解這些替代演算法的安全性如何。然而，可以相當肯定地假設，SHA2 系列及其最突出的成員 SHA-256 和 SHA-512 優於 SHA1。

在儲存密碼雜湊時，最好在雜湊之前在密碼前面加上鹽，以避免相同的密碼雜湊為相同的值，並避免使用彩虹表進行密碼恢復。與其他文章中建議的不同，將鹽放在組合鹽-密碼字串的中間，甚至放在開頭和結尾都沒有安全優勢。

相反地，還有兩個其他因素決定了鹽的強度：其長度和其變異性。例如，為所有密碼使用相同的鹽很容易實現，但只提供了非常少的額外安全性。尤其是，如果使用者輸入相同的密碼，它們仍然會雜湊為相同的值！

因此，鹽應該是隨機字串，其變數位至少與雜湊結果中的位一樣多。在使用者資料庫中，儲存使用者名稱、為該使用者隨機產生的鹽，以及雜湊鹽-密碼字串的結果。然後，透過查找使用者的條目，計算資料庫中找到的鹽的雜湊和使用者提供的密碼，並將結果與資料庫中儲存的結果進行比較來完成存取驗證。

上

下

jrz [dot] agarcia [at] gmail [dot] com ¶

6 年前

我對雜湊的行為（時間和長度）感到好奇，所以我執行了這段程式碼（是的，我在作弊，因為我從這個頁面中取得了兩個範例）
<?php
 echo "正在建立資料...";
 $data = "";
 for($i = 0; $i < 1500; $i++)
 $data .= sha1("H:k - $i - k:H");

 echo "完成! (".strlen($data)." 位元組)".PHP_EOL;

 $res = [];

 echo "正在測試雜湊.....".PHP_EOL;

 foreach (hash_algos() as $algo) {
 $time = microtime(1);
 $hash = hash($algo, $data);
 $time = (microtime(1) - $time) * 1000;
 $length = strlen($hash);

 $res["$time"][] = [
 "algo" => "HEX-$algo",
 "length" => "$length",
 "time" => sprintf("%.8f", $time)
 ];

 $time = microtime(1);
 hash($algo, $data, 1);
 $time = (microtime(1) - $time) * 1000;

 $res["$time"][] = [
 "algo" => "RAW-$algo",
 "length" => "$length",
 "time" => sprintf("%.8f", $time)
 ];
 }

 ksort($res);
 $i = 0;

 echo "結果:".PHP_EOL;
 echo "順位  時間(毫秒)  類型-雜湊演算法  雜湊長度".PHP_EOL;

 foreach($res as $sres){
 foreach($sres as $result){
 echo sprintf("%5d. %12s ms %-20s %-2d 位元組", $i++, $result['time'], $result['algo'], $result['length']).PHP_EOL;
 }
 }
?>

我發現今天 (2018 年 5 月 31 日) 有趣的是，我找到了 103 種演算法，比 9 年前多了 65 種 (根據此評論：https://secure.php.net/manual/en/function.hash.php#89574 )

此外，這是我的結果： https://ideone.com/embed/0iwuGn

由於訊息長度限制，我沒有在這裡張貼。

上

下

luka8088 at gmail dot com ¶

15 年前

在我的筆記型電腦上的效能測試結果
結果在此縮短以符合 PHP 網頁筆記...
這是用 1024000 位元組 (1000 KB) 的隨機資料進行測試的，md4 始終排名第一，而 md2 始終排名最後 :)

結果：(以微秒為單位)
1. md4 5307.912
2. md5 6890.058
3. crc32b 7298.946
4. crc32 7561.922
5. sha1 8886.098
6. tiger128,3 11054.992
7. haval192,3 11132.955
8. haval224,3 11160.135
9. tiger160,3 11162.996
10. haval160,3 11242.151
11. haval256,3 11327.981
12. tiger192,3 11630.058
13. haval128,3 11880.874
14. tiger192,4 14776.945
15. tiger128,4 14871.12
16. tiger160,4 14946.937
17. haval160,4 15661.954
18. haval192,4 15717.029
19. haval256,4 15759.944
20. adler32 15796.184
21. haval128,4 15887.022
22. haval224,4 16047.954
23. ripemd256 16245.126
24. haval160,5 17818.927
25. haval128,5 17887.115
26. haval224,5 18085.002
27. haval192,5 18135.07
28. haval256,5 18678.903
29. sha256 19020.08
30. ripemd128 20671.844
31. ripemd160 21853.923
32. ripemd320 22425.889
33. sha384 45102.119
34. sha512 45655.965
35. gost 57237.148
36. whirlpool 64682.96
37. snefru 80352.783
38. md2 705397.844

用於產生此結果的程式碼
(與瀏覽器和 CLI 模式相容)

<pre>

<?php

echo '正在建立隨機資料 ...' . PHP_EOL; 
@ob_flush();flush();

$data = '';
for ($i = 0; $i < 64000; $i++)
 $data .= hash('md5', rand(), true);

echo strlen($data) . ' 位元組的隨機資料已建立！' . PHP_EOL . PHP_EOL . '正在測試雜湊演算法...' . PHP_EOL; 
@ob_flush();flush();

$results = array();
foreach (hash_algos() as $v) {
 echo $v . PHP_EOL; 
 @ob_flush();flush();
 $time = microtime(true);
 hash($v, $data, false);
 $time = microtime(true) - $time;
 $results[$time * 1000000000][] = "$v (十六進位)";
 $time = microtime(true);
 hash($v, $data, true);
 $time = microtime(true) - $time;
 $results[$time * 1000000000][] = "$v (原始)";
}

ksort($results);

echo PHP_EOL . PHP_EOL . '結果：' . PHP_EOL; 

$i = 1;
foreach ($results as $k => $v)
 foreach ($v as $k1 => $v1)
 echo ' ' . str_pad($i++ . '.', 4, ' ', STR_PAD_LEFT) . ' ' . str_pad($v1, 30, ' ') . ($k / 1000) . ' 微秒' . PHP_EOL;

?>

</pre>

上

下

Hayley Watson ¶

7 年前

在目前可用的雜湊演算法中，SHA3 是由 NIST 從 51 個提交的候選者中選出的，隨後由美國商務部授權用於聯邦政府用途。

http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf

因此，如果您想要選擇雜湊演算法，您可以認為 SHA3 「足以應付政府工作」。

上

下

Leigh ¶

16 年前

關於這些基準測試以及您應如何應用它們的簡短說明。

如果您為了安全起見而雜湊密碼等，速度並不是您的朋友。您應該使用最慢的方法。

雜湊速度慢表示破解速度慢，並且有望使產生彩虹表之類的東西變得比值得的更麻煩。

上

下

synnus at gmail dot com ¶

4 年前

<?php

/* PHP 7.4

雜湊結果編號
1. adler32 (hex) 555.992 毫秒
2. adler32 (raw) 556.945 毫秒
3. fnv132 (raw) 1107.931 毫秒
4. fnv1a64 (raw) 1107.931 毫秒
5. fnv164 (raw) 1108.169 毫秒
6. fnv1a32 (raw) 1108.884 毫秒
7. fnv164 (hex) 1108.884 毫秒
8. fnv1a64 (hex) 1109.123 毫秒
9. fnv132 (hex) 1116.991 毫秒
10. fnv1a32 (hex) 1147.985 毫秒
11. tiger192,3 (raw) 1523.017 毫秒
12. tiger192,3 (hex) 1532.077 毫秒
13. tiger128,3 (hex) 1538.038 毫秒
14. tiger128,3 (raw) 1546.144 毫秒
15. md4 (raw) 1554.965 毫秒
16. md4 (hex) 1565.933 毫秒
17. tiger160,3 (raw) 1574.039 毫秒
18. tiger160,3 (hex) 1588.106 毫秒
19. joaat (hex) 1661.777 毫秒
20. joaat (raw) 1662.969 毫秒
21. md5 (raw) 1822.948 毫秒
22. md5 (hex) 1842.975 毫秒
23. tiger160,4 (hex) 1996.994 毫秒
24. tiger160,4 (raw) 2007.961 毫秒
25. tiger128,4 (raw) 2035.14 毫秒
26. tiger192,4 (raw) 2043.962 毫秒
27. tiger128,4 (hex) 2065.896 毫秒
28. tiger192,4 (hex) 2070.903 毫秒
29. sha1 (hex) 2254.009 毫秒
30. sha1 (raw) 2326.011 毫秒
31. sha3-224 (hex) 2768.039 毫秒
32. sha3-224 (raw) 2783.06 毫秒
33. sha512 (hex) 2936.124 毫秒
34. sha512 (raw) 2943.992 毫秒
35. sha3-256 (hex) 2945.899 毫秒
36. sha3-256 (raw) 2970.933 毫秒
37. sha512/224 (raw) 2990.007 毫秒
38. sha384 (raw) 3006.935 毫秒
39. sha512/224 (hex) 3010.988 毫秒
40. sha512/256 (raw) 3024.101 毫秒
41. sha384 (hex) 3036.975 毫秒
42. ripemd256 (raw) 3068.923 毫秒
43. ripemd256 (hex) 3072.023 毫秒
44. ripemd128 (raw) 3077.03 毫秒
45. ripemd128 (hex) 3123.998 毫秒
46. sha512/256 (hex) 3184.08 毫秒
47. haval256,3 (hex) 3671.884 毫秒
48. haval224,3 (hex) 3776.073 毫秒
49. sha3-384 (hex) 3777.98 毫秒
50. haval128,3 (raw) 3823.041 毫秒
51. haval128,3 (hex) 3829.002 毫秒
52. sha3-384 (raw) 3835.916 毫秒
53. haval256,3 (raw) 3852.128 毫秒
54. haval224,3 (raw) 3855.943 毫秒
55. haval160,3 (raw) 3859.996 毫秒
56. haval160,3 (hex) 3862.857 毫秒
57. haval192,3 (raw) 3892.898 毫秒
58. haval192,3 (hex) 3922.939 毫秒
59. crc32c (hex) 4080.057 毫秒
60. ripemd160 (hex) 4091.024 毫秒
61. ripemd160 (raw) 4094.123 毫秒
62. ripemd320 (raw) 4114.866 毫秒
63. crc32b (hex) 4116.058 毫秒
64. crc32 (raw) 4118.919 毫秒
65. ripemd320 (hex) 4175.186 毫秒
66. crc32c (raw) 4180.908 毫秒
67. crc32 (hex) 4194.974 毫秒
68. crc32b (raw) 4208.803 毫秒
69. sha224 (hex) 4735.946 毫秒
70. sha256 (raw) 4753.112 毫秒
71. sha256 (hex) 4761.934 毫秒
72. sha224 (raw) 4762.887 毫秒
73. haval192,4 (raw) 5304.098 毫秒
74. haval160,4 (raw) 5308.151 毫秒
75. haval128,4 (raw) 5323.886 毫秒
76. haval192,4 (hex) 5346.059 毫秒
77. haval128,4 (hex) 5351.066 毫秒
78. haval256,4 (hex) 5367.04 毫秒
79. haval256,4 (raw) 5378.007 毫秒
80. haval224,4 (raw) 5398.988 毫秒
81. haval224,4 (hex) 5413.055 毫秒
82. sha3-512 (raw) 5460.023 毫秒
83. sha3-512 (hex) 5527.973 毫秒
84. haval160,4 (hex) 5529.88 毫秒
85. haval192,5 (hex) 6403.923 毫秒
86. haval160,5 (raw) 6499.052 毫秒
87. haval128,5 (raw) 6513.833 毫秒
88. haval160,5 (hex) 6540.06 毫秒
89. haval128,5 (hex) 6541.013 毫秒
90. haval192,5 (raw) 6566.047 毫秒
91. haval224,5 (raw) 6567.001 毫秒
92. haval256,5 (hex) 6577.014 毫秒
93. haval224,5 (hex) 6598.949 毫秒
94. haval256,5 (raw) 6598.949 毫秒
95. whirlpool (raw) 9627.103 毫秒
96. whirlpool (hex) 9634.017 毫秒
97. gost (raw) 18457.889 毫秒
98. gost-crypto (raw) 18479.824 毫秒
99. gost (hex) 18527.03 毫秒
100. gost-crypto (hex) 18530.13 毫秒
101. snefru256 (hex) 36260.843 毫秒
102. snefru256 (raw) 36325.931 毫秒
103. snefru (hex) 36480.903 毫秒
104. snefru (raw) 36496.877 毫秒
105. md2 (raw) 184617.996 毫秒
106. md2 (hex) 185398.101 毫秒

*/
?>

上

下

buar42 at gmail dot com ¶

11 年前

我寫了一個 PHP 腳本，可以讓你依據產生時間或雜湊長度，來排序你系統上所有可用的雜湊演算法。它顯示我的系統上的一個一般關聯性 (較長的雜湊需要較長的計算時間)，但有些比其他更快，例如，sha512 產生 (聯合) 最長的雜湊，但實際上只排行第九慢 (從我機器上可用的 43 種雜湊演算法來看)。

我理解，雜湊的強度取決於它擁有的碰撞次數 (其中兩個輸入值產生相同的雜湊)，因此對於無限數量的輸入值，但有限數量的雜湊，會有 (理論上) 無限數量的碰撞。但是，如果你有一個較長的雜湊，那麼你會將無限大除以一個較大的數字，所以你會減少碰撞的次數。

實際上，碰撞的次數將受限於你選擇允許的最小和最大密碼長度，因此如果你強制執行密碼必須正好是特定長度 (例如 20 個字元) 的政策，你將會有大量的唯一密碼，但比你產生的雜湊還小的潛在輸入數量，所以這應該可以完全防止碰撞。理論上。

總之：我認為較長的雜湊比較好。

無論如何，這是程式碼
<?php

$data = "hello"; 

foreach (hash_algos() as $v)
 {
 $time=microtime(1);
 for ($i = 0; $i < 10000; $i++)
 {
 $r[$v] = strlen(hash($v, $data.$i, false));
 }
 $t[$v] = microtime(1)-$time;
 }

switch ($_GET['sort'])
 {
 default:
 ksort ($r);
 $array = 'r';
 break;
 case 'length':
 asort ($r);
 $array = 'r';
 break;
 case 'time':
 asort ($t);
 $array = 't';
 break;
 }

echo '<pre> <a href="?sort=alph">名稱</a> | <a href="?sort=length">雜湊長度</a> | <a href="?sort=time">產生 10000 個雜湊所需時間。</a>'."\n";
foreach ($$array as $key => $value)
 {
 echo $key;
 for ($i = strlen ($key); $i <= 19; $i++)
 {
 echo ' ';
 }
 echo '| '.$r[$key];
 for ($i = strlen ($r[$key]); $i <= 11; $i++)
 {
 echo ' ';
 }
 echo '| '.$t[$key]."\n";
 }

echo '</pre>';

?>

上

下

sneskid at hotmail dot com ¶

12 年前

在兩台不同的伺服器上，我發現 crc32() 與 hash('crc32b',) 有關。
如果你正在編寫基於 hash_file 的 crc32_file 函數，這可能對你有幫助。
(範例沒有補償 crc32 的負數結果)
<?php
$val = 'hello';
var_dump(crc32($val) == ( '0x' . hash('crc32b', $val) ) ); // bool(true)
var_dump(crc32($val) == ( '0x' . hash('crc32', $val) ) ); // bool(false)
?>

此外，如果你正在尋找一種減少碰撞的方法，並保持雜湊結果很小 (小於 md5)，你可以使用 hash/crc32 和 hash/crc32b 來獲得一個友善資料庫的 64 位元值，這比單一的 md5 慢，但結果可能更適合某些任務。
<?php
$val = 'hello';
$crc64 = ( '0x' . hash('crc32', $val) . hash('crc32b', $val) ) );
var_dump($crc64); // string(18) "0x3d6531193610a686"
var_dump($crc64 + 0); // int(4423996193312384646)
?>

(範例在 php 5.2.17 上測試)
注意：('0x' . $hex . + 0) 比 base_convert($hex,16,10) 快

上

下

-2

robert+nospam at robert-gonzalez dot com ¶

14 年前

我最近需要研究各種雜湊演算法以及它們的相同字串的值。為了讓我的生活更輕鬆一點，我編寫了這個小腳本。它會取得一個字串，並在你的伺服器上透過所有可用的雜湊演算法執行它，然後在一個整潔的 HTML 表格中輸出它們。

-----

<?php
/* 如果有表單的已發佈值，則取得該值 */
$p = empty($_POST['p']) ? null : $_POST['p'];
?>
<html>
<head><title>雜湊測試</title></head>
<style type="text/css">
table {border-collapse: collapse;}
table, td, th {border: solid 1px #ccc;}
th {background: #e1e1e1;border-color: #999;}
td, th {padding: 0.25em;}
td.algo {font-weight: bold;}
tr.on td {background: #f0f0f0;}
</style>
<body>
<h1>字串雜湊</h1>
<form method="post" action="<?php echo basename(__FILE__) ?>">
<p><label for="p">輸入要雜湊的字串：</label><br /><input id="p" type="text" name="p" value="<?php echo $p ?>" /></p>
<p><input type="submit" name="submit" value="雜湊它" /></p>
</form>
    
    <?php /* 如果有已發佈的值，則使用它 */ ?>
 <?php if ($p): ?>
 <hr />
<h2>以演算法為基礎，<em><?php echo $p ?></em> 的雜湊值表格</h2>
<table>
<tr>
<th>演算法</th>
<th><em><?php echo $p ?></em> 的雜湊值</th>
</tr>
        <?php /* 遍歷每個雜湊演算法，為每隔一行著色 */ ?>
 <?php $on = false; foreach (hash_algos() as $algo): ?>
<tr<?php if ($on): ?> class="on"<?php endif; ?>>
<td class="algo"><?php echo $algo ?></td>
<td class="hash"><?php echo hash($algo, $p) ?></td>
</tr>
    <?php $on = !$on; endforeach; ?>
</table>
    <?php endif; ?>
</body>
</html>

上

下

-2

Ricardo Striquer (ricardophp yohoocombr) ¶