smhasher
1.0.0
| función hash | MiB/seg | ciclo/hash | ciclo/mapa | tamaño | Problemas de calidad |
|---|---|---|---|---|---|
| no hacer nada32 | 11149460.06 | 4.00 | - | 13 | mala semilla 0, prueba NOP |
| no hacer nada64 | 11787676.42 | 4.00 | - | 13 | mala semilla 0, prueba NOP |
| no hacer nada128 | 11745060.76 | 4.06 | - | 13 | mala semilla 0, prueba NOP |
| NOP_OAAT_read64 | 11372846.37 | 14.00 | - | 47 | prueba NOP |
| malhash | 769,94 | 73,97 | - | 47 | mala semilla 0, prueba FALLA |
| sumahash | 10699.57 | 29,53 | - | 363 | mala semilla 0, prueba FALLA |
| sumhash32 | 42877.79 | 23.12 | - | 863 | UB, prueba FALLA |
| multiplicar_cambio | 8026.77 | 26.05 | 226,80 (8) | 345 | semillas malas y 0xfffffff0, falla la mayoría de las pruebas |
| par_multiplicar_cambio | 3716.95 | 40.22 | 186,34 (3) | 609 | falla la mayoría de las pruebas |
| -------------------------- | |||||
| crc32 | 383.12 | 134.21 | 257,50 (11) | 422 | inseguro, colisiones 8590x, distribución, 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 | Cordura, baja cíclica32, distribución 36,6% |
| sha1_64 | 353.03 | 1385.80 | 1759.94 (5) | 5126 | Cordura, baja cíclica32, distribución 36,6% |
| sha1-160 | 364,95 | 1470.55 | 1794.16 (13) | 5126 | Peine/Cíclico bajo32 |
| sha2-224 | 147.13 | 1354.81 | 1589,92 (12) | Peine bajo32 | |
| sha2-224_64 | 147,60 | 1360.10 | 1620.93 (13) | Mínimo cíclico32 | |
| 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 | inseguro, cordura, permutación, ceros, específico de la máquina |
| sha1ni_32 | 1576.17 | 174.04 | 405.56 (6) | 989 | específico de la máquina |
| sha2ni-256 | 1527.38 | 184,35 | 404.40 (4) | 4241 | inseguro, cordura, permutación, ceros, específico de la máquina |
| sha2ni-256_64 | 1501.85 | 186.20 | 407,96 (5) | 4241 | Ceros, específicos de la máquina |
| blake3_c | 1288.84 | 357,69 | 582,89 (6) | sin portabilidad de 32 bits | |
| rmd128 | 290.90 | 710.49 | 965,55 (6) | ||
| rmd160 | 202.16 | 1045.79 | 1287,74 (16) | Hi32 cíclico | |
| 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) | PerlinRuido | |
| sha3-256_64 | 100.57 | 3909.00 | 4174,63 (16) | PerlinRuido | |
| hasshe2 | 2773.89 | 64,35 | 282,30 (3) | 445 | Permutación, dos bytes, ceros, semilla |
| poli_1_mersenne | 1369.21 | 61,59 | 248,86 (4) | 479 | falla la mayoría de las pruebas |
| poli_2_mersenne | 1364.03 | 70.30 | 261,00 (6) | 479 | |
| poli_3_mersenne | 1342.82 | 80.22 | 268,79 (2) | 479 | |
| poli_4_mersenne | 1343.19 | 89.13 | 277,52 (3) | 479 | |
| tabulación32 | 5781.16 | 40.00 | 241,79 (10) | 848 | colisiones |
| tabulación | 7875.01 | 39,95 | 249,49 (3) | 554 | |
| crc32_hw | 6244.38 | 41.23 | 226,80 (2) | 653 | inseguro, 100% parcial, colisiones, distribución, BIC, específico de la máquina (SSE4.2/NEON) |
| crc32_hw1 | 7569.29 | 49.07 | 233,75 (3) | 671 | inseguro, 100% parcial, colisiones, distribución, BIC, específico de la máquina (x86 SSE4.2) |
| crc64_hw | 6143.62 | 40,48 | 223,13 (2) | 652 | inseguro, 100% parcial, colisiones, distribución, BIC, específico de la máquina (SSE4.2/NEON) |
| crc32_pclmul | - | - | - | inseguro, 100 % de polarización, colisiones, distribución, BIC, específico de la máquina (x86 SSE4.2+PCLMUL) | |
| o1hash | 11629440.57 | 18.15 | 199,35 (2) | 101 | inseguro, sin semilla, ceros, no pasa todas las pruebas |
| fibonacci | 16878.32 | 22,94 | 803.18 (15) | 1692 | UB, ceros, no pasa todas las pruebas. |
| FNV1a | 760.52 | 73,83 | 254,29 (5) | 204 | mala semilla, ceros, no pasa todas las pruebas |
| FNV1A_Totenschiff | 6274.78 | 26.23 | 251,13 (2) | 270 | UB, ceros, no pasa todas las pruebas. |
| FNV1A_Pippip_Yurii | 6172.14 | 27,55 | 244,80 (2) | 147 | UB, cordura, no pasa todas las pruebas |
| FNV1a_YT | 13486.49 | 30,50 | 237,43 (4) | 321 | mala semilla, UB, no pasa todas las pruebas |
| FNV2 | 6171.60 | 32.20 | 208,59 (4) | 278 | falla todas las pruebas |
| FNV64 | 774,37 | 72,43 | 201.15 (2) | 79 | falla todas las pruebas |
| FNV128 | 390.14 | 136,42 | 289,00 (3) | 171 | falla todas las pruebas |
| k-hash32 | 2230.42 | 53.05 | 264,64 (3) | 808 | inseguro, ceros, UB, malas semillas, no pasa todas las pruebas |
| k-hash64 | 2451.88 | 48,66 | 249,44 (2) | 609 | inseguro, ceros, UB, malas semillas, no pasa todas las pruebas |
| fletcher2 | 15552.61 | 20.61 | 335,31 (3) | 248 | mala semilla 0, UB, no pasa todas las pruebas |
| fletcher4 | 15556.93 | 20.60 | 358,60 (3) | 371 | mala semilla 0, UB, no pasa todas las pruebas |
| Bernstein | 1045,97 | 58,31 | 225,78 (3) | 41 | mala semilla 0, falla todas las pruebas |
| sdbm | 784,83 | 68,57 | 222,68 (5) | 41 | mala semilla 0, falla todas las pruebas |
| x17 | 748,75 | 74.13 | 236,00 (10) | 79 | 99,98% de sesgo, no pasa todas las pruebas |
| libertad | 628,66 | 84,95 | 225,07 (4) | 37 | inseguro, 100% parcial, no pasa todas las pruebas, mala semilla |
| gcc | 611.69 | 86,47 | 231,51 (5) | 39 | inseguro, 100% parcial, no pasa todas las pruebas, mala semilla |
| JenkinsOOAT | 627,64 | 107.04 | 252,79 (3) | 153 | mala semilla 0, 53,5% de sesgo, no pasa todas las pruebas |
| JenkinsOOAT_perl | 608.10 | 94,17 | 254,09 (4) | 65 | mala semilla 0, 1,5-11,5% de sesgo, 7,2x colisiones, BIC, LongNeighbors |
| MicroOAAT | 701.35 | 76,68 | 251.01 (3) | 68 | 100% sesgo, distribución, BIC |
| pearsonhash64 | 434.17 | 124.14 | 230,79 (4) | Avalancha, Semilla, SSSE3 solamente. MSVC roto | |
| pearsonhash128 | 434.23 | 121,34 | 221,03 (7) | Avalancha, Semilla, SSSE3 solamente. MSVC roto | |
| pearsonhash256 | 444.08 | 119.11 | 229,75 (4) | Avalancha, Semilla, SSSE3 solamente. MSVC roto | |
| VHASH_32 | 13053.40 | 65,84 | 289,86 (3) | 1231 | cordura, Semilla, MomentChi2 |
| VHASH_64 | 13465.50 | 63,88 | 286,38 (5) | 1231 | cordura, semilla, escasa |
| farsh32 | 27038.23 | 66,88 | 278,89 (5) | 944 | inseguro: AppendedZeroes, colisiones+sesgo, MomentChi2, LongNeighbors |
| farsh64 | 13829.32 | 112,46 | 332,59 (3) | 944 | inseguro: AppendedZeroes, colisiones+sesgo, MomentChi2, LongNeighbors |
| farsh128 | 6878.88 | 233.35 | 384,85 (3) | 944 | inseguro: AppendedZeroes, colisiones+bias, permut,combin,2bytes,zeroes,PerlinNoise |
| farsh256 | 3467.37 | 440.40 | 593,57 (5) | 944 | inseguro: AppendedZeroes, colisiones+bias, permut,combin,2bytes,zeroes,PerlinNoise |
| jodyhash32 | 1794.34 | 41.12 | 235,12 (4) | 102 | sesgo, colisiones, distribución, BIC LongNeighbors |
| jodyhash64 | 4813.10 | 40,72 | 239,22 (6) | 118 | sesgo, colisiones, distr, BIC, LongNeighbors |
| búsqueda3 | 2475.35 | 39,65 | 240,10 (3) | 341 | UB, 28% de sesgo, colisiones, 30% de distribución, BIC |
| súper rápido | 2058.22 | 49,56 | 254,12 (3) | 210 | UB, mala semilla 0, 91% de sesgo, 5273.01x colisiones, 37% de distribución, BIC |
| SoploOAAT | 506.66 | 103.33 | 236,89 (3) | 47 | mala semilla 0, colisiones, 99,998% distr., BIC, LongNeighbors |
| Mierda8 | 3041.14 | 37,25 | 247,87 (4) | 342 | UB, 2,42% sesgo, colisiones, 2% distribución |
| Murmullo1 | 2027.85 | 48,51 | 253,34 (3) | 358 | UB, 1 mala semilla, 511x colisiones, Diff, BIC |
| Murmullo2 | 3089.18 | 41.22 | 238,42 (4) | 358 | UB, 1 mala semilla, 1,7% de sesgo, 81x coll, 1,7% de distribución, BIC |
| Murmullo2A | 3087.98 | 45,90 | 238,54 (4) | 407 | UB, 1 mala semilla, 12,7% de sesgo, LongNeighbors |
| Murmullo2B | 5919.38 | 38.18 | 215,96 (3) | 433 | UB, 1,8% sesgo, colisiones, 3,4% distribución, BIC |
| Murmullo2C | 3810.98 | 49.09 | 218,51 (3) | 444 | UB, 2^32 malas semillas, 91% de sesgo, colisiones, distribución, BIC, LongNeighbors |
| Murmullo3A | 2982.67 | 49.08 | 245,78 (4) | 351 | UB, 1 mala semilla, Momento Chi2 69 |
| PMurHash32 | 3005.85 | 48,88 | 242,38 (3) | 1862 | 1 mala semilla, Momento Chi2 69 |
| Murmullo3C | 4833.18 | 56,87 | 250,47 (6) | 859 | UB, LongNeighbors, Texto, DiffDist |
| mirhash32low | 6145.39 | 36,95 | 235,09 (4) | 1112 | UB, 4 malas semillas, cíclico, vecinos largos, específico de la máquina (32/64 difiere) |
| PMPML_32 | 6639.68 | 45.33 | 257,45 (3) | 1084 | Avalancha >512, sin sembrar: Seed, BIC, MomentChi2, PerlinNoise |
| PMPML_64 | 9833.77 | 50.00 | 251,64 (6) | 1305 | sin semillas: Semilla, MomentChi2, BIC |
| xxHash32 | 5865.17 | 49.20 | 242,74 (3) | 738 | LongNeighbors, colisiones con diferencia de 4 bits, MomentChi2 220 |
| metrohash64 | 14741.56 | 39,44 | 215,76 (2) | 624 | UB, LongNeighbors, BIC |
| metrohash64_1 | 14298.77 | 40.31 | 223,25 (4) | 624 | UB, LongNeighbors, BIC, MomentChi2 |
| metrohash64crc_1 | 6929.69 | 44,65 | 223,68 (3) | 632 | UB, cíclico de 8/8 bytes, DiffDist, BIC, MomentChi2, específico de la máquina (SSE4.2/NEON) |
| metrohash64crc_2 | 8150.65 | 43,72 | 219,45 (5) | 632 | UB, cíclico de 8/8 bytes, DiffDist, BIC, específico de la máquina (SSE4.2/NEON) |
| cmmetrohash64_1o | 14921.73 | 38,95 | 213,25 (2) | 3506 | UB, LongNeighbors, BIC, MomentChi2 |
| cmmetrohash64_1 | 14151.73 | 40.90 | 211,89 (2) | 652 | UB, LongNeighbors, BIC, MomentChi2 |
| ciudad64nosemilla | 14209.19 | 31,80 | 225,90 (5) | 1038 | Avalancha, Sparse, TwoBytes, MomentChi2, Semilla |
| ciudad64 | 13887.84 | 46,32 | 239,77 (3) | 1120 | Escaso, dos bytes |
| t1ha1_64le | 13442.64 | 31.41 | 219,58 (3) | 517 | Avalancha |
| t1ha1_64be | 11586.02 | 32,74 | 232,55 (3) | 555 | Avalancha |
| t1ha0_32le | 7401.21 | 48.27 | 238,99 (3) | 509 | Vecinos escasos y largos |
| t1ha0_32be | 6217.37 | 50,66 | 244,51 (3) | 533 | Vecinos escasos y largos |
| t1ha2_stream | 14011.63 | 80,72 | 275,17 (3) | 1665 | Escasa, permutación, vecinos largos |
| t1ha2_stream128 | 13136.06 | 97,80 | 306.11 (7) | 1665 | Escasa, permutación, vecinos largos |
| aesnihash | 5579.32 | 56,83 | 258,71 (5) | 1209 | falla muchas pruebas, específico de la máquina (x64 AES-NI) |
| Faljash | 50631.69 | 123.02 | 322,14 (7) | 264 | Vecinos dispersos, largos, específicos de la máquina (x64 AES-NI) |
| MiauHash | 29969.40 | 64,96 | 274,29 (4) | 1764 | Escaso, invertible, específico de la máquina (x64 AES-NI) |
| MiauHash64low | 29485.59 | 65,98 | 278,05 (3) | 1764 | Escaso, invertible, específico de la máquina (x64 AES-NI) |
| MiauHash32low | 26944.58 | 65,95 | 292,79 (9) | 1764 | Escaso, invertible, específico de la máquina (x64 AES-NI) |
| -------------------------------------- | |||||
| tifuhash_64 | 35.60 | 1679.52 | 1212,75 (15) | 276 | Mínimo cíclico32 |
| floppsyhash | 35,72 | 1868.92 | 1411.07 (7) | 623 | |
| divisor de haz | 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 | |
| discoNONG | 3698.45 | 399,67 | 597,78 (9) | malas semillas | |
| chasquido | 1143.05 | 113.70 | 294,43 (4) | 1609 | PerlinRuido |
| SipHash | 943.53 | 147,15 | 338,74 (4) | 1071 | |
| medio sorbo | 1141.57 | 79,65 | 263,96 (3) | 700 | ceros |
| BuenoOAAT | 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 | 0,9% de sesgo |
| TSip | 4233.17 | 53.31 | 249,19 (3) | 519 | !msvc |
| hacha de mar | 8261.80 | 58,94 | 256,08 (4) | 871 | PerlinRuido, !msvc |
| sehash32low | 8266.17 | 58,90 | 290,21 (16) | 871 | PerlinRuido 32, !msvc |
| choque | 18703.04 | 70.19 | 282,12 (6) | 1809 | PerlinNoise, específico de la máquina (x64 SSE4.2) |
| CarreteraHash64 | 6242.58 | 99,55 | 248,41 (3) | 2546 | |
| Murmullo3F | 7623.44 | 52,69 | 221,87 (3) | 699 | UB |
| MAMÁ | 9563.99 | 34,99 | 228,55 (5) | 1912 | UB, demasiadas semillas malas, específico de la máquina (32/64 difiere) |
| MAMÁbaja | 9261.89 | 36.17 | 247,66 (4) | 1912 | UB, 5 malas semillas |
| xmsx32 | 2039.10 | 46,39 | 249,30 (7) | 192 | 2 malas semillas |
| mirhash | 6139.07 | 37.02 | 209,47 (3) | 1112 | UB, 2^36 semillas malas, LongNeighbors, específico de la máquina (32/64 difiere) |
| mirhashstrict | 3549.01 | 49,99 | 224,91 (2) | 1112 | |
| mirhashstrict32low | 3441.35 | 50,60 | 247,19 (3) | 1112 | 1 mala semilla, MomentChi2 9 |
| fasthash32 | 6128.28 | 40.30 | 241,64 (4) | 566 | UB |
| fasthash64 | 5818.92 | 38,70 | 220,74 (2) | 509 | UB |
| aesni | 31232.34 | 29.21 | 230,14 (4) | 519 | específico de la máquina (x64 AES-NI) |
| aesni-bajo | 31221.14 | 29,64 | 226,18 (3) | 519 | específico de la máquina (x64 AES-NI) |
| mx3 | 9034.90 | 48,71 | 227,89 (2) | 734 | UB |
| pengyhash | 13428.80 | 74,24 | 275,42 (5) | 421 | |
| ciudad32 | 5551.28 | 54,40 | 261,64 (2) | 1319 | |
| ciudad64low | 13904.10 | 46.24 | 260,08 (3) | 1120 | |
| ciudad128 | 14031.96 | 89.09 | 290,05 (10) | 1841 | |
| CiudadCrc128 | 7916.44 | 55,50 | 240,79 (2) | 295 | |
| GranjaHash32 | 21755.58 | 47,54 | 258,35 (3) | 11489 | específico de la máquina (x64 SSE4/AVX) |
| GranjaHash64 | 12845.53 | 47.11 | 251,58 (3) | 3758 | |
| GranjaHash128 | 13913.65 | 70,25 | 263,06 (3) | 163 | |
| granjahash32_c | 21601.86 | 47,38 | 273,00 (3) | 762 | específico de la máquina (x64 SSE4/AVX) |
| granjahash64_c | 12834.10 | 47.23 | 246,20 (2) | 3688 | |
| granjahash128_c | 13753.24 | 68,96 | 263,76 (3) | 1890 | |
| metrohash64_2 | 14316.37 | 40.23 | 218,28 (3) | 627 | UB, Vecinos Largos |
| cmmetrohash64_2 | 14294.26 | 40,76 | 221,40 (4) | 655 | Vecinos largos |
| metrohash128 | 15634.66 | 73,28 | 261,23 (4) | 773 | UB, Vecinos Largos |
| metrohash128_1 | 15806.97 | 72,30 | 260,90 (4) | 773 | UB, Vecinos Largos |
| metrohash128_2 | 15822.60 | 72,30 | 255,34 (3) | 773 | UB, Vecinos Largos |
| metrohash128crc_1 | 8009.23 | 78,72 | 281,55 (13) | 723 | UB, específico de la máquina (SSE4.2/NEON) |
| metrohash128crc_2 | 7878.22 | 79,90 | 275,22 (4) | 723 | UB, específico de la máquina (SSE4.2/NEON) |
| xxHash64 | 12108.87 | 49,78 | 228,83 (2) | 1999 | |
| espeluznante32 | 13108.95 | 56,27 | 255,36 (3) | 2221 | UB |
| espeluznante64 | 13529.36 | 58,76 | 236,31 (3) | 2221 | UB |
| espeluznante128 | 11781.35 | 58,91 | 242,91 (3) | 2221 | UB |
| EspeluznanteV2_32 | 13529.16 | 55,55 | 248,37 (4) | 2069 | |
| espeluznantev2_64 | 12678.82 | 56,71 | 243,21 (4) | 2069 | |
| EspeluznanteV2_128 | 13512.82 | 58,33 | 244,56 (5) | 2069 | |
| ahash64 | 9862.62 | 27.32 | 181,68 (1) | 412 | óxido |
| xxh3 | 21033.55 | 29,48 | 226,77 (4) | 744 | Bit DiffDist 7 w. 36 bits, BIC |
| xxh3low | 17093.19 | 30,57 | 242,07 (7) | 756 | |
| xxh128 | 18802.16 | 32.37 | 234,30 (4) | 1012 | |
| xxh128bajo | 18833.05 | 32.30 | 234,68 (3) | 1012 | |
| t1ha2_atonce | 13854.44 | 37,92 | 233,54 (2) | 541 | Ceros bajos3 |
| t1ha2_atonce128 | 14148.42 | 55,70 | 253,74 (6) | 613 | Vecinos largos |
| t1ha0_aes_noavx | 27231.59 | 37,70 | 236,10 (3) | 925 | LongNeighbors, específico de la máquina (x86 AES-NI) |
| t1ha0_aes_avx1 | 22714.85 | 48.12 | 226,52 (16) | 843 | LongNeighbors, específico de la máquina (x64 AVX.txt) |
| t1ha0_aes_avx2 | 56919.46 | 36,70 | 233.14 (2) | 792 | LongNeighbors, específico de la máquina (x64 AVX2) |
| wyhash32 | 2532.89 | 48,40 | 484,57 (1) | 426 | 4 semillas malas y rotas, 32 bits |
| wyhash32low | 22393.77 | 29.04 | 243,40 (3) | 474 | 5 malas semillas |
| wyhash | 22540.23 | 28,87 | 236,16 (8) | 474 | |
| rapidhash | 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_hi | 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 | |
| medio tiempo_hash64 | 4735.63 | 99,90 | 315,34 (3) | 2911 | |
| medio tiempo_hash128 | 17534.53 | 97,97 | 311.10 (4) | 2462 | |
| medio tiempo_hash256 | 18003.39 | 99,46 | 315.09 (3) | 2622 | |
| medio tiempo_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 | |
| polimur | 9676.33 | 42,70 | 246,53 (3) | 1128 |
Las variantes de la tabla ordenable:
Predeterminado AMD Ryzen 5 3350G 3.6GHz
Intel i5-2300 2,8GHz
Intel i5-2300 2,8 GHz de 32 bits
AMD Ryzen 3 3200U 3,5GHz
Mac Air i7-4650
Corteza-A53 2GHz (Sony XPeria L4)
Agregué algunos hashes asistidos por SSE y variantes rápidas de inteligencia/arm CRC32-C, AES y SHA HW. Consulte también el antiguo https://github.com/aappleby/smhasher/wiki, la bifurcación mejorada, pero sin mantenimiento, https://github.com/demerphq/smhasher y la nueva versión mejorada SMHasher3 https://gitlab.com/ fwojcik/smhasher3.
Entonces, las funciones hash más rápidas en x86_64 sin problemas de calidad son:
rapidhash (un wyhash mejorado)
xxh3low
wyhash
umash (¡incluso universal!)
ahash64
t1ha2_atonce
komihash
FarmHash ( no es portátil, también es específico de la máquina: 64 frente a 32 bits, gcc antiguo, ... )
medio tiempo_hash128
espeluznante32
pengyhash
nmhash32
mx3
MUM/mir ( resultados diferentes en arcos de 32/64 bits, muchas semillas malas para filtrar )
fasthash32
Las funciones hash para tablas de símbolos o tablas hash suelen utilizar hashes de 32 bits, para bases de datos, sistemas de archivos y sumas de comprobación de archivos normalmente de 64 o 128 bits, para criptografía ahora comienzan con 256 bits.
El tamaño de clave medio típico en perl5 es 20, el más común 4. Similar a todos los demás lenguajes dinámicos. Consulte github.com/rurban/perl-hash-stats
Cuando se usa en una tabla hash, el caché de instrucciones generalmente superará a la CPU y el rendimiento medido aquí. En mis pruebas, el FNV1A más pequeño supera al crc32_hw1 más rápido con tablas hash de Perl 5. Incluso si esas peores funciones hash provocarán más colisiones, la ventaja general de velocidad y la capacidad en línea superan la calidad ligeramente peor. Consulte, por ejemplo, Un análisis en siete dimensiones de los métodos de hash y sus implicaciones en el procesamiento de consultas para obtener una descripción general concisa de las mejores estrategias de tablas hash, lo que confirma que el hash Mult más simple (bernstein, FNV*, x17, sdbm) siempre supera a las "mejores" funciones hash. (Tabulación, Murmullo, Granja, ...) cuando se usa en una tabla hash.
Las funciones hash rápidas probadas aquí son recomendables como rápidas para resúmenes de archivos y tal vez bases de datos más grandes, pero no para tablas hash de 32 bits. Los "problemas de calidad" conducen a una distribución menos uniforme, es decir, más colisiones y peor rendimiento, pero rara vez se relacionan con ataques de seguridad reales; solo la segunda prueba de cordura de AppendZeroes contra � es relevante para la seguridad.
MiB/seg: el promedio de la prueba de velocidad de clave masiva para alineaciones 0-7 con claves de 262144 bytes. Cuanto más alto, mejor.
cycl./hash: el promedio de la prueba de velocidad de clave pequeña para claves de 1 a 31 bytes. Cuanto más pequeño, mejor.
cycl./map: El resultado de la prueba Hashmap para /usr/dict/words con consultas rápidas de obtención de hashmap de C++, con la desviación estándar entre paréntesis. Esto pone a prueba la inlinabilidad de la función hash en la práctica (ver tamaño). Cuanto más pequeño, mejor.
tamaño: el tamaño del objeto en bytes en AMD64. Esto afecta la inlinabilidad, por ejemplo, en tablas hash. Cuanto más pequeño, mejor.
Problemas de calidad: Ver los fallos en el documento vinculado. Cuanto menos mejor.
https://github.com/martinus/better-faster-stronger-mixer Mezcladores. Y en su blog los mejores benchmarks de mapas hash de C++.
http://nohatcoder.dk/2019-05-19-1.html ofrece una clasificación de nivel de hash nueva y útil del 1 al 5.
http://www.strchr.com/hash_functions enumera otros puntos de referencia y la calidad de las funciones hash más simples y rápidas.
http://bench.cr.yp.to/primitives-hash.html enumera los puntos de referencia de todos los hashes seguros probados actualmente.
http://valerieaurora.org/hash.html Duración de las funciones hash criptográficas
Los ataques de tabla hash descritos en SipHash contra City, Murmur o Perl JenkinsOAAT o en Hash Function Lounge no se incluyen aquí. Enumeramos algunos ataques conocidos en GH #186.
Evitar un ataque de este tipo no puede ser un problema de la función hash, sino sólo del esquema de resolución de colisiones de la tabla hash. Puede atacar todas y cada una de las funciones hash, incluso las mejores y más seguras si detecta la semilla, por ejemplo, a partir de (malas) características del lenguaje, ataques de canal lateral, tiempos de colisión e independientemente del orden de clasificación, por lo que necesita proteger su colisión. esquema de manejo del peor de los casos O(n), es decir, encadenamiento separado con listas enlazadas. El encadenamiento de listas enlazadas permite factores de carga elevados, pero no es compatible con la caché. El único esquema de lista enlazada recomendable es insertar la clave o el hash en la matriz. Hoy en día, todo el mundo utiliza el direccionamiento abierto rápido, incluso si el factor de carga debe ser ~50%, a menos que utilice Cuckoo Hashing.
Es decir, el uso de SipHash para su tabla hash en Python 3.4, Ruby, Rust, Systemd, OpenDNS, Haskell y OpenBSD es puro teatro de seguridad. SipHash no es lo suficientemente seguro por motivos de seguridad ni lo suficientemente rápido para uso general. La generación de fuerza bruta de ~32k colisiones necesita de 2 a 4 millones para todos estos hashes. Siphash es el más lento y necesita un máximo de 4 m, otros normalmente un máximo de 2 m y 30 s, con <10 s para ataques prácticos de colisión de 16 k con todas las funciones hash. Usar Murmur suele ser más lento que un simple Mult, incluso en el peor de los casos. La seguridad demostrable es solo un hash uniforme, es decir, 2-5 Mult o Tabulación independientes, o el uso de un esquema de colisión logarítmica garantizada (un árbol) o un esquema de colisión lineal, como swisstable/folly-F14, Robin Hood o Cuckoo hash con conteo de colisiones.
Una nota más con respecto a la seguridad: hoy en día, incluso SHA1 se puede resolver en un solucionador, como Z3 (o otros más rápidos) para ataques prácticos de colisión de tablas hash (es decir, 14-20 bits). Todas las funciones hash probadas aquí con menos de 160 bits no pueden considerarse "seguras" en absoluto.
El ataque de vulnerabilidad '�' con claves binarias se prueba en la segunda prueba de Sanity Zero.
Nuestros hashes criptográficos se refuerzan con una semilla size_t agregada, mezclada en el estado inicial, y las versiones que requieren relleno con ceros se refuerzan agregando también len, para evitar colisiones con AppendedZeroes para el relleno. Las implementaciones de libtomcrypt ya lo permiten, pero es posible que otras no. Sin ellas, dichas funciones hash criptográficas no son adecuadas para tareas normales, ya que es trivial crear colisiones mediante relleno o malas semillas.
El conjunto de pruebas oficial de la función hash del NIST no realiza pruebas estadísticas tan exhaustivas para buscar rangos débiles en los bits. Además, las criptomonedas no cambian el estado inicial, lo que hacemos aquí para nuestra semilla aleatoria de 32 bits. Crypto se preocupa principalmente por la clave irreversible -> funciones hash sin cambiar el estado fijo inicial y los tiempos/ataques de canal lateral.
El "Programa de validación de algoritmos criptográficos" (CAVP) del NIST implica la prueba de las implementaciones de algoritmos criptográficos aprobados por FIPS y recomendados por NIST. Durante la competencia NIST SHA-3, la metodología de prueba se tomó prestada del "CAVP", ya que los KAT y MCT del conjunto de pruebas de competencia SHA-3 se basaron en las pruebas CAVP para SHA-2. Además de esto, la "Prueba de mensajes extremadamente largos", no presente en el CAVP para SHA-2, requería que los remitentes generaran el valor hash correspondiente a un mensaje con una longitud de 1 GiB. “NIST - Programa de validación de algoritmos criptográficos (CAVP)”, junio de 2017. Disponible: http://csrc.nist.gov/groups/STM/cavp (No se proporciona código fuente de prueba, solo descripciones de alto nivel)
Otros dos conjuntos de pruebas independientes de terceros encontraron una gran cantidad de errores y debilidades en los candidatos SHA3. "Búsqueda de errores en implementaciones de funciones hash criptográficas", Nicky Mouha, Mohammad S Raunak, D. Richard Kuhn y Raghu Kacker, 2017. https://eprint.iacr.org/2017/891.pdf
Tal vez los investigadores independientes deberían unirse para realizar una mejor ronda pública de SHA-4, basada en mejores y más métodos de prueba, código fuente abierto para las pruebas y el uso de prácticas estándar de la industria, como valgrind, Address-Sanitizer y ubsan para detectar errores obvios. .
malas semillas
Las funciones hash normalmente se inicializan con una semilla aleatoria. Pero algunos valores iniciales pueden generar funciones hash incorrectas, independientemente de la clave. En el caso normal de semillas aleatorias, la probabilidad de semillas malas es muy baja, como 2^32 o 2^64. Una aplicación práctica necesita saber si existen semillas malas y elegir otra. Consulte, por ejemplo, mirhash_seed_init() y mirhash_bad_seeds() en Hashes.h . Tenga en cuenta que una semilla defectuosa no es realmente un problema si la omite durante la inicialización. Todavía puede ser una función hash BUENA o recomendada. Pero una mala semilla de 0 que provoca colisiones se considera un error, una función hash incorrecta.
Probamos los secretos internos, si se multiplicarán por 0. Esto también se llama "multiplicación ciega". main.cpp enumera algunos secretos para cada función hash que probamos. La función <hash>_bad_seeds() enumera las semillas defectuosas confirmadas.
Se debe tener especial cuidado con crc, la mayoría de las variantes de FNV1, fletcher, Jenkins. Y con BUENOS hashes la mayoría de las variantes de MUM, como mirhash, MUM, wyhash.
Independientemente de esto, cuando el atacante conoce la semilla dará lugar a ataques DDOS. Incluso con hashes criptográficos en tablas hash power2.
Problemas típicos de comportamiento indefinido ( UB ):
Desalineado
Muchos hashes de palabras (a diferencia del procesamiento seguro de bytes) no verifican el búfer de entrada para verificar la alineación adecuada de las palabras, lo que fallará con ubsan o Sparc. la palabra es int32_t o int64_t o incluso más. En algunos hardware RISC antiguos, esto será un error de BUS; incluso puede dejar que Intel HW genere dicho error de bus configurando algún indicador de CPU. Pero en general está bien utilizar accesos desalineados.
Estos son: mx3, Spooky, mirhash ( pero no estricto ), MUM, fasthash, Murmur3*, Murmur2*, metrohash* (todos menos cmetro*), Crap8, beamsplitter, lookup3, fletcher4, fletcher2, todas las variantes de sanmayce FNV1a_ (FNV1a_YT, FNV1A_Pippip_Yurii, FNV1A_Totenschiff, ...), fibonacci.
La mitigación habitual es verificar la alineación del búfer en la persona que llama, proporcionar un bucle de preprocesamiento para el prefijo desalineado o copiar todo el búfer en un área alineada nueva. Coloque ese código adicional dentro de #ifdef HAVE_ALIGNED_ACCESS_REQUIRED .
oob - Fuera de los límites
Algunas funciones hash asumen un búfer de entrada relleno al que se puede acceder más allá de su longitud hasta el tamaño de la palabra. Esto permite un procesamiento de bucle más rápido, ya que no se necesita un segundo bucle ni una tabla de conmutación para el resto, pero requiere un entorno de llamada cooperativo y, como tal, se considera trampa.
Desbordamiento de entero con signo
Un error de tipo simple, este hash necesita usar tipos enteros sin signo internamente, para evitar un comportamiento indefinido e inconsistente. es decir, SuperFastHash: desbordamiento de entero con signo: -2147483641 + -113 no se puede representar en el tipo 'int'
desbordamiento del exponente de desplazamiento
Con: FNV1A_Pippip_Yurii, FNV1A_Totenschiff, pair_multiply_shift, sumhash32 el exponente de desplazamiento 64 es demasiado grande para el tipo de 64 bits 'long unsigned int'
