smhasher
1.0.0
| Fonction de hachage | Mio/sec | cycl./hachage | cycl./carte | taille | Problèmes de qualité |
|---|---|---|---|---|---|
| ne rien faire32 | 11149460.06 | 16h00 | - | 13 | mauvaise graine 0, test NOP |
| rien faire64 | 11787676.42 | 16h00 | - | 13 | mauvaise graine 0, test NOP |
| ne rien faire128 | 11745060.76 | 4.06 | - | 13 | mauvaise graine 0, test NOP |
| NOP_OAAT_read64 | 11372846.37 | 14h00 | - | 47 | tester NOP |
| MauvaisHash | 769,94 | 73,97 | - | 47 | mauvaise graine 0, test FAIL |
| sumhash | 10699.57 | 29.53 | - | 363 | mauvaise graine 0, test FAIL |
| sumhash32 | 42877.79 | 23.12 | - | 863 | UB, test ÉCHEC |
| multiplier_shift | 8026.77 | 26.05 | 226,80 (8) | 345 | mauvaises graines & 0xfffffff0, échoue à la plupart des tests |
| paire_multiply_shift | 3716.95 | 40.22 | 186.34 (3) | 609 | échoue à la plupart des tests |
| -------------------------- | |||||
| crc32 | 383.12 | 134.21 | 257,50 (11) | 422 | non sécurisé, collisions 8590x, distribution, PerlinNoise |
| md5_32 | 350,53 | 644.31 | 894.12 (10) | 4419 | |
| md5_64 | 351.01 | 656.67 | 897.43 (12) | 4419 | |
| md5-128 | 350,89 | 681,88 | 894.03 (13) | 4419 | |
| sha1_32 | 353.03 | 1385.80 | 1759.94 (5) | 5126 | Santé mentale, faible cyclique32, distribution à 36,6 % |
| sha1_64 | 353.03 | 1385.80 | 1759.94 (5) | 5126 | Santé mentale, faible cyclique32, distribution à 36,6 % |
| sha1-160 | 364,95 | 1470.55 | 1794.16 (13) | 5126 | Peigne/Cyclique bas32 |
| sha2-224 | 147.13 | 1354.81 | 1589.92 (12) | Peigne bas32 | |
| sha2-224_64 | 147,60 | 1360.10 | 1620.93 (13) | Bas cyclique32 | |
| sha2-256 | 147,80 | 1374.90 | 1606.06 (16) | ||
| sha2-256_64 | 148.01 | 1376.34 | 1624.71 (16) | ||
| sha1ni | 1601.21 | 174.16 | 397.28 (6) | 989 | non sécurisé, bon sens, permutation, zéros, spécifique à la machine |
| sha1ni_32 | 1576.17 | 174.04 | 405.56 (6) | 989 | spécifique à la machine |
| sha2ni-256 | 1527.38 | 184,35 | 404.40 (4) | 4241 | non sécurisé, bon sens, permutation, zéros, spécifique à la machine |
| sha2ni-256_64 | 1501.85 | 186.20 | 407.96 (5) | 4241 | Zéros, spécifiques à la machine |
| blake3_c | 1288.84 | 357,69 | 582,89 (6) | pas de portabilité 32 bits | |
| RMD128 | 290,90 | 710.49 | 965.55 (6) | ||
| RMD160 | 202.16 | 1045.79 | 1287.74 (16) | Hi32 cyclique | |
| rmd256 | 364.81 | 584,86 | 835.02 (11) | ||
| edonr224 | 864.69 | 303.42 | 526.94 (6) | ||
| edonr256 | 847,85 | 305,79 | 510.01 (4) | ||
| blake2s-128 | 295.30 | 698.09 | 1059.24 (51) | ||
| blake2s-160 | 215.01 | 1026,74 | 1239.54 (11) | ||
| blake2s-224 | 207.06 | 1063.86 | 1236,50 (20) | ||
| blake2s-256 | 215.28 | 1014.88 | 1230.38 (28) | ||
| blake2s-256_64 | 211.52 | 1044.22 | 1228.43 (8) | ||
| blake2b-160 | 356.08 | 1236.84 | 1458.15 (12) | ||
| blake2b-224 | 356,59 | 1228,50 | 1425.87 (16) | ||
| blake2b-256 | 355,97 | 1232.22 | 1443.31 (19) | ||
| blake2b-256_64 | 356,97 | 1222.76 | 1435.03 (9) | ||
| asconhashv12 | 144,98 | 885.02 | 1324.23 (38) | 4341 | |
| asconhashv12_64 | 159,68 | 386,90 | 480,86 (4) | 6490 | |
| sha3-256 | 100,58 | 3877.18 | 4159.79 (37) | PerlinBruit | |
| sha3-256_64 | 100,57 | 3909.00 | 4174.63 (16) | PerlinBruit | |
| hasshe2 | 2773.89 | 64.35 | 282.30 (3) | 445 | Permutation, deux octets, zéros, graine |
| poly_1_mersenne | 1369.21 | 61,59 | 248,86 (4) | 479 | échoue à la plupart des tests |
| poly_2_mersenne | 1364.03 | 70h30 | 261,00 (6) | 479 | |
| poly_3_mersenne | 1342.82 | 80.22 | 268,79 (2) | 479 | |
| poly_4_mersenne | 1343.19 | 89.13 | 277.52 (3) | 479 | |
| tabulation32 | 5781.16 | 40h00 | 241,79 (10) | 848 | collision |
| tabulation | 7875.01 | 39,95 | 249.49 (3) | 554 | |
| crc32_hw | 6244.38 | 41.23 | 226,80 (2) | 653 | non sécurisé, biais à 100 %, collisions, distribution, BIC, spécifique à la machine (SSE4.2/NEON) |
| crc32_hw1 | 7569.29 | 49.07 | 233.75 (3) | 671 | non sécurisé, biais à 100 %, collisions, distribution, BIC, spécifique à la machine (x86 SSE4.2) |
| crc64_hw | 6143.62 | 40.48 | 223.13 (2) | 652 | non sécurisé, biais à 100 %, collisions, distribution, BIC, spécifique à la machine (SSE4.2/NEON) |
| crc32_pclmul | - | - | - | non sécurisé, 100 % de biais, collisions, distribution, BIC, spécifique à la machine (x86 SSE4.2+PCLMUL) | |
| o1hash | 11629440.57 | 18h15 | 199.35 (2) | 101 | non sécurisé, pas de graine, zéros, échoue à tous les tests |
| fibonacci | 16878.32 | 22.94 | 803.18 (15) | 1692 | UB, zéros, échoue à tous les tests |
| FNV1a | 760.52 | 73,83 | 254.29 (5) | 204 | mauvaise graine, zéros, échoue à tous les tests |
| FNV1A_Totenschiff | 6274.78 | 26.23 | 251.13 (2) | 270 | UB, zéros, échoue à tous les tests |
| FNV1A_Pippip_Yurii | 6172.14 | 27h55 | 244,80 (2) | 147 | UB, santé mentale, échoue à tous les tests |
| FNV1a_YT | 13486.49 | 30h50 | 237.43 (4) | 321 | mauvaise graine, UB, échoue à tous les tests |
| FNV2 | 6171.60 | 32h20 | 208.59 (4) | 278 | échoue à tous les tests |
| FNV64 | 774.37 | 72.43 | 201.15 (2) | 79 | échoue à tous les tests |
| FNV128 | 390.14 | 136.42 | 289,00 (3) | 171 | échoue à tous les tests |
| k-hash32 | 2230.42 | 53.05 | 264.64 (3) | 808 | non sécurisé, zéros, UB, mauvaises graines, échoue à tous les tests |
| k-hash64 | 2451.88 | 48.66 | 249.44 (2) | 609 | non sécurisé, zéros, UB, mauvaises graines, échoue à tous les tests |
| fletcher2 | 15552.61 | 20.61 | 335.31 (3) | 248 | mauvaise graine 0, UB, échoue à tous les tests |
| fletcher4 | 15556.93 | 20h60 | 358,60 (3) | 371 | mauvaise graine 0, UB, échoue à tous les tests |
| Bernstein | 1045,97 | 58.31 | 225.78 (3) | 41 | mauvaise graine 0, échoue à tous les tests |
| SDBM | 784.83 | 68,57 | 222.68 (5) | 41 | mauvaise graine 0, échoue à tous les tests |
| x17 | 748,75 | 74.13 | 236,00 (10) | 79 | Biais de 99,98 %, échoue à tous les tests |
| liberté | 628,66 | 84,95 | 225.07 (4) | 37 | peu sûr, 100 % de biais, échoue à tous les tests, mauvaise graine |
| gcc | 611.69 | 86.47 | 231.51 (5) | 39 | peu sûr, 100 % de biais, échoue à tous les tests, mauvaise graine |
| JenkinsOOAT | 627,64 | 107.04 | 252.79 (3) | 153 | mauvaise graine 0, biais de 53,5 %, échoue à tous les tests |
| JenkinsOOAT_perl | 608.10 | 94.17 | 254.09 (4) | 65 | mauvaise graine 0, biais de 1,5 à 11,5 %, collisions 7,2x, BIC, LongNeighbors |
| MicroOAAT | 701.35 | 76,68 | 251.01 (3) | 68 | Biais à 100 %, distribution, BIC |
| poiresonhash64 | 434.17 | 124.14 | 230,79 (4) | Avalanche, Seed, SSSE3 uniquement. MSVC cassé | |
| poiresonhash128 | 434.23 | 121.34 | 221.03 (7) | Avalanche, Seed, SSSE3 uniquement. MSVC cassé | |
| poiresonhash256 | 444.08 | 119.11 | 229,75 (4) | Avalanche, Seed, SSSE3 uniquement. MSVC cassé | |
| VHASH_32 | 13053.40 | 65,84 | 289,86 (3) | 1231 | santé mentale, graine, MomentChi2 |
| VHASH_64 | 13465.50 | 63,88 | 286.38 (5) | 1231 | santé mentale, graine, clairsemée |
| farsh32 | 27038.23 | 66,88 | 278,89 (5) | 944 | non sécurisé : AppendedZeroes, collisions+bias, MomentChi2, LongNeighbors |
| farsh64 | 13829.32 | 112.46 | 332.59 (3) | 944 | non sécurisé : AppendedZeroes, collisions+bias, MomentChi2, LongNeighbors |
| farsh128 | 6878.88 | 233.35 | 384,85 (3) | 944 | non sécurisé : AppendedZeroes, collisions+bias, permut,combin,2bytes,zeroes,PerlinNoise |
| farsh256 | 3467.37 | 440.40 | 593.57 (5) | 944 | non sécurisé : AppendedZeroes, collisions+bias, permut,combin,2bytes,zeroes,PerlinNoise |
| jodyhash32 | 1794.34 | 41.12 | 235.12 (4) | 102 | biais, collisions, distribution, BIC LongNeighbors |
| jodyhash64 | 4813.10 | 40.72 | 239.22 (6) | 118 | biais, collisions, distribution, BIC, LongNeighbours |
| recherche3 | 2475.35 | 39,65 | 240.10 (3) | 341 | UB, biais de 28 %, collisions, distribution de 30 %, BIC |
| ultra rapide | 2058.22 | 49.56 | 254.12 (3) | 210 | UB, mauvaise graine 0, biais de 91 %, collisions 5273.01x, distribution de 37 %, BIC |
| MurmureOAAT | 506.66 | 103.33 | 236,89 (3) | 47 | mauvaise graine 0, collisions, distribution à 99,998 %, BIC, LongNeighbours |
| Merde8 | 3041.14 | 37.25 | 247,87 (4) | 342 | UB, biais de 2,42 %, collisions, distribution de 2 % |
| Murmure1 | 2027.85 | 48.51 | 253.34 (3) | 358 | UB, 1 mauvaise graine, 511x collisions, Diff, BIC |
| Murmure2 | 3089.18 | 41.22 | 238.42 (4) | 358 | UB, 1 mauvaise graine, biais 1,7 %, 81x coll, distribution 1,7 %, BIC |
| Murmure2A | 3087.98 | 45,90 | 238.54 (4) | 407 | UB, 1 mauvaise graine, biais de 12,7 %, LongNeighbors |
| Murmure2B | 5919.38 | 38.18 | 215,96 (3) | 433 | UB, biais de 1,8 %, collisions, distribution de 3,4 %, BIC |
| Murmure2C | 3810.98 | 49.09 | 218.51 (3) | 444 | UB, 2 ^ 32 mauvaises graines, biais de 91 %, collisions, distribution, BIC, LongNeighbors |
| Murmure3A | 2982.67 | 49.08 | 245,78 (4) | 351 | UB, 1 mauvaise graine, Moment Chi2 69 |
| PMurHash32 | 3005.85 | 48,88 | 242.38 (3) | 1862 | 1 mauvaise graine, Moment Chi2 69 |
| Murmure3C | 4833.18 | 56,87 | 250.47 (6) | 859 | UB, LongNeighbours, Texte, DiffDist |
| mirhash32low | 6145.39 | 36,95 | 235.09 (4) | 1112 | UB, 4 mauvaises graines, Cyclique, LongNeighbors, spécifique à la machine (32/64 diffèrent) |
| PMPML_32 | 6639.68 | 45.33 | 257.45 (3) | 1084 | Avalanche >512, non ensemencée : Seed, BIC, MomentChi2, PerlinNoise |
| PMPML_64 | 9833.77 | 50.00 | 251.64 (6) | 1305 | non ensemencé : Seed, MomentChi2, BIC |
| xxHash32 | 5865.17 | 49.20 | 242.74 (3) | 738 | LongNeighbors, collisions avec diff 4 bits, MomentChi2 220 |
| métrohash64 | 14741.56 | 39.44 | 215.76 (2) | 624 | UB, LongNeighbors, BIC |
| métrohash64_1 | 14298.77 | 40.31 | 223.25 (4) | 624 | UB, LongNeighbours, BIC, MomentChi2 |
| métrohash64crc_1 | 6929.69 | 44,65 | 223.68 (3) | 632 | UB, cyclique 8/8 octets, DiffDist, BIC, MomentChi2, spécifique à la machine (SSE4.2/NEON) |
| metrohash64crc_2 | 8150.65 | 43.72 | 219.45 (5) | 632 | UB, cyclique 8/8 octets, DiffDist, BIC, spécifique à la machine (SSE4.2/NEON) |
| cmetrohash64_1o | 14921.73 | 38,95 | 213.25 (2) | 3506 | UB, LongNeighbours, BIC, MomentChi2 |
| cmetrohash64_1 | 14151.73 | 40,90 | 211.89 (2) | 652 | UB, LongNeighbours, BIC, MomentChi2 |
| City64noGraine | 14209.19 | 31,80 | 225,90 (5) | 1038 | Avalanche, clairsemé, TwoBytes, MomentChi2, graine |
| Ville64 | 13887.84 | 46.32 | 239.77 (3) | 1120 | clairsemé, deux octets |
| t1ha1_64le | 13442.64 | 31.41 | 219.58 (3) | 517 | Avalanche |
| t1ha1_64be | 11586.02 | 32,74 | 232.55 (3) | 555 | Avalanche |
| t1ha0_32le | 7401.21 | 48.27 | 238,99 (3) | 509 | Voisins clairsemés et longs |
| t1ha0_32be | 6217.37 | 50,66 | 244.51 (3) | 533 | Voisins clairsemés et longs |
| t1ha2_stream | 14011.63 | 80,72 | 275.17 (3) | 1665 | Clairsemé, Permutation, LongNeighbours |
| t1ha2_stream128 | 13136.06 | 97.80 | 306.11 (7) | 1665 | Clairsemé, Permutation, LongNeighbours |
| aesnihash | 5579.32 | 56,83 | 258.71 (5) | 1209 | échoue à de nombreux tests, spécifiques à la machine (x64 AES-NI) |
| Falkhash | 50631.69 | 123.02 | 322.14 (7) | 264 | Sparse, LongNeighbors, spécifiques à la machine (x64 AES-NI) |
| MiaouHash | 29969.40 | 64,96 | 274.29 (4) | 1764 | Sparse, inversible, spécifique à la machine (x64 AES-NI) |
| MiaouHash64low | 29485.59 | 65,98 | 278.05 (3) | 1764 | Sparse, inversible, spécifique à la machine (x64 AES-NI) |
| MiaouHash32low | 26944.58 | 65,95 | 292,79 (9) | 1764 | Sparse, inversible, spécifique à la machine (x64 AES-NI) |
| -------------------------------------- | |||||
| tifuhash_64 | 35.60 | 1679.52 | 1212.75 (15) | 276 | Bas cyclique32 |
| disquettehash | 35,72 | 1868.92 | 1411.07 (7) | 623 | |
| séparateur de faisceau | 789.22 | 682,45 | 1150.33 (26) | 4203 | UB |
| discohash1 | 4131.12 | 199.00 | 398.35 (5) | 1294 | |
| discohash1-128 | 4072.95 | 234.17 | 438.43 (5) | 1294 | |
| discohash2 | 3986.52 | 207.52 | 421,99 (2) | 1294 | |
| discohash2-128 | 4094.73 | 236.61 | 433.35 (4) | 1294 | |
| discothèqueNONG | 3698.45 | 399,67 | 597,78 (9) | mauvaises graines | |
| clé de chasse | 1143.05 | 113,70 | 294.43 (4) | 1609 | PerlinBruit |
| SipHash | 943.53 | 147.15 | 338.74 (4) | 1071 | |
| Demi-SipHash | 1141.57 | 79,65 | 263.96 (3) | 700 | des zéros |
| BonOAAT | 743.81 | 85,62 | 231.22 (3) | 237 | |
| pearsonbhash64 | 1794.83 | 97.80 | 268,90 (8) | 683 | |
| pearsonbhash128 | 1691.62 | 104,57 | 272.38 (4) | 1134 | |
| pearsonbhash256 | 1442.59 | 126.04 | 309.34 (4) | 844 | |
| prvhash64_64m | 3077.18 | 47.31 | 241.92 (3) | 349 | |
| prvhash64_64 | 3015.08 | 48.03 | 240.64 (3) | 384 | |
| prvhash64_128 | 3353.81 | 67,64 | 266.32 (2) | 718 | |
| prvhash64s_64 | 6591.34 | 273,50 | 464.65 (3) | 2640 | |
| prvhash64s_128 | 6581.40 | 333,83 | 528.07 (5) | 2799 | |
| SipHash13 | 1812.75 | 106,56 | 310.76 (5) | 778 | Biais de 0,9 % |
| Astuce | 4233.17 | 53.31 | 249.19 (3) | 519 | !msvc |
| hachis de mer | 8261.80 | 58,94 | 256.08 (4) | 871 | PerlinNoise, !msvc |
| seahash32low | 8266.17 | 58.90 | 290.21 (16) | 871 | PerlinNoise 32, !msvc |
| choc | 18703.04 | 70.19 | 282.12 (6) | 1809 | PerlinNoise, spécifique à la machine (x64 SSE4.2) |
| AutorouteHash64 | 6242.58 | 99.55 | 248.41 (3) | 2546 | |
| Murmure3F | 7623.44 | 52,69 | 221.87 (3) | 699 | UB |
| MAMAN | 9563.99 | 34,99 | 228.55 (5) | 1912 | UB, trop de mauvaises graines, spécifique à la machine (32/64 diffèrent) |
| MUMfaible | 9261.89 | 36.17 | 247.66 (4) | 1912 | UB, 5 mauvaises graines |
| xmsx32 | 2039.10 | 46.39 | 249.30 (7) | 192 | 2 mauvaises graines |
| mirhash | 6139.07 | 37.02 | 209.47 (3) | 1112 | UB, 2 ^ 36 mauvaises graines, LongNeighbors, spécifiques à la machine (32/64 diffèrent) |
| mirhashstrict | 3549.01 | 49,99 | 224.91 (2) | 1112 | |
| mirhashstrict32low | 3441.35 | 50,60 | 247.19 (3) | 1112 | 1 mauvaise graine, MomentChi2 9 |
| fasthash32 | 6128.28 | 40h30 | 241.64 (4) | 566 | UB |
| fasthash64 | 5818.92 | 38.70 | 220.74 (2) | 509 | UB |
| aesni | 31232.34 | 29.21 | 230.14 (4) | 519 | spécifique à la machine (x64 AES-NI) |
| aesni-faible | 31221.14 | 29.64 | 226.18 (3) | 519 | spécifique à la machine (x64 AES-NI) |
| mx3 | 9034.90 | 48.71 | 227,89 (2) | 734 | UB |
| pengyhash | 13428.80 | 74.24 | 275.42 (5) | 421 | |
| Ville32 | 5551.28 | 54.40 | 261.64 (2) | 1319 | |
| Ville64low | 13904.10 | 46.24 | 260.08 (3) | 1120 | |
| Ville128 | 14031.96 | 89.09 | 290.05 (10) | 1841 | |
| VilleCrc128 | 7916.44 | 55,50 | 240,79 (2) | 295 | |
| FermeHash32 | 21755.58 | 47.54 | 258.35 (3) | 11489 | spécifique à la machine (x64 SSE4/AVX) |
| FermeHash64 | 12845.53 | 47.11 | 251.58 (3) | 3758 | |
| FermeHash128 | 13913.65 | 70.25 | 263.06 (3) | 163 | |
| farmhash32_c | 21601.86 | 47.38 | 273,00 (3) | 762 | spécifique à la machine (x64 SSE4/AVX) |
| farmhash64_c | 12834.10 | 47.23 | 246.20 (2) | 3688 | |
| farmhash128_c | 13753.24 | 68,96 | 263.76 (3) | 1890 | |
| métrohash64_2 | 14316.37 | 40.23 | 218.28 (3) | 627 | UB, LongNeighbours |
| cmetrohash64_2 | 14294.26 | 40,76 | 221.40 (4) | 655 | Longs voisins |
| métrohash128 | 15634.66 | 73.28 | 261.23 (4) | 773 | UB, LongNeighbours |
| métrohash128_1 | 15806.97 | 72h30 | 260,90 (4) | 773 | UB, LongNeighbours |
| métrohash128_2 | 15822.60 | 72h30 | 255.34 (3) | 773 | UB, LongNeighbours |
| métrohash128crc_1 | 8009.23 | 78.72 | 281,55 (13) | 723 | UB, spécifique à la machine (SSE4.2/NEON) |
| métrohash128crc_2 | 7878.22 | 79.90 | 275.22 (4) | 723 | UB, spécifique à la machine (SSE4.2/NEON) |
| xxHash64 | 12108.87 | 49,78 | 228.83 (2) | 1999 | |
| Effrayant32 | 13108.95 | 56.27 | 255.36 (3) | 2221 | UB |
| Effrayant64 | 13529.36 | 58,76 | 236.31 (3) | 2221 | UB |
| Effrayant128 | 11781.35 | 58.91 | 242.91 (3) | 2221 | UB |
| EffrayantV2_32 | 13529.16 | 55.55 | 248.37 (4) | 2069 | |
| EffrayantV2_64 | 12678.82 | 56.71 | 243.21 (4) | 2069 | |
| EffrayantV2_128 | 13512.82 | 58.33 | 244.56 (5) | 2069 | |
| ahash64 | 9862.62 | 27.32 | 181.68 (1) | 412 | rouiller |
| xxh3 | 21033.55 | 29h48 | 226.77 (4) | 744 | DiffDist bit 7 w. 36 bits, BIC |
| xxh3low | 17093.19 | 30.57 | 242.07 (7) | 756 | |
| xxh128 | 18802.16 | 32.37 | 234.30 (4) | 1012 | |
| xxh128faible | 18833.05 | 32h30 | 234.68 (3) | 1012 | |
| t1ha2_atonce | 13854.44 | 37,92 | 233.54 (2) | 541 | Zéros bas3 |
| t1ha2_atonce128 | 14148.42 | 55,70 | 253.74 (6) | 613 | Longs voisins |
| t1ha0_aes_noavx | 27231.59 | 37.70 | 236.10 (3) | 925 | LongNeighbors, spécifiques à la machine (x86 AES-NI) |
| t1ha0_aes_avx1 | 22714.85 | 48.12 | 226.52 (16) | 843 | LongNeighbors, spécifiques à la machine (x64 AVX.txt) |
| t1ha0_aes_avx2 | 56919.46 | 36.70 | 233.14 (2) | 792 | LongNeighbors, spécifiques à la machine (x64 AVX2) |
| wyhash32 | 2532.89 | 48h40 | 484.57 (1) | 426 | 4 graines mauvaises et cassées, 32 bits |
| wyhash32low | 22393.77 | 29.04 | 243.40 (3) | 474 | 5 mauvaises graines |
| wyhash | 22540.23 | 28.87 | 236.16 (8) | 474 | |
| hachage rapide | 23789.79 | 22.80 | 138.71 (7) | 574 | |
| rapidhash_unrolled | 23892.88 | 23.41 | 139.47 (12) | 782 | |
| umash32 | 21427.57 | 42.12 | 255.55 (5) | 1530 | |
| umash32_salut | 21483.12 | 42,65 | 251.09 (4) | 1530 | |
| umash64 | 21690.08 | 41,67 | 238.01 (4) | 1530 | |
| umash128 | 13211.88 | 43.37 | 237.40 (3) | 1530 | |
| mi-temps_hash64 | 4735.63 | 99.90 | 315.34 (3) | 2911 | |
| mi-temps_hash128 | 17534.53 | 97,97 | 311.10 (4) | 2462 | |
| mi-temps_hash256 | 18003.39 | 99.46 | 315.09 (3) | 2622 | |
| mi-temps_hash512 | 10890.15 | 118.05 | 333.45 (3) | 3550 | |
| nmhash32 | 12969.62 | 55,88 | 265.69 (4) | 2445 | |
| nmhash32x | 12775.08 | 42,66 | 246.05 (3) | 1494 | |
| k-hashv32 | 9181.87 | 52,76 | 245.14 (3) | 1280 | |
| k-hashv64 | 7850.92 | 46,94 | 193.94 (1) | 1279 | |
| komihash | 12242.78 | 33.02 | 236.07 (2) | 1323 | |
| polymère | 9676.33 | 42,70 | 246.53 (3) | 1128 |
Les variantes de table triable :
AMD Ryzen 5 3350G 3,6 GHz par défaut
Intel i5-2300 2,8 GHz
Intel i5-2300 2,8 GHz 32 bits
AMD Ryzen 3 3200U 3,5 GHz
Mac Air i7-4650
Cortex-A53 2 GHz (Sony XPeria L4)
J'ai ajouté quelques hachages assistés par SSE et des variantes rapides Intel/arm CRC32-C, AES et SHA HW. Voir aussi l'ancien https://github.com/aappleby/smhasher/wiki, le fork amélioré mais non maintenu https://github.com/demerphq/smhasher et la nouvelle version améliorée SMHasher3 https://gitlab.com/ fwojcik/smhasher3.
Ainsi, les fonctions de hachage les plus rapides sur x86_64 sans problèmes de qualité sont :
rapidhash (un wyhash amélioré)
xxh3low
wyhash
umash (même universel !)
ahash64
t1ha2_atonce
komihash
FarmHash ( non portable, trop spécifique à la machine : 64 vs 32 bits, ancien gcc, ... )
mi-temps_hash128
Effrayant32
pengyhash
nmhash32
mx3
MUM/mir ( résultats différents sur les archs 32/64 bits, beaucoup de mauvaises graines à filtrer )
fasthash32
Les fonctions de hachage pour les tables de symboles ou les tables de hachage utilisent généralement des hachages de 32 bits, pour les bases de données, les systèmes de fichiers et les sommes de contrôle de fichiers, généralement de 64 ou 128 bits, pour le chiffrement commençant désormais par 256 bits.
La taille médiane typique d'une clé dans Perl5 est de 20, la plus courante étant de 4. Similaire pour tous les autres langages dynamiques. Voir github.com/rurban/perl-hash-stats
Lorsqu'il est utilisé dans une table de hachage, le cache d'instructions bat généralement le processeur et le débit mesurés ici. Dans mes tests, le plus petit FNV1A bat le plus rapide crc32_hw1 avec les tables de hachage Perl 5. Même si ces pires fonctions de hachage entraînent davantage de collisions, l'avantage global en termes de vitesse et de capacité en ligne surpasse la qualité légèrement inférieure. Voir par exemple une analyse en sept dimensions des méthodes de hachage et ses implications sur le traitement des requêtes pour un aperçu concis des meilleures stratégies de table de hachage, confirmant que le hachage Mult le plus simple (bernstein, FNV*, x17, sdbm) bat toujours les « meilleures » fonctions de hachage. (Tabulation, Murmur, Farm, ...) lorsqu'il est utilisé dans une table de hachage.
Les fonctions de hachage rapide testées ici sont recommandées aussi rapidement pour les résumés de fichiers et peut-être pour les bases de données plus volumineuses, mais pas pour les tables de hachage 32 bits. Les "problèmes de qualité" conduisent à une distribution moins uniforme, c'est-à-dire plus de collisions et de moins bonnes performances, mais sont rarement liés à de véritables attaques de sécurité, seul le deuxième test de santé mentale d'AppendZeroes contre � est pertinent pour la sécurité.
Mio/sec : moyenne du test de vitesse de clé en bloc pour les alignements 0 à 7 avec des clés de 262 144 octets. Plus c’est haut, mieux c’est.
cycl./hash : La moyenne du test de vitesse des petites clés pour les clés de 1 à 31 octets. Plus c’est petit, mieux c’est.
cycl./map : le résultat du test Hashmap pour /usr/dict/words avec des requêtes d'obtention de hashmap C++ rapides, avec l'écart type entre parenthèses. Cela teste l'inlinabilité de la fonction de hachage dans la pratique (voir taille). Plus c’est petit, mieux c’est.
size : La taille de l’objet en octets sur AMD64. Cela affecte l'inlinabilité, par exemple, des tables de hachage. Plus c’est petit, mieux c’est.
Problèmes de qualité : Voir les échecs dans la doc liée. Moins il y en a, mieux c'est.
https://github.com/martinus/better-faster-stronger-mixer Mélangeurs. Et sur son blog les meilleurs benchmarks de hashmap C++.
http://nohatcoder.dk/2019-05-19-1.html donne une nouvelle classification de niveau de hachage utile 1-5.
http://www.strchr.com/hash_functions répertorie d'autres références et la qualité des fonctions de hachage les plus simples et rapides.
http://bench.cr.yp.to/primitives-hash.html répertorie les références de tous les hachages sécurisés actuellement testés.
http://valerieaurora.org/hash.html Durées de vie des fonctions de hachage cryptographique
Les attaques par table de hachage décrites dans SipHash contre City, Murmur ou Perl JenkinsOAAT ou dans Hash Function Lounge ne sont pas incluses ici. Nous listons quelques attaques connues au GH #186.
Un tel évitement des attaques ne peut pas être le problème de la fonction de hachage, mais uniquement du schéma de résolution des collisions des tables de hachage. Vous pouvez attaquer chaque fonction de hachage, même la meilleure et la plus sécurisée, si vous détectez la graine, par exemple à partir de (mauvaises) fonctionnalités de langage, d'attaques par canal secondaire, de timings de collision et indépendamment de l'ordre de tri, vous devez donc protéger votre collision. schéma de traitement à partir du pire des cas O(n), c'est-à-dire un chaînage séparé avec des listes chaînées. Le chaînage de listes chaînées permet des facteurs de charge élevés, mais est très peu convivial pour le cache. Le seul schéma de liste chaînée recommandable consiste à intégrer la clé ou le hachage dans le tableau. De nos jours, tout le monde utilise un adressage ouvert rapide, même si le facteur de charge doit être d'environ 50 %, à moins que vous n'utilisiez Cuckoo Hashing.
C'est-à-dire que l'utilisation de SipHash pour leur table de hachage dans Python 3.4, Ruby, Rust, Systemd, OpenDNS, Haskell et OpenBSD est un pur théâtre de sécurité. SipHash n'est pas suffisamment sécurisé pour des raisons de sécurité et pas assez rapide pour un usage général. La génération par force brute d'environ 32 000 collisions nécessite 2 à 4 m pour tous ces hachages. siphash étant le plus lent, il nécessite un maximum de 4 min, les autres généralement un maximum de 2 m30, avec <10 s pour des attaques de collision pratiques de 16 000 avec toutes les fonctions de hachage. L'utilisation de Murmur est généralement plus lente qu'un simple Mult, même dans le pire des cas. La sécurité prouvable est uniquement un hachage uniforme, c'est-à-dire 2 à 5 Mult ou Tabulation indépendants, ou l'utilisation d'un schéma de collision logarithmique garanti (un arbre) ou d'un schéma de collision linéaire, tel que swisstable/folly-F14, Robin Hood ou Cuckoo hachage avec comptage de collisions.
Une dernière remarque concernant la sécurité : de nos jours, même SHA1 peut être résolu dans un solveur, comme Z3 (ou des plus rapides) pour des attaques pratiques par collision avec des tables de hachage (c'est-à-dire 14-20 bits). Toutes les fonctions de hachage de moins de 160 bits testées ici ne peuvent pas du tout être considérées comme « sécurisées ».
L'attaque de vulnérabilité '�' avec des clés binaires est testée dans le 2ème test Sanity Zero.
Nos hachages cryptographiques sont renforcés avec une graine size_t ajoutée, mélangée à l'état initial, et les versions qui nécessitent un remplissage nul sont renforcées en ajoutant également le len, pour éviter les collisions avec AppendedZeroes pour le remplissage. Les implémentations de libtomcrypt le prévoient déjà, mais d'autres pourraient ne pas le faire. Sans cela, de telles fonctions de hachage cryptographique ne conviennent pas aux tâches normales, car il est trivial de créer des collisions par remplissage ou par mauvaises graines.
La suite de tests officielle des fonctions de hachage du NIST n'effectue pas de tests statistiques aussi approfondis pour rechercher des plages faibles dans les bits. De plus, la crypto ne change pas l'état initial, ce que nous faisons ici pour notre graine aléatoire de 32 bits. Crypto se soucie principalement des clés irréversibles -> fonctions de hachage sans modifier l'état fixe initial et les attaques de timing/sidechannel.
Le « Programme de validation des algorithmes cryptographiques » (CAVP) du NIST implique le test des implémentations d'algorithmes cryptographiques approuvés par la FIPS et recommandés par le NIST. Lors du concours NIST SHA-3, la méthodologie de test a été empruntée au « CAVP », car les KAT et MCT de la suite de tests de compétition SHA-3 étaient basés sur les tests CAVP pour SHA-2. En plus de cela, le « test de message extrêmement long », non présent dans le CAVP pour SHA-2, exigeait que les émetteurs génèrent la valeur de hachage correspondant à un message d'une longueur de 1 Gio. « NIST - Cryptographic Algorithm Validation Program (CAVP) », juin 2017. Disponible : http://csrc.nist.gov/groups/STM/cavp (Aucun code source de test fourni, juste des descriptions de haut niveau)
Deux autres suites de tests tierces indépendantes ont découvert un grand nombre de bugs et de faiblesses dans les candidats SHA3. « Recherche de bogues dans les implémentations de fonctions de hachage cryptographique », Nicky Mouha, Mohammad S Raunak, D. Richard Kuhn et Raghu Kacker, 2017. https://eprint.iacr.org/2017/891.pdf
Peut-être que des chercheurs indépendants devraient se réunir pour réaliser un meilleur cycle public SHA-4, basé sur des méthodes de test meilleures et plus nombreuses, un code source ouvert pour les tests et l'utilisation de pratiques standard de l'industrie, telles que valgrind, address-sanitizer et ubsan, pour détecter les bogues évidents. .
Mauvaises graines
Les fonctions de hachage sont généralement initialisées avec une graine aléatoire. Mais certaines valeurs de départ peuvent conduire à de mauvaises fonctions de hachage, quelle que soit la clé. Dans le cas normal avec des graines aléatoires, la probabilité de telles mauvaises graines est très faible, comme 2 ^ 32 ou 2 ^ 64. Une application pratique doit savoir si de mauvaises graines existent et en choisir une autre. Voir par exemple mirhash_seed_init() et mirhash_bad_seeds() dans Hashes.h . Notez qu'une mauvaise graine n'est pas vraiment un problème lorsque vous ignorez cette graine lors de l'initialisation. Cela peut toujours être une fonction de hachage BON ou recommandée. Mais une mauvaise graine de 0 conduisant à des collisions est considérée comme un bug, une mauvaise fonction de hachage.
Nous testons les secrets internes, s'ils seront multipliés par 0. Ceci est également appelé « multiplication aveugle ». main.cpp répertorie quelques secrets pour chaque fonction de hachage que nous testons. La fonction <hash>_bad_seeds() répertorie les mauvaises graines confirmées.
Des précautions particulières doivent être prises pour crc, la plupart des variantes de FNV1, Fletcher, Jenkins. Et avec GOOD hash la plupart des variantes de MUM, comme mirhash, MUM, wyhash.
Indépendamment de cela, lorsque l’attaquant connaît la graine, cela entraînera des attaques DDOS. Même avec des hachages cryptographiques dans les tables de hachage power2.
Problèmes typiques de comportement non défini ( UB ) :
Mal aligné
De nombreux hachages par mot (contrairement au traitement sécurisé par octet) ne vérifient pas le tampon d'entrée pour l'alignement correct des mots, ce qui échouera avec ubsan ou Sparc. le mot étant int32_t ou int64_t ou même plus. Sur certains anciens matériels RISC, il s'agira d'une erreur de BUS, vous pouvez même laisser Intel HW générer une telle erreur de bus en définissant un indicateur de processeur. Mais en général, utiliser des accès mal alignés est acceptable.
Ce sont : mx3, Spooky, mirhash ( mais pas strict ), MUM, fasthash, Murmur3*, Murmur2*, metrohash* (tous sauf cmetro*), Crap8, Beamsplitter, lookup3, fletcher4, fletcher2, toutes les variantes sanmayce FNV1a_ (FNV1a_YT, FNV1A_Pippip_Yurii, FNV1A_Totenschiff, ...), fibonacci.
L'atténuation habituelle consiste à vérifier l'alignement du tampon soit dans l'appelant, soit à fournir une boucle de prétraitement pour le préfixe mal aligné, soit à copier l'intégralité du tampon dans une nouvelle zone alignée. Mettez ce code supplémentaire dans #ifdef HAVE_ALIGNED_ACCESS_REQUIRED .
oob - Hors limites
Certaines fonctions de hachage supposent un tampon d'entrée rempli, accessible au-delà de sa longueur jusqu'à la taille du mot. Cela permet un traitement de boucle plus rapide, car aucune deuxième boucle ou table de commutation pour le reste n'est nécessaire, mais cela nécessite un environnement d'appel coopératif et est en tant que tel considéré comme de la triche.
Débordement d'entier signé
Une simple erreur de type, ce hachage doit utiliser des types entiers non signés en interne, pour éviter un comportement indéfini et incohérent. c'est-à-dire SuperFastHash : débordement d'entier signé : -2147483641 + -113 ne peut pas être représenté en type 'int'
décalage d'exposant
Avec : FNV1A_Pippip_Yurii, FNV1A_Totenschiff, pair_multiply_shift, sumhash32, l'exposant de décalage 64 est trop grand pour le type 64 bits 'long unsigned int'
