แฮชที่เร็วที่สุดสำหรับการใช้ที่ไม่ใช่การเข้ารหัส?


154

ฉันกำลังเตรียมวลีที่จะใส่ลงในฐานข้อมูลพวกเขาอาจมีรูปแบบไม่ถูกต้องดังนั้นฉันต้องการเก็บแฮชสั้น ๆ ของพวกเขาแทน (ฉันจะเปรียบเทียบง่ายๆถ้ามีหรือไม่มีแฮชจึงเหมาะ)

ฉันคิดว่า MD5 นั้นค่อนข้างช้าสำหรับคำร้องขอมากกว่า 100,000+ คำขอดังนั้นฉันจึงอยากรู้ว่าอะไรจะเป็นวิธีที่ดีที่สุดในการแฮชวลีบางทีอาจจะเปิดตัวฟังก์ชันแฮชของตัวเองหรือการใช้hash('md4', '...'จะเร็วขึ้นในท้ายที่สุด

ฉันรู้ว่า MySQL มี MD5 () เพื่อที่จะเติมเต็มความเร็วเล็กน้อยในการสิ้นสุดการสืบค้น แต่อาจจะมีฟังก์ชั่นการแฮ็ชที่เร็วขึ้นใน MySQL ฉันไม่ทราบว่าจะทำงานกับ PHP ได้หรือไม่


6
มีอะไรหยุดคุณจากการเปรียบเทียบแฮช
NullUserException

3
NullUserException: คุณพูดถูกฉันจะลองใช้วลีความยาวแบบสุ่ม แค่ต้องการความเข้าใจในสิ่งที่จะเป็นบรรทัดฐานถ้ามีการจัดการสิ่งนี้
John

5
MD5 นั้นไม่ช้าจริงๆ ...
เหลืองอำพัน

25
คุณแน่ใจหรือไม่ว่าฟังก์ชันการแฮชเป็นคอขวดของแอปพลิเคชันทั้งหมด ฉันสงสัยอย่างนั้น
สามัญสำนึกของคุณ

4
นี่เป็นคำถามที่ดีมากที่จะถามและความคิดเห็นที่แสดงถึงมันไม่ใช่หรือไม่สำคัญและ / หรือควรชัดเจนและ / หรือใช้งานง่าย - น่าผิดหวังและน่าผิดหวัง (และยังไม่ได้คาดคิดเลย)
michael

คำตอบ:


56

CRC32 นั้นค่อนข้างเร็วและมีฟังก์ชั่นสำหรับมัน: http://www.php.net/manual/en/function.crc32.php

แต่คุณควรระวังว่า CRC32 จะมีการชนกันมากกว่า MD5 หรือแม้กระทั่งแฮช SHA-1 เพียงเพราะความยาวลดลง (32 บิตเทียบกับ 128 บิตตามลำดับ 160 บิต) แต่ถ้าคุณแค่ต้องการตรวจสอบว่าสตริงที่เก็บไว้เสียหายหรือไม่คุณสามารถใช้ CRC32 ได้


1
ว้าวประเภทข้อมูลที่จำเป็นเท่านั้นคือจำนวนเต็มที่ไม่ได้ลงชื่อซึ่งจะเร็วกว่าการแปลงแบบอื่น ๆ อย่างมาก
จอห์น

2
@John: หรือไม่ CRC32 นั้นช้ากว่า MD4 และไม่เร็วกว่า MD5 ในโปรเซสเซอร์ ARM มากนัก นอกจากนี้ CRC32 ยังใช้ประเภทจำนวนเต็ม 32 บิตที่ไม่ได้ลงนามซึ่งเป็นสิ่งที่ MD5 ต้องการ ...
Thomas Pornin

3
หากคุณได้รับประโยชน์ / ความหรูหราของซีพียู Intel รุ่นใหม่กว่ามีคำสั่งแอสเซมบลี crc32c ที่ ... อาจเร็วจริง ๆ (แม้ว่าจะไม่ใช่ค่า crc32 ดั้งเดิม) ดูเพิ่มเติม xxhash code.google.com/p/xxhash
rogerdpack

146
fcn     time  generated hash
crc32:  0.03163  798740135
md5:    0.0731   0dbab6d0c841278d33be207f14eeab8b
sha1:   0.07331  417a9e5c9ac7c52e32727cfd25da99eca9339a80
xor:    0.65218  119
xor2:   0.29301  134217728
add:    0.57841  1105

และรหัสที่ใช้ในการสร้างนี้คือ:

 $loops = 100000;
 $str = "ana are mere";

 echo "<pre>";

 $tss = microtime(true);
 for($i=0; $i<$loops; $i++){
  $x = crc32($str);
 }
 $tse = microtime(true);
 echo "\ncrc32: \t" . round($tse-$tss, 5) . " \t" . $x;

 $tss = microtime(true);
 for($i=0; $i<$loops; $i++){
  $x = md5($str);
 }
 $tse = microtime(true);
 echo "\nmd5: \t".round($tse-$tss, 5) . " \t" . $x;

 $tss = microtime(true);
 for($i=0; $i<$loops; $i++){
  $x = sha1($str);
 }
 $tse = microtime(true);
 echo "\nsha1: \t".round($tse-$tss, 5) . " \t" . $x;

 $tss = microtime(true);
 for($i=0; $i<$loops; $i++){
  $l = strlen($str);
  $x = 0x77;
  for($j=0;$j<$l;$j++){
   $x = $x xor ord($str[$j]);
  }
 }
 $tse = microtime(true);
 echo "\nxor: \t".round($tse-$tss, 5) . " \t" . $x;

 $tss = microtime(true);
 for($i=0; $i<$loops; $i++){
  $l = strlen($str);
  $x = 0x08;
  for($j=0;$j<$l;$j++){
   $x = ($x<<2) xor $str[$j];
  }
 }
 $tse = microtime(true);
 echo "\nxor2: \t".round($tse-$tss, 5) . " \t" . $x;

 $tss = microtime(true);
 for($i=0; $i<$loops; $i++){
  $l = strlen($str);
  $x = 0;
  for($j=0;$j<$l;$j++){
   $x = $x + ord($str[$j]);
  }
 }
 $tse = microtime(true);
 echo "\nadd: \t".round($tse-$tss, 5) . " \t" . $x;

3
อ่าขอบคุณสำหรับความเข้าใจที่แท้จริงเพียงเพิ่มการใช้ CRC32 ให้เร็วที่สุด
John

@ John - hash_algos()คุณสามารถดึงอัลกอริทึมคร่ำเครียดโดยใช้: กัญชารหัสการเปรียบเทียบดังต่อไปนี้คือในความคิดเห็นของ PHP ==> codepad.viper-7.com/5Wdhw6
ปีเตอร์ Ajtai

ขอบคุณสำหรับรหัสของคุณ ฉันได้ปรับปรุงมันเล็กน้อย ฉันไม่คิดว่าเราควรเปรียบเทียบฟังก์ชั่นเช่น md5 () ที่ประมวลผลสตริงทั้งหมดและลูปที่ทำไบต์ต่อไบต์เหมือนที่คุณทำกับ xor ใน PHP ลูปเหล่านี้ช้ามากและช้ากว่า md5 เอง เราควรเปรียบเทียบหนึ่ง hases กับที่อื่นทั้งหมดนำมาใช้เป็นฟังก์ชั่น
Maxim Masiutin

1
เพิ่งทราบอย่างรวดเร็ว - ฉันลองมันด้วยสตริงที่ยาวกว่า (~ 5000 ตัวอักษร) และ CRC32 นั้นช้ากว่า MD5 และ SHA1 บนเครื่องของฉัน (i7-6650U, 16GB) CRC32 - 1.7s, MD5 - 1.4s, SHA1 - 1.5s ทดสอบด้วยตัวเองเสมอ
Sam Tolton

4
@Quamis การทดสอบนั้นดี แต่อาจทำให้เข้าใจผิด - เนื่องจาก @samTolton สังเกตว่าผลลัพธ์ต่างกันและmd5เร็วกว่า การทดสอบที่ดีขึ้นคือการสุ่มเนื้อหาสตริงและความยาวด้วย วิธีนี้เราจะได้รับแนวคิดที่ดีขึ้นเกี่ยวกับประสิทธิภาพของโลกแห่งความเป็นจริง วิธีนี้จะหลีกเลี่ยงการแคช ลองดู: ประสิทธิภาพการตรวจสอบ php hashing
Shlomi Hassid

43

อันดับของรายการที่แต่ละวงแบ่งปันสิ่งเดียวกันเพื่อเข้ารหัสเป็นคนอื่น ๆ ทั้งหมด

<?php

set_time_limit(720);

$begin = startTime();
$scores = array();


foreach(hash_algos() as $algo) {
    $scores[$algo] = 0;
}

for($i=0;$i<10000;$i++) {
    $number = rand()*100000000000000;
    $string = randomString(500);

    foreach(hash_algos() as $algo) {
        $start = startTime();

        hash($algo, $number); //Number
        hash($algo, $string); //String

        $end = endTime($start);

        $scores[$algo] += $end;
    }   
}


asort($scores);

$i=1;
foreach($scores as $alg => $time) {
    print $i.' - '.$alg.' '.$time.'<br />';
    $i++;
}

echo "Entire page took ".endTime($begin).' seconds<br />';

echo "<br /><br /><h2>Hashes Compared</h2>";

foreach($scores as $alg => $time) {
    print $i.' - '.$alg.' '.hash($alg,$string).'<br />';
    $i++;
}

function startTime() {
   $mtime = microtime(); 
   $mtime = explode(" ",$mtime); 
   $mtime = $mtime[1] + $mtime[0]; 
   return $mtime;   
}

function endTime($starttime) {
   $mtime = microtime(); 
   $mtime = explode(" ",$mtime); 
   $mtime = $mtime[1] + $mtime[0]; 
   $endtime = $mtime; 
   return $totaltime = ($endtime - $starttime); 
}

function randomString($length) {
    $characters = '0123456789abcdefghijklmnopqrstuvwxyz';
    $string = '';    
    for ($p = 0; $p < $length; $p++) {
        $string .= $characters[mt_rand(0, strlen($characters) - 1)];
    }
    return $string;
}

?>

และก็เอาท์พุท

1 - crc32b 0.111036300659
2 - crc32 0.112048864365
3 - md4 0.120795726776
4 - md5 0.138875722885
5 - sha1 0.146368741989
6 - adler32 0.15501332283
7 - tiger192,3 0.177447080612
8 - tiger160,3 0.179498195648
9 - tiger128,3 0.184012889862
10 - ripemd128 0.184052705765
11 - ripemd256 0.185411214828
12 - salsa20 0.198500156403
13 - salsa10 0.204956293106
14 - haval160,3 0.206098556519
15 - haval256,3 0.206891775131
16 - haval224,3 0.206954240799
17 - ripemd160 0.207638263702
18 - tiger192,4 0.208125829697
19 - tiger160,4 0.208438634872
20 - tiger128,4 0.209359407425
21 - haval128,3 0.210256814957
22 - sha256 0.212738037109
23 - ripemd320 0.215386390686
24 - haval192,3 0.215610980988
25 - sha224 0.218329429626
26 - haval192,4 0.256464719772
27 - haval160,4 0.256565093994
28 - haval128,4 0.257113456726
29 - haval224,4 0.258928537369
30 - haval256,4 0.259262084961
31 - haval192,5 0.288433790207
32 - haval160,5 0.290239810944
33 - haval256,5 0.291721343994
34 - haval224,5 0.294484138489
35 - haval128,5 0.300224781036
36 - sha384 0.352449893951
37 - sha512 0.354603528976
38 - gost 0.392376661301
39 - whirlpool 0.629067659378
40 - snefru256 0.829529047012
41 - snefru 0.833986997604
42 - md2 1.80192279816
Entire page took 22.755341053 seconds


Hashes Compared

1 - crc32b 761331d7
2 - crc32 7e8c6d34
3 - md4 1bc8785de173e77ef28a24bd525beb68
4 - md5 9f9cfa3b5b339773b8d6dd77bbe931dd
5 - sha1 ca2bd798e47eab85655f0ce03fa46b2e6e20a31f
6 - adler32 f5f2aefc
7 - tiger192,3 d11b7615af06779259b29446948389c31d896dee25edfc50
8 - tiger160,3 d11b7615af06779259b29446948389c31d896dee
9 - tiger128,3 d11b7615af06779259b29446948389c3
10 - ripemd128 5f221a4574a072bc71518d150ae907c8
11 - ripemd256 bc89cd79f4e70b73fbb4faaf47a3caf263baa07e72dd435a0f62afe840f5c71c
12 - salsa20 91d9b963e172988a8fc2c5ff1a8d67073b2c5a09573cb03e901615dc1ea5162640f607e0d7134c981eedb761934cd8200fe90642a4608eacb82143e6e7b822c4
13 - salsa10 320b8cb8498d590ca2ec552008f1e55486116257a1e933d10d35c85a967f4a89c52158f755f775cd0b147ec64cde8934bae1e13bea81b8a4a55ac2c08efff4ce
14 - haval160,3 27ad6dd290161b883e614015b574b109233c7c0e
15 - haval256,3 03706dd2be7b1888bf9f3b151145b009859a720e3fe921a575e11be801c54c9a
16 - haval224,3 16706dd2c77b1888c29f3b151745b009879a720e4fe921a576e11be8
17 - ripemd160 f419c7c997a10aaf2d83a5fa03c58350d9f9d2e4
18 - tiger192,4 112f486d3a9000f822c050a204d284d52473f267b1247dbd
19 - tiger160,4 112f486d3a9000f822c050a204d284d52473f267
20 - tiger128,4 112f486d3a9000f822c050a204d284d5
21 - haval128,3 9d9155d430218e4dcdde1c62962ecca3
22 - sha256 6027f87b4dd4c732758aa52049257f9e9db7244f78c132d36d47f9033b5c3b09
23 - ripemd320 9ac00db553b51662826267daced37abfccca6433844f67d8f8cfd243cf78bbbf86839daf0961b61d
24 - haval192,3 7d706dd2d37c1888eaa53b154948b009e09c720effed21a5
25 - sha224 b6395266d8c7e40edde77969359e6a5d725f322e2ea4bd73d3d25768
26 - haval192,4 d87cd76e4c8006d401d7068dce5dec3d02dfa037d196ea14
27 - haval160,4 f2ddd76e156d0cd40eec0b8d09c8f23d0f47a437
28 - haval128,4 f066e6312b91e7ef69f26b2adbeba875
29 - haval224,4 1b7cd76ea97c06d439d6068d7d56ec3d73dba0373895ea14e465bc0e
30 - haval256,4 157cd76e8b7c06d432d6068d7556ec3d66dba0371c95ea14e165bc0ec31b9d37
31 - haval192,5 05f9ea219ae1b98ba33bac6b37ccfe2f248511046c80c2f0
32 - haval160,5 e054ec218637bc8b4bf1b26b2fb40230e0161904
33 - haval256,5 48f6ea210ee1b98be835ac6b7dc4fe2f39841104a37cc2f06ceb2bf58ab4fe78
34 - haval224,5 57f6ea2111e1b98bf735ac6b92c4fe2f43841104ab7cc2f076eb2bf5
35 - haval128,5 ccb8e0ac1fd12640ecd8976ab6402aa8
36 - sha384 bcf0eeaa1479bf6bef7ece0f5d7111c3aeee177aa7990926c633891464534cd8a6c69d905c36e882b3350ef40816ed02
37 - sha512 8def9a1e6e31423ef73c94251d7553f6fe3ed262c44e852bdb43e3e2a2b76254b4da5ef25aefb32aae260bb386cd133045adfa2024b067c2990b60d6f014e039
38 - gost ef6cb990b754b1d6a428f6bb5c113ee22cc9533558d203161441933d86e3b6f8
39 - whirlpool 54eb1d0667b6fdf97c01e005ac1febfacf8704da55c70f10f812b34cd9d45528b60d20f08765ced0ab3086d2bde312259aebf15d105318ae76995c4cf9a1e981
40 - snefru256 20849cbeda5ddec5043c09d36b2de4ba0ea9296b6c9efaa7c7257f30f351aea4
41 - snefru 20849cbeda5ddec5043c09d36b2de4ba0ea9296b6c9efaa7c7257f30f351aea4
42 - md2 d4864c8c95786480d1cf821f690753dc

4
ในตอนท้ายจะมีข้อผิดพลาดน้อยที่สุด strlen($characters)ควรเป็นstrlen($characters) - 1:)
MM

