hash

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

hash — 生成哈希值（消息摘要）

描述

hash(
    string $algo,
    string $data,
    bool $binary = false,
    array $options = []
): string

参数

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 方法生成带密钥的哈希值

改进此页面

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

＋添加备注

用户贡献的备注 15 个备注

向上

向下

682

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

向上

向下

153

Kai Petzke ¶

14 年前

在新的应用程序中应避免使用众所周知的哈希函数 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 年前（根据这个评论：https://secure.php.net/manual/en/function.hash.php#89574 ）多了 65 种。

另外，这是我的结果：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

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

*/
?>

向上

向下

buar42 at gmail dot com ¶

10 年前

我写了一个 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) ¶

5 年前

我还没有进行任何测试或实际研究（我使用 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)
?>

PS：你总是可以使用浮点数来存储一个很大的数字，但是对于“普通人类”来说，二进制类型总的来说更容易检查、理解和维护，因此我建议使用二进制，但是如果你关心速度，那么浮点数可能是你的朋友。

PS：记住... 不使用 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，因为它们不太可能发生冲突，因此不易受到冲突攻击）。

向上

向下

-6

rojaro at gmail dot com ¶

13 年前

如果给定的 algo 参数包含不支持的算法，则哈希函数将返回 bool(false) 并发出警告。

向上

向下

-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 bytes

header('Content-Type: text/plain');
echo 'Testing ' . strlen(HASH_DATA) . ' bytes of data over ' . HASH_TIMES . " iterations:\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 年前

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

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

向上

向下

-3

Anonymous ¶

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
)