İkili hashing - nedir bu?

Question

İkili karmaşanın ne olduğunu anlamaya çalışıyorum. Anladığım kadarıyla mesajınızı dört bölüme ayırdınız, D1-D4, o zaman bu parçaların her birini ayrı ayrı aldınız ve H1-H4 olsun. Daha sonra H5 ve H6 oluşturmak için H1 + H2 ve H3 + H4 hasadı. O halde H5 ve H6 hash'ları son hash değerinizi üretmek için H'ye sahipsiniz. Bu doğru mu? Eğer değilse lütfen yanlış gittiğimi söyle, teşekkür ederim!

Answer 1

Bak - (! Kesinlikle en iyi) good old Wikipedia

Bu muhtemelen en basit karma algoritması, ama size nasıl bir karma eserleri hakkında genel bir fikir verecektir.

Diğer tüm karma algoritmalar temelde aynı şeyi yapar, ancak tersine daha zor olan (sha256 vb.) Ya da sonuçların daha eşit dağılımını ve daha az bir çarpışma olasılığını (perlhash vb.) Veren algoritmalarla yapar. > Sha256/512 - dokunulmadığından bir dosyayı kanıtlanması

• : en iyisi

  için karma istediğinize bağlıdır.

• Bir parolayı veya gizli tutmak istediğiniz başka bir değeri kaydetme -> sha256/512
• Dizgiden veya dizgeden oluşan bir dizgiden -> perlhash veya benzeri bir sayısal anahtar alma.
• Hızla obfuscating veya hesap numaralarını maskeleme -> crc32 İşte

perl programlama dilinin ikili" bir Google aramadan bob burtle's hash

Answer 2

Siz haklısınız. Wikipedia'nın resim hemen hemen bunu açıklar: https://en.wikipedia.org/wiki/Merkle_tree

Size orijinal mesaj bölünmüş nasıl uygulamasına bağlıdır. Açıkçası, mesajınız göreceli olarak küçükse, bunu milyonlarca bloğa bölmek de yararsızdır, aynı şekilde mesajınız çok büyükse, her biri bir bayt blokta bölmek gariptir.

bunu kullanan tüm kullanıcılara sizin bölme iletişim kurmak gerekiyor unutmayın. Aksi karmaları eşleşmeyen

Answer 3

"md5", "sha256", "sha512", "haval160", vb .. Burada

MD5 algoritması tanımıdır birçok ikili karma algoritmalar vardır. Bu sözde kod ve tam bir c uygulaması http://en.wikipedia.org/wiki/MD5 adresinde bulunabilir. Bir bakışta, bu prosedürde F ve g oluşturmak için A, B, C ve D'nin kullanıldığı görülmektedir. Bu işlemden önce giriş 512 bit bloklar halinde parçalara ayrılır. Daha sonra, on altı 32-bit kelimeye.

MD5 müzakere Bu algoritmaya göre hesaplanmıştır. Tüm değerler küçük endianlıdır. CRC32 açıklar bu sayfada

//Note: All variables are unsigned 32 bit and wrap modulo 2^32 when calculating 
var int[64] s, K 

//s specifies the per-round shift amounts 
s[ 0..15] := { 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22} 
s[16..31] := { 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20} 
s[32..47] := { 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23} 
s[48..63] := { 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21} 

//Use binary integer part of the sines of integers (Radians) as constants: 
for i from 0 to 63 
    K[i] := floor(abs(sin(i + 1)) × (2 pow 32)) 
end for 
//(Or just use the following table): 
K[ 0.. 3] := { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee } 
K[ 4.. 7] := { 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501 } 
K[ 8..11] := { 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be } 
K[12..15] := { 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821 } 
K[16..19] := { 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa } 
K[20..23] := { 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8 } 
K[24..27] := { 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed } 
K[28..31] := { 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a } 
K[32..35] := { 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c } 
K[36..39] := { 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 } 
K[40..43] := { 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 } 
K[44..47] := { 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665 } 
K[48..51] := { 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039 } 
K[52..55] := { 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1 } 
K[56..59] := { 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 } 
K[60..63] := { 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 } 

//Initialize variables: 
var int a0 := 0x67452301 //A 
var int b0 := 0xefcdab89 //B 
var int c0 := 0x98badcfe //C 
var int d0 := 0x10325476 //D 

//Pre-processing: adding a single 1 bit 
append "1" bit to message  
/* Notice: the input bytes are considered as bits strings, 
    where the first bit is the most significant bit of the byte.[41] 


//Pre-processing: padding with zeros 
append "0" bit until message length in bit ≡ 448 (mod 512) 
append length mod (2 pow 64) to message 


//Process the message in successive 512-bit chunks: 
for each 512-bit chunk of message 
    break chunk into sixteen 32-bit words M[j], 0 ≤ j ≤ 15 
//Initialize hash value for this chunk: 
    var int A := a0 
    var int B := b0 
    var int C := c0 
    var int D := d0 
//Main loop: 
    for i from 0 to 63 
     if 0 ≤ i ≤ 15 then 
      F := (B and C) or ((not B) and D) 
      g := i 
     else if 16 ≤ i ≤ 31 
      F := (D and B) or ((not D) and C) 
      g := (5×i + 1) mod 16 
     else if 32 ≤ i ≤ 47 
      F := B xor C xor D 
      g := (3×i + 5) mod 16 
     else if 48 ≤ i ≤ 63 
      F := C xor (B or (not D)) 
      g := (7×i) mod 16 
     dTemp := D 
     D := C 
     C := B 
     B := B + leftrotate((A + F + K[i] + M[g]), s[i]) 
     A := dTemp 
    end for 
//Add this chunk's hash to result so far: 
    a0 := a0 + A 
    b0 := b0 + B 
    c0 := c0 + C 
    d0 := d0 + D 
end for 

var char digest[16] := a0 append b0 append c0 append d0 //(Output is in little-endian) 

//leftrotate function definition 
leftrotate (x, c) 
    return (x << c) binary or (x >> (32-c));