29

มีการเปรียบเทียบความเร็วในไซต์ xxhash คัดลอกวางที่นี่:

 Name            Speed       Q.Score   Author
 xxHash          5.4 GB/s     10
 MumurHash 3a    2.7 GB/s     10       Austin Appleby
 SpookyHash      2.0 GB/s     10       Bob Jenkins
 SBox            1.4 GB/s      9       Bret Mulvey
 Lookup3         1.2 GB/s      9       Bob Jenkins
 CityHash64      1.05 GB/s    10       Pike & Alakuijala
 FNV             0.55 GB/s     5       Fowler, Noll, Vo
 CRC32           0.43 GB/s     9
 MD5-32          0.33 GB/s    10       Ronald L. Rivest
 SHA1-32         0.28 GB/s    10

ดังนั้นดูเหมือนว่า xxHash จะเร็วที่สุดในขณะที่คนอื่น ๆ มักจะแฮ็กรุ่นเก่าเช่น CRC32, MD5 และ SHA

https://code.google.com/p/xxhash/

โปรดทราบว่านี่เป็นการสั่งซื้อการรวบรวม 32 บิต ในการรวบรวม 64 บิตลำดับประสิทธิภาพน่าจะแตกต่างกันมาก แฮชบางตัวมีพื้นฐานมาจากการคูณแบบ 64 บิตและการดึงข้อมูล


