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: 各种哈希算法的选项数组。目前，只有 "seed" 参数受 MurmurHash 变体支持。

返回值

返回一个字符串，其中包含计算出的消息摘要，以小写十六进制表示，除非 binary 设置为 true，在这种情况下，将返回消息摘要的原始二进制表示。

变更日志

版本	描述
8.1.0	添加了 `options` 参数。
8.0.0	hash() 现在如果 `algo` 未知，则会抛出 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方法生成带密钥的哈希值

发现问题？

了解如何改进此页面 • 提交拉取请求 • 报告错误

＋添加备注

用户贡献的备注 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 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e7304336293e3bf45
sha384 96 59e1748777448c69de6b800d7a33bbfb9ff1b463e44354c355334319957a8f2e2374597888076b907210311d
sha512 128 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dd8be0dbbe930da2564f46204a926024e19525448a4e804630c7c70b05a95d23662c789a9103e9
ripemd128 32 789d569f08ed7055e94b4289a4195012
ripemd160 40 108f07b8382412612c048d07d13f814118445acd
ripemd256 64 cc1d2594aece0a064b7aed75a57283d9490fd5705ed3d66bf9a620250116e9
ripemd320 80 eb0cf45114c56a8421fbcb33430fa22e0cd607560a88bbe14ce682287c78d4d2f23d9829
whirlpool 128 0a25f55d7308eca6b9567a7ed3bd1b46327f0f1ffdc804dd8bb756100095f4f7
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 7c5f22b1a92d9470efea37ec6ed00b2357a4ce3c41aa6e28e3b875e976c3256
gost 64 a7eb5d08ddf2363f1ea0317a803fcef81d33863c8b2f9f6d7d15865b4090a6
adler32 8 062c0215
crc32 8 3d653119
crc32b 8 3610a686
haval128,3 32 85c3e4fac0ba4d85519978fdc3d1d9be
haval160,3 40 0e53b29ad41cea507a343cdd8b62106864f6b3fe
haval192,3 48 bfaf81218bbb8ee51b600f5088c4b8601558ff56e2de1c4f
haval224,3 56 92d0e3354be5d525616f217660e0f860b5d472a9cb99d6766be669422
haval256,3 64 26718e4fb05595cb8703a672a8ae91eea071cac5e7426173d4c7f538d97d69
haval128,4 32 fe10754e0b31d69d4ece9c7a46e044e5
haval160,4 40 b9afd44b015f8afce44e4e02d8b908ed857afbd1
haval192,4 48 ae73833a09e84691d0214f360ee5027396f12599e3618118
haval224,4 56 e1ad67dc7a5901496b15dab92c2715de4b120af2baf661ecd925c024
haval256,4 64 2d39577df3a6a63168826b2a10f07a65a676f5776a0772e0a87059c21a33f
haval128,5 32 d20e920d5be9d9d34855accb501d1987
haval160,5 40 dac5e2024bfea142e53d1422b90c9ee2c8187cc6
haval192,5 48 bbb99b1e989ec3174019b20792fd92dd67175c2ff6ce5965
haval224,5 56 aa6551d75e33a9c5cd4141e9a068b1fc7b6d847f85c3ab162957460a
haval256,5 64 348298791817d5088a6de6c1b6364756d404a50bd64e645035f80c85e0b11

上

下

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 "OK! (".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是从51个提交的候选算法中由NIST选择，随后被美国商务部强制用于联邦政府。

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

*/
?>

上

下

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) ¶

6年前

我没有进行任何测试或实际研究（我正在使用crc32并将其存储在mysql带符号整数类型中），但是如果您的选择算法大于数据库支持的整数，我认为raw_format选项可能是最佳选择，可以直接存储在数据库中，而无需类型转换需求，因为它会导致二进制字符串值。

要检查您选择的算法是否具有数据库中支持的整数大小，只需对raw_format输出使用strlen并查看它有多少字节（例如：crc32有4个字节输出，sha256有32个，md5有16个）。

<?php 
var_dump(strlen(hash('md5', 'string to check', true))); // int(16)
?>

附注：您可以始终使用浮点数来存储非常大的数字，但是对于“普通用户”来说，二进制类型通常更容易检查、理解和维护，因此我建议使用二进制类型，但是如果您追求速度，浮点数可能是您的朋友。

附注：记住……如果没有raw_format，返回值将是十六进制值，没有'Hx'补码，因此要将结果转换为十进制，只需使用hexdec，如下所示……

<?php
var_dump(hexdec(hash('crc32b', 'string to check'))); // int(1206832624)
?>

