바이너리 해싱 -이게 뭐죠?

Question

이진 해싱이 무엇인지 이해하려고합니다. 내 이해는 메시지를 네 부분으로 나눠서 D1-D4를 작성한 다음 각 부분을 개별적으로 가지고 H1-H4를 얻는 것입니다. 그런 다음 H1 + H2 및 H3 + H4를 해시하여 H5 및 H6을 만듭니다. 그런 다음 H5와 H6을 해시하여 최종 해시 값을 생성합니다. H. 맞습니까? 제발 내가 어디가 잘못 됐는지 말해주세요, 고마워요!

Answer 1

봐 - (! 확실히 최고의) good old Wikipedia

이것은 아마도 가장 간단한 해싱 알고리즘이지만, 그것은 당신에게 어떻게 해시 작품의 일반적인 아이디어를 줄 것이다.

다른 모든 해시 알고리즘은 기본적으로 동일한 작업을 수행하지만, 역순으로 (sha256 등) 또는 결과가 더 균등하게 분산되고 충돌 (perlhash 등)이 적게 발생하는 알고리즘을 사용합니다. > SHA256/512 - 훼손되지 않은 파일을 증명

• : 최고

  는 해시를 원하는에 따라 달라집니다.

• 비밀 번호를 유지하려는 비밀 번호 또는 다른 값 저장 -> sha256/512
• 문자열 또는 perlhash 또는 유사 문자로 배열 또는 데이터베이스 레코드의 숫자 키 가져 오기.
• 신속 난독 또는 계좌 번호를 마스킹 -> CRC32 여기

는 펄 프로그래밍 언어 진 "의 구글 검색 bob burtle's hash

Answer 2

정확합니다. Wikipedia의 그림은 거의 다음과 같습니다. https://en.wikipedia.org/wiki/Merkle_tree

원본 메시지를 어떻게 분할했는지에 따라 다릅니다. 분명히 메시지가 상대적으로 작 으면 메시지를 수백만 블록으로 나누는 것은 쓸모가 없습니다. 마찬가지로 메시지가 매우 크다면 각각을 바이트 단위로 나누는 것은 어색합니다.

당신이 그것을 사용하는 모든 사람들에게 나누기를 전할 필요가 있다는 것을 잊지 마십시오. 그렇지 않으면 해시가 일치하지 않습니다

Answer 3

"MD5", "SHA256", "SHA512", "haval160", 등 여기

는 MD5 알고리즘에 대한 설명입니다 많은 이진 해시 알고리즘이 있습니다. 이 의사 코드와 완벽한 구현은 http://en.wikipedia.org/wiki/MD5에서 찾을 수 있습니다. 이 과정에서 A, B, C 및 D가 F 및 g를 만드는 데 사용 된 것 같습니다. 이 절차를 수행하기 전에 입력이 512 비트 블록으로 분할됩니다. 그런 다음 16 비트의 32 비트 단어를 추가합니다.

MD5 해시는이 알고리즘에 따라 계산됩니다. 모든 값은 리틀 엔디안 방식입니다. CRC32 설명이 페이지에서

//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));