17
+-------------------+---------+------+--------------+
|       NAME        |  LOOPS  | TIME |     OP/S     |
+-------------------+---------+------+--------------+
| sha1ShortString   | 1638400 | 2.85 | 574,877.19   |
| md5ShortString    | 2777680 | 4.11 | 675,834.55   |
| crc32ShortString  | 3847980 | 3.61 | 1,065,922.44 |
| sha1MediumString  | 602620  | 4.75 | 126,867.37   |
| md5MediumString   | 884860  | 4.69 | 188,669.51   |
| crc32MediumString | 819200  | 4.85 | 168,907.22   |
| sha1LongString    | 181800  | 4.95 | 36,727.27    |
| md5LongString     | 281680  | 4.93 | 57,135.90    |
| crc32LongString   | 226220  | 4.95 | 45,701.01    |
+-------------------+---------+------+--------------+

ดูเหมือนว่า crc32 จะเร็วกว่าสำหรับข้อความขนาดเล็ก (ในกรณีนี้คือ 26 ตัวอักษร) ในขณะที่ md5 สำหรับข้อความที่ยาวขึ้น (ในกรณีนี้> 852 ตัวอักษร)


17

ปรับปรุง 2019: คำตอบนี้เป็นรุ่นล่าสุด ห้องสมุดที่สนับสนุนเสียงพึมพำส่วนใหญ่มีให้บริการในทุกภาษา

