EHash.pas--移植自EurekaLog -- by 飘云

飘云

1. {************************************************}
   
2. {                                                }
   
3. {              EHash EurekaLog v 7.x             }
   
4. {               Hash Unit - EHashes              }
   
5. {                                                }
   
6. {  Copyright (c) 2001 - 2008 by Fabio Dell'Aria  }
   
7. {  Fixed By PiaoYun/P.Y.G  2013-10-24            }
   
8. {                                                }
   
9. {************************************************}
   
10. unit EHash;
    
11. 
    
12. interface
    
13. 
    
14. uses
    
15.   Windows;
    
16. // 获取从指针处给定大小的CRC32校验值，可用来作为判断函数是否被修改 piaoyun 2013-10-24
    
17. function GetCRC32(Buf: Pointer; Size: DWord): DWord; overload;
    
18. // 获取字符串CRC32
    
19. function GetCRC32(const Src: string): DWord; overload;
    
20. // 获取字符串CRC16
    
21. function GetCRC16(const Src: string): Word;
    
22. // 更新CRC32数据
    
23. function UpdateCRC32(const ACRC32: LongWord; const AData: Byte): LongWord;
    
24. // 获取给定位置、大小的MD5值 -- 也可以用来作为判断函数是否被修改
    
25. procedure GetMD5(var Digest; const Buffer; Size: DWord);
    
26. 
    
27. implementation
    
28. 
    
29. const
    
30.   Crc16Tab: array[0..255] of Word =
    
31.   ($0000, $1021, $2042, $3063, $4084, $50A5, $60C6, $70E7,
    
32.     $8108, $9129, $A14A, $B16B, $C18C, $D1AD, $E1CE, $F1EF,
    
33.     $1231, $0210, $3273, $2252, $52B5, $4294, $72F7, $62D6,
    
34.     $9339, $8318, $B37B, $A35A, $D3BD, $C39C, $F3FF, $E3DE,
    
35.     $2462, $3443, $0420, $1401, $64E6, $74C7, $44A4, $5485,
    
36.     $A56A, $B54B, $8528, $9509, $E5EE, $F5CF, $C5AC, $D58D,
    
37.     $3653, $2672, $1611, $0630, $76D7, $66F6, $5695, $46B4,
    
38.     $B75B, $A77A, $9719, $8738, $F7DF, $E7FE, $D79D, $C7BC,
    
39.     $48C4, $58E5, $6886, $78A7, $0840, $1861, $2802, $3823,
    
40.     $C9CC, $D9ED, $E98E, $F9AF, $8948, $9969, $A90A, $B92B,
    
41.     $5AF5, $4AD4, $7AB7, $6A96, $1A71, $0A50, $3A33, $2A12,
    
42.     $DBFD, $CBDC, $FBBF, $EB9E, $9B79, $8B58, $BB3B, $AB1A,
    
43.     $6CA6, $7C87, $4CE4, $5CC5, $2C22, $3C03, $0C60, $1C41,
    
44.     $EDAE, $FD8F, $CDEC, $DDCD, $AD2A, $BD0B, $8D68, $9D49,
    
45.     $7E97, $6EB6, $5ED5, $4EF4, $3E13, $2E32, $1E51, $0E70,
    
46.     $FF9F, $EFBE, $DFDD, $CFFC, $BF1B, $AF3A, $9F59, $8F78,
    
47.     $9188, $81A9, $B1CA, $A1EB, $D10C, $C12D, $F14E, $E16F,
    
48.     $1080, $00A1, $30C2, $20E3, $5004, $4025, $7046, $6067,
    
49.     $83B9, $9398, $A3FB, $B3DA, $C33D, $D31C, $E37F, $F35E,
    
50.     $02B1, $1290, $22F3, $32D2, $4235, $5214, $6277, $7256,
    
51.     $B5EA, $A5CB, $95A8, $8589, $F56E, $E54F, $D52C, $C50D,
    
52.     $34E2, $24C3, $14A0, $0481, $7466, $6447, $5424, $4405,
    
53.     $A7DB, $B7FA, $8799, $97B8, $E75F, $F77E, $C71D, $D73C,
    
54.     $26D3, $36F2, $0691, $16B0, $6657, $7676, $4615, $5634,
    
55.     $D94C, $C96D, $F90E, $E92F, $99C8, $89E9, $B98A, $A9AB,
    
56.     $5844, $4865, $7806, $6827, $18C0, $08E1, $3882, $28A3,
    
57.     $CB7D, $DB5C, $EB3F, $FB1E, $8BF9, $9BD8, $ABBB, $BB9A,
    
58.     $4A75, $5A54, $6A37, $7A16, $0AF1, $1AD0, $2AB3, $3A92,
    
59.     $FD2E, $ED0F, $DD6C, $CD4D, $BDAA, $AD8B, $9DE8, $8DC9,
    
60.     $7C26, $6C07, $5C64, $4C45, $3CA2, $2C83, $1CE0, $0CC1,
    
61.     $EF1F, $FF3E, $CF5D, $DF7C, $AF9B, $BFBA, $8FD9, $9FF8,
    
62.     $6E17, $7E36, $4E55, $5E74, $2E93, $3EB2, $0ED1, $1EF0);
    
63. 
    
64. var
    
65.   crc_table: array[0..255] of DWord;                                                                // Table of CRCs of all 8-bit messages.
    
66.   crc_table_computed: Boolean = False;                                                              // Flag: has the table been computed? Initially "false.
    
67. 
    
68. // Make the table for a fast CRC.
    
69. 
    
70. procedure make_crc_table;
    
71. var
    
72.   c: DWord;
    
73.   n, k: Integer;
    
74.   poly: DWord;                                                                                      { polynomial exclusive-or pattern }
    
75. 
    
76. const
    
77. { terms of polynomial defining this crc (except x^32): }
    
78.   p: array[0..13] of Byte = (0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26);
    
79. 
    
80. begin
    
81.   { make exclusive-or pattern from polynomial ($EDB88320) }
    
82.   poly := 0;
    
83.   for n := 0 to ((SizeOf(p) div SizeOf(Byte)) - 1) do
    
84.     poly := (poly or (DWord(1) shl (31 - p[n])));
    
85. 
    
86.   for n := 0 to 255 do
    
87.   begin
    
88.     c := DWord(n);
    
89.     for k := 0 to 7 do
    
90.     begin
    
91.       if ((c and 1) <> 0) then
    
92.         c := (poly xor (c shr 1))
    
93.       else
    
94.         c := (c shr 1);
    
95.     end;
    
96.     crc_table[n] := c;
    
97.   end;
    
98.   crc_table_computed := True;
    
99. end;
    
100. 
     
101. function GetCRC32(Buf: Pointer; Size: DWord): DWord;
     
102. var
     
103.   crc: DWord;
     
104. begin
     
105.   if (buf = nil) or (Size = 0) then
     
106.   begin
     
107.     Result := 0;
     
108.     Exit;
     
109.   end;
     
110. 
     
111.   if (not crc_table_computed) then
     
112.     make_crc_table;
     
113.   crc := (0 xor uLong($FFFFFFFF));
     
114.   repeat
     
115.     crc := crc_table[(crc xor PByte(Buf)^) and $FF] xor (crc shr 8);
     
116.     Inc(PByte(Buf));
     
117.     Dec(Size);
     
118.   until (Size = 0);
     
119.   Result := (crc xor uLong($FFFFFFFF));
     
120. end;
     
121. 
     
122. function UpdateCRC32(const ACRC32: LongWord; const AData: Byte): LongWord;
     
123. begin
     
124.   if (not crc_table_computed) then
     
125.     make_crc_table;
     
126.   Result := LongWord(crc_table[Byte(ACRC32 xor LongWord(AData))] xor ((ACRC32 shr 8) and LongWord($00FFFFFF)));
     
127. end;
     
128. 
     
129. function GetCRC32(const Src: string): DWord;
     
130. var
     
131.   TestData: AnsiString;
     
132. begin
     
133.   TestData := UTF8Encode(Src);
     
134.   Result := GetCRC32(Pointer(TestData), Length(TestData));
     
135. end;
     
136. 
     
137. function GetCRC16(const Src: string): Word;
     
138. var
     
139.   i: Integer;
     
140.   TestData: AnsiString;
     
141. begin
     
142.   Result := 0;
     
143.   TestData := UTF8Encode(Src);
     
144.   for i := 1 to Length(TestData) do
     
145.     Result := (Crc16Tab[((Result shr 8) xor Ord(TestData[i])) and $FF] xor ((Result shl 8) and $FFFF));
     
146. end;
     
147. 
     
148. procedure GetMD5(var Digest; const Buffer; Size: DWord);
     
149. var
     
150.   LenHi, LenLo, Index: DWord;
     
151.   CurrentHash: array[0..3] of DWord;
     
152.   HashBuffer: array[0..63] of Byte;
     
153.   PBuf: ^Byte;
     
154. 
     
155.   procedure Compress;
     
156.   var
     
157.     Data: array[0..15] of DWord;
     
158.     A, B, C, D: DWord;
     
159. 
     
160.     function LRot32(a, b: DWord): DWord; //{$IFDEF SUPPORTS_INLINE}inline; {$ENDIF}
     
161.     begin
     
162.       Result := (a shl b) or (a shr (32 - b));
     
163.     end;
     
164. 
     
165.   begin
     
166.     Move(HashBuffer, Data, Sizeof(Data));
     
167.     A := CurrentHash[0];
     
168.     B := CurrentHash[1];
     
169.     C := CurrentHash[2];
     
170.     D := CurrentHash[3];
     
171. 
     
172.     A := B + LRot32(A + (D xor (B and (C xor D))) + Data[0] + $D76AA478, 7);
     
173.     D := A + LRot32(D + (C xor (A and (B xor C))) + Data[1] + $E8C7B756, 12);
     
174.     C := D + LRot32(C + (B xor (D and (A xor B))) + Data[2] + $242070DB, 17);
     
175.     B := C + LRot32(B + (A xor (C and (D xor A))) + Data[3] + $C1BDCEEE, 22);
     
176.     A := B + LRot32(A + (D xor (B and (C xor D))) + Data[4] + $F57C0FAF, 7);
     
177.     D := A + LRot32(D + (C xor (A and (B xor C))) + Data[5] + $4787C62A, 12);
     
178.     C := D + LRot32(C + (B xor (D and (A xor B))) + Data[6] + $A8304613, 17);
     
179.     B := C + LRot32(B + (A xor (C and (D xor A))) + Data[7] + $FD469501, 22);
     
180.     A := B + LRot32(A + (D xor (B and (C xor D))) + Data[8] + $698098D8, 7);
     
181.     D := A + LRot32(D + (C xor (A and (B xor C))) + Data[9] + $8B44F7AF, 12);
     
182.     C := D + LRot32(C + (B xor (D and (A xor B))) + Data[10] + $FFFF5BB1, 17);
     
183.     B := C + LRot32(B + (A xor (C and (D xor A))) + Data[11] + $895CD7BE, 22);
     
184.     A := B + LRot32(A + (D xor (B and (C xor D))) + Data[12] + $6B901122, 7);
     
185.     D := A + LRot32(D + (C xor (A and (B xor C))) + Data[13] + $FD987193, 12);
     
186.     C := D + LRot32(C + (B xor (D and (A xor B))) + Data[14] + $A679438E, 17);
     
187.     B := C + LRot32(B + (A xor (C and (D xor A))) + Data[15] + $49B40821, 22);
     
188. 
     
189.     A := B + LRot32(A + (C xor (D and (B xor C))) + Data[1] + $F61E2562, 5);
     
190.     D := A + LRot32(D + (B xor (C and (A xor B))) + Data[6] + $C040B340, 9);
     
191.     C := D + LRot32(C + (A xor (B and (D xor A))) + Data[11] + $265E5A51, 14);
     
192.     B := C + LRot32(B + (D xor (A and (C xor D))) + Data[0] + $E9B6C7AA, 20);
     
193.     A := B + LRot32(A + (C xor (D and (B xor C))) + Data[5] + $D62F105D, 5);
     
194.     D := A + LRot32(D + (B xor (C and (A xor B))) + Data[10] + $02441453, 9);
     
195.     C := D + LRot32(C + (A xor (B and (D xor A))) + Data[15] + $D8A1E681, 14);
     
196.     B := C + LRot32(B + (D xor (A and (C xor D))) + Data[4] + $E7D3FBC8, 20);
     
197.     A := B + LRot32(A + (C xor (D and (B xor C))) + Data[9] + $21E1CDE6, 5);
     
198.     D := A + LRot32(D + (B xor (C and (A xor B))) + Data[14] + $C33707D6, 9);
     
199.     C := D + LRot32(C + (A xor (B and (D xor A))) + Data[3] + $F4D50D87, 14);
     
200.     B := C + LRot32(B + (D xor (A and (C xor D))) + Data[8] + $455A14ED, 20);
     
201.     A := B + LRot32(A + (C xor (D and (B xor C))) + Data[13] + $A9E3E905, 5);
     
202.     D := A + LRot32(D + (B xor (C and (A xor B))) + Data[2] + $FCEFA3F8, 9);
     
203.     C := D + LRot32(C + (A xor (B and (D xor A))) + Data[7] + $676F02D9, 14);
     
204.     B := C + LRot32(B + (D xor (A and (C xor D))) + Data[12] + $8D2A4C8A, 20);
     
205. 
     
206.     A := B + LRot32(A + (B xor C xor D) + Data[5] + $FFFA3942, 4);
     
207.     D := A + LRot32(D + (A xor B xor C) + Data[8] + $8771F681, 11);
     
208.     C := D + LRot32(C + (D xor A xor B) + Data[11] + $6D9D6122, 16);
     
209.     B := C + LRot32(B + (C xor D xor A) + Data[14] + $FDE5380C, 23);
     
210.     A := B + LRot32(A + (B xor C xor D) + Data[1] + $A4BEEA44, 4);
     
211.     D := A + LRot32(D + (A xor B xor C) + Data[4] + $4BDECFA9, 11);
     
212.     C := D + LRot32(C + (D xor A xor B) + Data[7] + $F6BB4B60, 16);
     
213.     B := C + LRot32(B + (C xor D xor A) + Data[10] + $BEBFBC70, 23);
     
214.     A := B + LRot32(A + (B xor C xor D) + Data[13] + $289B7EC6, 4);
     
215.     D := A + LRot32(D + (A xor B xor C) + Data[0] + $EAA127FA, 11);
     
216.     C := D + LRot32(C + (D xor A xor B) + Data[3] + $D4EF3085, 16);
     
217.     B := C + LRot32(B + (C xor D xor A) + Data[6] + $04881D05, 23);
     
218.     A := B + LRot32(A + (B xor C xor D) + Data[9] + $D9D4D039, 4);
     
219.     D := A + LRot32(D + (A xor B xor C) + Data[12] + $E6DB99E5, 11);
     
220.     C := D + LRot32(C + (D xor A xor B) + Data[15] + $1FA27CF8, 16);
     
221.     B := C + LRot32(B + (C xor D xor A) + Data[2] + $C4AC5665, 23);
     
222. 
     
223.     A := B + LRot32(A + (C xor (B or (not D))) + Data[0] + $F4292244, 6);
     
224.     D := A + LRot32(D + (B xor (A or (not C))) + Data[7] + $432AFF97, 10);
     
225.     C := D + LRot32(C + (A xor (D or (not B))) + Data[14] + $AB9423A7, 15);
     
226.     B := C + LRot32(B + (D xor (C or (not A))) + Data[5] + $FC93A039, 21);
     
227.     A := B + LRot32(A + (C xor (B or (not D))) + Data[12] + $655B59C3, 6);
     
228.     D := A + LRot32(D + (B xor (A or (not C))) + Data[3] + $8F0CCC92, 10);
     
229.     C := D + LRot32(C + (A xor (D or (not B))) + Data[10] + $FFEFF47D, 15);
     
230.     B := C + LRot32(B + (D xor (C or (not A))) + Data[1] + $85845DD1, 21);
     
231.     A := B + LRot32(A + (C xor (B or (not D))) + Data[8] + $6FA87E4F, 6);
     
232.     D := A + LRot32(D + (B xor (A or (not C))) + Data[15] + $FE2CE6E0, 10);
     
233.     C := D + LRot32(C + (A xor (D or (not B))) + Data[6] + $A3014314, 15);
     
234.     B := C + LRot32(B + (D xor (C or (not A))) + Data[13] + $4E0811A1, 21);
     
235.     A := B + LRot32(A + (C xor (B or (not D))) + Data[4] + $F7537E82, 6);
     
236.     D := A + LRot32(D + (B xor (A or (not C))) + Data[11] + $BD3AF235, 10);
     
237.     C := D + LRot32(C + (A xor (D or (not B))) + Data[2] + $2AD7D2BB, 15);
     
238.     B := C + LRot32(B + (D xor (C or (not A))) + Data[9] + $EB86D391, 21);
     
239. 
     
240.     Inc(CurrentHash[0], A);
     
241.     Inc(CurrentHash[1], B);
     
242.     Inc(CurrentHash[2], C);
     
243.     Inc(CurrentHash[3], D);
     
244.     Index := 0;
     
245.     FillChar(HashBuffer, Sizeof(HashBuffer), 0);
     
246.   end;
     
247. 
     
248. begin
     
249.   LenHi := 0;
     
250.   LenLo := 0;
     
251.   Index := 0;
     
252.   FillChar(HashBuffer, Sizeof(HashBuffer), 0);
     
253.   FillChar(CurrentHash, Sizeof(CurrentHash), 0);
     
254. 
     
255.   CurrentHash[0] := $67452301;
     
256.   CurrentHash[1] := $EFCDAB89;
     
257.   CurrentHash[2] := $98BADCFE;
     
258.   CurrentHash[3] := $10325476;
     
259. 
     
260.   Inc(LenHi, Size shr 29);
     
261.   Inc(LenLo, Size * 8);
     
262.   if (LenLo < (Size * 8)) then Inc(LenHi);
     
263. 
     
264.   PBuf := @Buffer;
     
265.   while (Size > 0) do
     
266.   begin
     
267.     if (Sizeof(HashBuffer) - Index) <= DWord(Size) then
     
268.     begin
     
269.       Move(PBuf^, HashBuffer[Index], Sizeof(HashBuffer) - Index);
     
270.       Dec(Size, Sizeof(HashBuffer) - Index);
     
271.       Inc(PBuf, Sizeof(HashBuffer) - Index);
     
272.       Compress;
     
273.     end
     
274.     else
     
275.     begin
     
276.       Move(PBuf^, HashBuffer[Index], Size);
     
277.       Inc(Index, Size);
     
278.       Size := 0;
     
279.     end;
     
280.   end;
     
281.   HashBuffer[Index] := $80;
     
282.   if (Index >= 56) then Compress;
     
283.   PDWord(@HashBuffer[56])^ := LenLo;
     
284.   PDWord(@HashBuffer[60])^ := LenHi;
     
285.   Compress;
     
286.   Move(CurrentHash, Digest, Sizeof(CurrentHash));
     
287. end;
     
288. 
     
289. end.
     

复制代码

xingbing

群主编程功底很深，膜拜。