PS：注册后... 我注意到这里有些测试中 'crc32' 比 md5 慢，据我所知，CRC32 算法（有多种计算 CRC32 的算法）本身应该比 MD5 快，而 Adler-32 比 CRC32 更快（CRC32 比 Adler-32 更一致，比 MD5 不那么一致，但如果您想安全地验证，建议使用 SHA256 或更好的 SHA512，因为它们发生碰撞的可能性更小，因此不易受到碰撞攻击）。

上

下

-2

匿名 ¶

4年前

<?PHP
function allhash($d){
 foreach(hash_algos() as $v){
 $r[] = "$v\t 长度: ".strlen(hash($v, $d));
 }
 return $r;
}

print_r(allhash(1));
?>
输出

数组
(
[0] => md2 长度: 32
[1] => md4 长度: 32
[2] => md5 长度: 32
[3] => sha1 长度: 40
[4] => sha224 长度: 56
[5] => sha256 长度: 64
[6] => sha384 长度: 96
[7] => sha512/224 长度: 56
[8] => sha512/256 长度: 64
[9] => sha512 长度: 128
[10] => sha3-224 长度: 56
[11] => sha3-256 长度: 64
[12] => sha3-384 长度: 96
[13] => sha3-512 长度: 128
[14] => ripemd128 长度: 32
[15] => ripemd160 长度: 40
[16] => ripemd256 长度: 64
[17] => ripemd320 长度: 80
[18] => whirlpool 长度: 128
[19] => tiger128,3 长度: 32
[20] => tiger160,3 长度: 40
[21] => tiger192,3 长度: 48
[22] => tiger128,4 长度: 32
[23] => tiger160,4 长度: 40
[24] => tiger192,4 长度: 48
[25] => snefru 长度: 64
[26] => snefru256 长度: 64
[27] => gost 长度: 64
[28] => gost-crypto 长度: 64
[29] => adler32 长度: 8
[30] => crc32 长度: 8
[31] => crc32b 长度: 8
[32] => crc32c 长度: 8
[33] => fnv132 长度: 8
[34] => fnv1a32 长度: 8
[35] => fnv164 长度: 16
[36] => fnv1a64 长度: 16
[37] => joaat 长度: 8
[38] => haval128,3 长度: 32
[39] => haval160,3 长度: 40
[40] => haval192,3 长度: 48
[41] => haval224,3 长度: 56
[42] => haval256,3 长度: 64
[43] => haval128,4 长度: 32
[44] => haval160,4 长度: 40
[45] => haval192,4 长度: 48
[46] => haval224,4 长度: 56
[47] => haval256,4 长度: 64
[48] => haval128,5 长度: 32
[49] => haval160,5 长度: 40
[50] => haval192,5 长度: 48
[51] => haval224,5 长度: 56
[52] => haval256,5 长度: 64
)

上

下

-5

inspiration3 at gmail dot com ¶

16年前

另一个全面的基准测试脚本，它按从好到坏的顺序排列结果，并包含 crc32()、md5() 和 sha1() 独立函数。

<?php

define('HASH_TIMES', 1000);
define('HASH_DATA', 'The quick brown fox jumped over!'); // 32 字节

header('Content-Type: text/plain');
echo '测试 ' . strlen(HASH_DATA) . ' 字节的数据超过 ' . HASH_TIMES . " 次迭代:\n";

foreach (hash_algos() as $algo) {
 $time = microtime(1);
 for ($i = 0; $i < HASH_TIMES; $i++) hash($algo, HASH_DATA);
 $results[$algo] = microtime(1) - $time;
}

$time = microtime(1); for ($i = 0; $i < HASH_TIMES; $i++) crc32(HASH_DATA); $results['crc32()'] = microtime(1) - $time;
$time = microtime(1); for ($i = 0; $i < HASH_TIMES; $i++) md5(HASH_DATA); $results['md5()'] = microtime(1) - $time;
$time = microtime(1); for ($i = 0; $i < HASH_TIMES; $i++) sha1(HASH_DATA); $results['sha1()'] = microtime(1) - $time;

asort($results, SORT_NUMERIC);
foreach ($results as $algo => $time) echo "\n$time\t$algo";

?>

上

下

-5

Hayley Watson ¶

7年前

这些是哈希函数。有些被设计为文档的签名，而另一些则只是作为检查，用于确保传输的数据在传输过程中没有损坏或以其他方式修改，并且不提供任何加密功能。

了解它们的区别，并使用合适的函数，因为使用错误的哈希函数可能比根本不使用更糟糕。