คำแนะนำปัจจุบันคือการใช้Murmur Hash Family (ดูเฉพาะตัวแปร murmur2หรือmurmur3 )

เสียงพึมพำของ Murmur ถูกออกแบบมาเพื่อการแฮ็กอย่างรวดเร็วโดยมีการชนน้อยที่สุด (เร็วกว่า CRC, MDx และ SHAx) มันเหมาะที่จะมองหารายการที่ซ้ำกันและเหมาะสำหรับดัชนี HashTable

อันที่จริงมันถูกใช้โดยฐานข้อมูลที่ทันสมัยหลายแห่ง (Redis, ElastisSearch, Cassandra) เพื่อคำนวณแฮชทุกประเภทเพื่อวัตถุประสงค์ที่หลากหลาย อัลกอริทึมเฉพาะนี้เป็นแหล่งที่มาของการปรับปรุงประสิทธิภาพมากมายในทศวรรษปัจจุบัน

นอกจากนี้ยังใช้ในการใช้งานของตัวกรองบลูม คุณควรทราบว่าหากคุณกำลังค้นหา "แฮ็กเร็ว" คุณอาจประสบปัญหาทั่วไปที่แก้ไขโดยตัวกรองของ Bloom ;-)

หมายเหตุ : เสียงพึมพำเป็นแฮชวัตถุประสงค์ทั่วไปหมายถึงไม่ใช่การเข้ารหัสลับ ไม่ป้องกันการค้นหา "ข้อความ" ต้นฉบับที่สร้างแฮช ไม่เหมาะสมที่จะแฮรหัสผ่าน

รายละเอียดเพิ่มเติมบางอย่าง: MurmurHash - มันคืออะไร?


2
มีคำขอเปิดที่นี่เพื่อเพิ่ม murmurhash เป็น php ซึ่งคุณสามารถลงคะแนนได้
keune

8

แทนที่จะสมมติว่า MD5 นั้นค่อนข้าง "ช้า" ลองเลย ใช้งานง่าย C-based ของ MD5 บนเครื่องพีซีง่าย (เหมือง 2.4 GHz Core2 โดยใช้หลักเดียว) สามารถสับ 6 ล้านข้อความขนาดเล็กต่อวินาที ข้อความเล็ก ๆ อยู่ที่นี่ถึง 55 ไบต์ สำหรับข้อความที่ยาวขึ้นความเร็วในการแปลง MD5 นั้นจะเป็นแบบเชิงเส้นด้วยขนาดของข้อความนั่นคือ crunches ข้อมูลที่ประมาณ 400 เมกะไบต์ต่อวินาที คุณอาจทราบว่านี่เป็นความเร็วสูงสุดที่ดีเป็นสี่เท่าของฮาร์ดดิสก์ที่ดีหรือการ์ดเครือข่ายกิกะบิตอีเธอร์เน็ต

เนื่องจากพีซีของฉันมีสี่คอร์หมายความว่าการแฮชข้อมูลอย่างรวดเร็วเท่ากับฮาร์ดดิสของฉันสามารถให้หรือรับการใช้งานได้สูงสุด 6% ของกำลังการประมวลผลที่มีอยู่ มันเป็นสถานการณ์ที่พิเศษมากสำหรับความเร็วการแฮ็กที่จะกลายเป็นคอขวดหรือแม้กระทั่งทำให้เกิดค่าใช้จ่ายที่เห็นได้ชัดเจนบนพีซี

สำหรับสถาปัตยกรรมขนาดเล็กที่มีความเร็วการแฮชอาจมีความเกี่ยวข้องบ้างคุณอาจต้องการใช้ MD4 MD4 นั้นใช้ได้สำหรับจุดประสงค์ที่ไม่ใช่การเข้ารหัส (และเพื่อจุดประสงค์ในการเข้ารหัสคุณไม่ควรใช้ MD5 อยู่ดี) มีรายงานว่า MD4 นั้นเร็วกว่า CRC32 บนแพลตฟอร์มที่ใช้ ARM


มีประเด็นที่ต้องพิจารณา MD5 ใช้เวลา 128 บิตแทน 32 ซึ่งหมายความว่าที่เก็บฐานข้อมูลใช้พื้นที่เพิ่มขึ้น 4 เท่าและช้ากว่า 4 เท่าในการค้นหาการเปรียบเทียบแฮช (ฉันคิดว่า ) สิ่งที่ฉันเกี่ยวข้องกับ (สำหรับการใช้งานของฉัน) คือความรวดเร็วในการสืบค้นฐานข้อมูลในภายหลังเมื่อเต็มแฮช
Camilo Martin

3
หากคุณไม่ใช้เอาต์พุตที่มีความกว้างเพียงพอคุณจะได้รับการชนแบบสุ่มซึ่งจะไม่ดีเนื่องจากเป้าหมายคือการสืบค้นฐานข้อมูลเพื่อทราบว่า "วลี" ที่ระบุนั้นเป็นที่รู้จักอยู่แล้วหรือไม่ การชนที่นี่เปลี่ยนเป็นผลบวกเท็จ ด้วย 32 บิตคุณจะเริ่มเห็นการชนทันทีที่คุณมีวลี 60000 หรือมากกว่านั้น สิ่งนี้เป็นจริงสำหรับฟังก์ชันแฮชทั้งหมดการเข้ารหัสหรือไม่ ดังที่ได้กล่าวไว้คุณสามารถเอาท์พุทของฟังก์ชันแฮชและตัดให้ยาวตามที่คุณเห็นว่าเหมาะสมภายในข้อ จำกัด ที่อธิบายข้างต้น
โทมัสพริน

@ThomasPornin ถ้าเราไปตามทางที่ถูกตัดทอนมันจะไม่เจอปัญหาการชนกันอีกครั้งฉันหมายถึงเหตุผลเดียวที่ md5 ควรจะไม่ได้รับการชนง่าย ๆ คือการไม่มีตัวละครพิเศษเมื่อเทียบกับ CRC32 ใช่ไหม?
Mohd Abdul Mujib

4

ข้อแม้

คำตอบด้านล่างไม่ตอบคำถามตามที่ถามเนื่องจากไม่แนะนำฟังก์ชันแฮช โปรดจำไว้ว่า "ฟังก์ชันแฮชคือฟังก์ชันใด ๆ ที่สามารถใช้ในการแมปข้อมูลที่มีขนาดตามอำเภอใจกับค่าคงที่" (Wikipedia) คำตอบด้านล่างแนะนำการเปลี่ยนแปลงที่ไม่รับประกันผลลัพธ์ขนาดคงที่

หากคุณยินดีที่จะผ่อนคลายความต้องการของการใช้ฟังก์ชันแฮชอ่านต่อ ...

คำตอบเดิม

ฉันแนะนำ urlencode () หรือ base64_encode () ด้วยเหตุผลเหล่านี้:

  • คุณไม่จำเป็นต้องใช้การเข้ารหัส
  • คุณต้องการความเร็ว
  • คุณต้องการวิธีในการระบุสตริงที่ไม่ซ้ำกันในขณะที่ล้างค่าสตริง 'ผิดรูปแบบ'

การปรับโค้ดเบนช์มาร์กที่อื่นในการตอบกลับเหล่านี้ฉันได้แสดงให้เห็นว่าวิธีใดวิธีหนึ่งเหล่านี้เร็วกว่าอัลกอริธึมแฮช คุณอาจใช้ urlencode () หรือ base64_encode () เพื่อล้างค่าสตริง 'malformed' ที่คุณต้องการเก็บทั้งนี้ขึ้นอยู่กับแอปพลิเคชันของคุณ


Re: "คุณต้องการวิธีในการระบุสตริงที่ไม่ซ้ำกันในขณะที่ล้างสตริง 'malformed'": คุณจะทำอย่างละเอียดไหม
David J.

มันยากที่จะจำสิ่งที่ฉันคิดเมื่อหกปีที่แล้ว ... ฉันอาจพูดพาดพิงถึงความจริงที่ว่าคุณไม่ได้ชนกับ urlencode หรือ base64_encode ดังนั้นผลลัพธ์จะไม่ซ้ำกันเหมือนกับสายดั้งเดิม
Anachronist

2

ขั้นตอนที่หนึ่ง: ติดตั้ง libsodium (หรือตรวจสอบว่าคุณใช้ PHP 7.2 ขึ้นไป)

ขั้นตอนที่สอง: ใช้ข้อใดข้อหนึ่งต่อไปนี้:

  1. sodium_crypto_generichash()ซึ่งเป็นBLAKE2bฟังก์ชันแฮชที่ปลอดภัยกว่า MD5 แต่เร็วกว่า SHA256 (ลิงก์มีเกณฑ์มาตรฐาน ฯลฯ )
  2. sodium_crypto_shorthash()ซึ่งเป็นSipHash-2-4ซึ่งเหมาะสำหรับตารางแฮช แต่ไม่ควรใช้เพื่อต้านทานการชน

_shorthashเร็วประมาณ 3 เท่า_generichashแต่คุณต้องใช้กุญแจและคุณมีความเสี่ยงเล็กน้อยในการชน ด้วย_generichashคุณอาจไม่ต้องกังวลเกี่ยวกับการชนกันและไม่จำเป็นต้องใช้รหัส (แต่อาจต้องการต่อไป)


1
คำถามคือ "สิ่งนี้เร็วแค่ไหน"?
My1

1
sodium_crypto_generichash(), which is BLAKE2b, a hash function more secure than MD5 but faster than SHA256. (Link has benchmarks, etc.)- blake2b แน่ใจว่าเป็น แต่การดำเนินงานของ userland PHP blake2b เป็นไปได้มากช้ากว่า SHA256 C-ดำเนินการสำหรับ PHP ... ฉันต้องการ PHP สามารถ adobt blake2b ใน hash_algos () ที่ห้องสวีท ..
hanshenrik

การใช้งาน PHP ล้วนๆไม่ได้แนะนำไว้ที่นี่
Scott Arciszewski

1

หากคุณกำลังมองหาอย่างรวดเร็วและไม่ซ้ำกันผมขอแนะนำให้ xxHash หรือสิ่งที่ crc32c ใช้ซีพียูรุ่นใหม่ของในตัวคำสั่งเห็น https://stackoverflow.com/a/11422479/32453 นอกจากนี้ยังเชื่อมโยงไปยังแฮชที่เร็วยิ่งขึ้นหากคุณไม่สนใจว่าจะมีการชนกันมาก


1

Adler32 ทำงานได้ดีที่สุดในเครื่องของฉัน และเปิดออกได้เร็วกว่าmd5()crc32()


3
ถ้า MD5 เร็วกว่าฟังก์ชั่น CRC32 ทั่วไปแสดงว่ามีบางอย่างผิดปกติ
nxasdf

0

การติดตั้ง md5 ในแฮชนั้นเร็วกว่า md5 เล็กน้อย () ดังนั้นนี่อาจเป็นตัวเลือกหรืออย่างอื่นโปรดลอง:

echo '<pre>';

$run = array();

function test($algo)
{
  #static $c = 0;
  #if($c>10) return;
  #$c++;

 $tss = microtime(true);
 for($i=0; $i<100000; $i++){
  $x = hash($algo, "ana are mere");
 }
 $tse = microtime(true);

 $GLOBALS['run'][(string)round($tse-$tss, 5)] = "\nhash({$algo}): \t".round($tse-$tss, 5) . " \t" . $x;
 #echo "\n$i nhash({$algo}): \t".round($tse-$tss, 5) . " \t" . $x;
}
array_map('test', hash_algos());
ksort($run);
print_r($run);
echo '</pre>';

คุณสามารถดูได้ที่http://www.dozent.net/Tipps-Tricks/PHP/hash-performance


0

CRC32เร็วกว่า แต่มีความปลอดภัยน้อยกว่า MD5 และ SHA1 ไม่มีความแตกต่างของความเร็วระหว่าง MD5 และ SHA1 มากนัก


MD5 ได้รับการพิจารณาแล้วว่าไม่ปลอดภัย เป็นวิธีที่ไม่ปลอดภัยกว่า SHA1 อ่านหน้าวิกิ MD5
Ahmed
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.