飘云阁

 找回密码
 加入我们

QQ登录

只需一步,快速开始

查看: 2974|回复: 1

[Delphi] EHash.pas--移植自EurekaLog -- by 飘云

[复制链接]
  • TA的每日心情
    开心
    2016-6-16 14:07
  • 签到天数: 10 天

    [LV.3]偶尔看看II

    发表于 2014-2-5 00:37:55 | 显示全部楼层 |阅读模式
    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. interface

    12. uses
    13.   Windows;
    14. // 获取从指针处给定大小的CRC32校验值,可用来作为判断函数是否被修改 piaoyun 2013-10-24
    15. function GetCRC32(Buf: Pointer; Size: DWord): DWord; overload;
    16. // 获取字符串CRC32
    17. function GetCRC32(const Src: string): DWord; overload;
    18. // 获取字符串CRC16
    19. function GetCRC16(const Src: string): Word;
    20. // 更新CRC32数据
    21. function UpdateCRC32(const ACRC32: LongWord; const AData: Byte): LongWord;
    22. // 获取给定位置、大小的MD5值 -- 也可以用来作为判断函数是否被修改
    23. procedure GetMD5(var Digest; const Buffer; Size: DWord);

    24. implementation

    25. const
    26.   Crc16Tab: array[0..255] of Word =
    27.   ($0000, $1021, $2042, $3063, $4084, $50A5, $60C6, $70E7,
    28.     $8108, $9129, $A14A, $B16B, $C18C, $D1AD, $E1CE, $F1EF,
    29.     $1231, $0210, $3273, $2252, $52B5, $4294, $72F7, $62D6,
    30.     $9339, $8318, $B37B, $A35A, $D3BD, $C39C, $F3FF, $E3DE,
    31.     $2462, $3443, $0420, $1401, $64E6, $74C7, $44A4, $5485,
    32.     $A56A, $B54B, $8528, $9509, $E5EE, $F5CF, $C5AC, $D58D,
    33.     $3653, $2672, $1611, $0630, $76D7, $66F6, $5695, $46B4,
    34.     $B75B, $A77A, $9719, $8738, $F7DF, $E7FE, $D79D, $C7BC,
    35.     $48C4, $58E5, $6886, $78A7, $0840, $1861, $2802, $3823,
    36.     $C9CC, $D9ED, $E98E, $F9AF, $8948, $9969, $A90A, $B92B,
    37.     $5AF5, $4AD4, $7AB7, $6A96, $1A71, $0A50, $3A33, $2A12,
    38.     $DBFD, $CBDC, $FBBF, $EB9E, $9B79, $8B58, $BB3B, $AB1A,
    39.     $6CA6, $7C87, $4CE4, $5CC5, $2C22, $3C03, $0C60, $1C41,
    40.     $EDAE, $FD8F, $CDEC, $DDCD, $AD2A, $BD0B, $8D68, $9D49,
    41.     $7E97, $6EB6, $5ED5, $4EF4, $3E13, $2E32, $1E51, $0E70,
    42.     $FF9F, $EFBE, $DFDD, $CFFC, $BF1B, $AF3A, $9F59, $8F78,
    43.     $9188, $81A9, $B1CA, $A1EB, $D10C, $C12D, $F14E, $E16F,
    44.     $1080, $00A1, $30C2, $20E3, $5004, $4025, $7046, $6067,
    45.     $83B9, $9398, $A3FB, $B3DA, $C33D, $D31C, $E37F, $F35E,
    46.     $02B1, $1290, $22F3, $32D2, $4235, $5214, $6277, $7256,
    47.     $B5EA, $A5CB, $95A8, $8589, $F56E, $E54F, $D52C, $C50D,
    48.     $34E2, $24C3, $14A0, $0481, $7466, $6447, $5424, $4405,
    49.     $A7DB, $B7FA, $8799, $97B8, $E75F, $F77E, $C71D, $D73C,
    50.     $26D3, $36F2, $0691, $16B0, $6657, $7676, $4615, $5634,
    51.     $D94C, $C96D, $F90E, $E92F, $99C8, $89E9, $B98A, $A9AB,
    52.     $5844, $4865, $7806, $6827, $18C0, $08E1, $3882, $28A3,
    53.     $CB7D, $DB5C, $EB3F, $FB1E, $8BF9, $9BD8, $ABBB, $BB9A,
    54.     $4A75, $5A54, $6A37, $7A16, $0AF1, $1AD0, $2AB3, $3A92,
    55.     $FD2E, $ED0F, $DD6C, $CD4D, $BDAA, $AD8B, $9DE8, $8DC9,
    56.     $7C26, $6C07, $5C64, $4C45, $3CA2, $2C83, $1CE0, $0CC1,
    57.     $EF1F, $FF3E, $CF5D, $DF7C, $AF9B, $BFBA, $8FD9, $9FF8,
    58.     $6E17, $7E36, $4E55, $5E74, $2E93, $3EB2, $0ED1, $1EF0);

    59. var
    60.   crc_table: array[0..255] of DWord;                                                                // Table of CRCs of all 8-bit messages.
    61.   crc_table_computed: Boolean = False;                                                              // Flag: has the table been computed? Initially "false.

    62. // Make the table for a fast CRC.

    63. procedure make_crc_table;
    64. var
    65.   c: DWord;
    66.   n, k: Integer;
    67.   poly: DWord;                                                                                      { polynomial exclusive-or pattern }

    68. const
    69. { terms of polynomial defining this crc (except x^32): }
    70.   p: array[0..13] of Byte = (0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26);

    71. begin
    72.   { make exclusive-or pattern from polynomial ($EDB88320) }
    73.   poly := 0;
    74.   for n := 0 to ((SizeOf(p) div SizeOf(Byte)) - 1) do
    75.     poly := (poly or (DWord(1) shl (31 - p[n])));

    76.   for n := 0 to 255 do
    77.   begin
    78.     c := DWord(n);
    79.     for k := 0 to 7 do
    80.     begin
    81.       if ((c and 1) <> 0) then
    82.         c := (poly xor (c shr 1))
    83.       else
    84.         c := (c shr 1);
    85.     end;
    86.     crc_table[n] := c;
    87.   end;
    88.   crc_table_computed := True;
    89. end;

    90. function GetCRC32(Buf: Pointer; Size: DWord): DWord;
    91. var
    92.   crc: DWord;
    93. begin
    94.   if (buf = nil) or (Size = 0) then
    95.   begin
    96.     Result := 0;
    97.     Exit;
    98.   end;

    99.   if (not crc_table_computed) then
    100.     make_crc_table;
    101.   crc := (0 xor uLong($FFFFFFFF));
    102.   repeat
    103.     crc := crc_table[(crc xor PByte(Buf)^) and $FF] xor (crc shr 8);
    104.     Inc(PByte(Buf));
    105.     Dec(Size);
    106.   until (Size = 0);
    107.   Result := (crc xor uLong($FFFFFFFF));
    108. end;

    109. function UpdateCRC32(const ACRC32: LongWord; const AData: Byte): LongWord;
    110. begin
    111.   if (not crc_table_computed) then
    112.     make_crc_table;
    113.   Result := LongWord(crc_table[Byte(ACRC32 xor LongWord(AData))] xor ((ACRC32 shr 8) and LongWord($00FFFFFF)));
    114. end;

    115. function GetCRC32(const Src: string): DWord;
    116. var
    117.   TestData: AnsiString;
    118. begin
    119.   TestData := UTF8Encode(Src);
    120.   Result := GetCRC32(Pointer(TestData), Length(TestData));
    121. end;

    122. function GetCRC16(const Src: string): Word;
    123. var
    124.   i: Integer;
    125.   TestData: AnsiString;
    126. begin
    127.   Result := 0;
    128.   TestData := UTF8Encode(Src);
    129.   for i := 1 to Length(TestData) do
    130.     Result := (Crc16Tab[((Result shr 8) xor Ord(TestData[i])) and $FF] xor ((Result shl 8) and $FFFF));
    131. end;

    132. procedure GetMD5(var Digest; const Buffer; Size: DWord);
    133. var
    134.   LenHi, LenLo, Index: DWord;
    135.   CurrentHash: array[0..3] of DWord;
    136.   HashBuffer: array[0..63] of Byte;
    137.   PBuf: ^Byte;

    138.   procedure Compress;
    139.   var
    140.     Data: array[0..15] of DWord;
    141.     A, B, C, D: DWord;

    142.     function LRot32(a, b: DWord): DWord; //{$IFDEF SUPPORTS_INLINE}inline; {$ENDIF}
    143.     begin
    144.       Result := (a shl b) or (a shr (32 - b));
    145.     end;

    146.   begin
    147.     Move(HashBuffer, Data, Sizeof(Data));
    148.     A := CurrentHash[0];
    149.     B := CurrentHash[1];
    150.     C := CurrentHash[2];
    151.     D := CurrentHash[3];

    152.     A := B + LRot32(A + (D xor (B and (C xor D))) + Data[0] + $D76AA478, 7);
    153.     D := A + LRot32(D + (C xor (A and (B xor C))) + Data[1] + $E8C7B756, 12);
    154.     C := D + LRot32(C + (B xor (D and (A xor B))) + Data[2] + $242070DB, 17);
    155.     B := C + LRot32(B + (A xor (C and (D xor A))) + Data[3] + $C1BDCEEE, 22);
    156.     A := B + LRot32(A + (D xor (B and (C xor D))) + Data[4] + $F57C0FAF, 7);
    157.     D := A + LRot32(D + (C xor (A and (B xor C))) + Data[5] + $4787C62A, 12);
    158.     C := D + LRot32(C + (B xor (D and (A xor B))) + Data[6] + $A8304613, 17);
    159.     B := C + LRot32(B + (A xor (C and (D xor A))) + Data[7] + $FD469501, 22);
    160.     A := B + LRot32(A + (D xor (B and (C xor D))) + Data[8] + $698098D8, 7);
    161.     D := A + LRot32(D + (C xor (A and (B xor C))) + Data[9] + $8B44F7AF, 12);
    162.     C := D + LRot32(C + (B xor (D and (A xor B))) + Data[10] + $FFFF5BB1, 17);
    163.     B := C + LRot32(B + (A xor (C and (D xor A))) + Data[11] + $895CD7BE, 22);
    164.     A := B + LRot32(A + (D xor (B and (C xor D))) + Data[12] + $6B901122, 7);
    165.     D := A + LRot32(D + (C xor (A and (B xor C))) + Data[13] + $FD987193, 12);
    166.     C := D + LRot32(C + (B xor (D and (A xor B))) + Data[14] + $A679438E, 17);
    167.     B := C + LRot32(B + (A xor (C and (D xor A))) + Data[15] + $49B40821, 22);

    168.     A := B + LRot32(A + (C xor (D and (B xor C))) + Data[1] + $F61E2562, 5);
    169.     D := A + LRot32(D + (B xor (C and (A xor B))) + Data[6] + $C040B340, 9);
    170.     C := D + LRot32(C + (A xor (B and (D xor A))) + Data[11] + $265E5A51, 14);
    171.     B := C + LRot32(B + (D xor (A and (C xor D))) + Data[0] + $E9B6C7AA, 20);
    172.     A := B + LRot32(A + (C xor (D and (B xor C))) + Data[5] + $D62F105D, 5);
    173.     D := A + LRot32(D + (B xor (C and (A xor B))) + Data[10] + $02441453, 9);
    174.     C := D + LRot32(C + (A xor (B and (D xor A))) + Data[15] + $D8A1E681, 14);
    175.     B := C + LRot32(B + (D xor (A and (C xor D))) + Data[4] + $E7D3FBC8, 20);
    176.     A := B + LRot32(A + (C xor (D and (B xor C))) + Data[9] + $21E1CDE6, 5);
    177.     D := A + LRot32(D + (B xor (C and (A xor B))) + Data[14] + $C33707D6, 9);
    178.     C := D + LRot32(C + (A xor (B and (D xor A))) + Data[3] + $F4D50D87, 14);
    179.     B := C + LRot32(B + (D xor (A and (C xor D))) + Data[8] + $455A14ED, 20);
    180.     A := B + LRot32(A + (C xor (D and (B xor C))) + Data[13] + $A9E3E905, 5);
    181.     D := A + LRot32(D + (B xor (C and (A xor B))) + Data[2] + $FCEFA3F8, 9);
    182.     C := D + LRot32(C + (A xor (B and (D xor A))) + Data[7] + $676F02D9, 14);
    183.     B := C + LRot32(B + (D xor (A and (C xor D))) + Data[12] + $8D2A4C8A, 20);

    184.     A := B + LRot32(A + (B xor C xor D) + Data[5] + $FFFA3942, 4);
    185.     D := A + LRot32(D + (A xor B xor C) + Data[8] + $8771F681, 11);
    186.     C := D + LRot32(C + (D xor A xor B) + Data[11] + $6D9D6122, 16);
    187.     B := C + LRot32(B + (C xor D xor A) + Data[14] + $FDE5380C, 23);
    188.     A := B + LRot32(A + (B xor C xor D) + Data[1] + $A4BEEA44, 4);
    189.     D := A + LRot32(D + (A xor B xor C) + Data[4] + $4BDECFA9, 11);
    190.     C := D + LRot32(C + (D xor A xor B) + Data[7] + $F6BB4B60, 16);
    191.     B := C + LRot32(B + (C xor D xor A) + Data[10] + $BEBFBC70, 23);
    192.     A := B + LRot32(A + (B xor C xor D) + Data[13] + $289B7EC6, 4);
    193.     D := A + LRot32(D + (A xor B xor C) + Data[0] + $EAA127FA, 11);
    194.     C := D + LRot32(C + (D xor A xor B) + Data[3] + $D4EF3085, 16);
    195.     B := C + LRot32(B + (C xor D xor A) + Data[6] + $04881D05, 23);
    196.     A := B + LRot32(A + (B xor C xor D) + Data[9] + $D9D4D039, 4);
    197.     D := A + LRot32(D + (A xor B xor C) + Data[12] + $E6DB99E5, 11);
    198.     C := D + LRot32(C + (D xor A xor B) + Data[15] + $1FA27CF8, 16);
    199.     B := C + LRot32(B + (C xor D xor A) + Data[2] + $C4AC5665, 23);

    200.     A := B + LRot32(A + (C xor (B or (not D))) + Data[0] + $F4292244, 6);
    201.     D := A + LRot32(D + (B xor (A or (not C))) + Data[7] + $432AFF97, 10);
    202.     C := D + LRot32(C + (A xor (D or (not B))) + Data[14] + $AB9423A7, 15);
    203.     B := C + LRot32(B + (D xor (C or (not A))) + Data[5] + $FC93A039, 21);
    204.     A := B + LRot32(A + (C xor (B or (not D))) + Data[12] + $655B59C3, 6);
    205.     D := A + LRot32(D + (B xor (A or (not C))) + Data[3] + $8F0CCC92, 10);
    206.     C := D + LRot32(C + (A xor (D or (not B))) + Data[10] + $FFEFF47D, 15);
    207.     B := C + LRot32(B + (D xor (C or (not A))) + Data[1] + $85845DD1, 21);
    208.     A := B + LRot32(A + (C xor (B or (not D))) + Data[8] + $6FA87E4F, 6);
    209.     D := A + LRot32(D + (B xor (A or (not C))) + Data[15] + $FE2CE6E0, 10);
    210.     C := D + LRot32(C + (A xor (D or (not B))) + Data[6] + $A3014314, 15);
    211.     B := C + LRot32(B + (D xor (C or (not A))) + Data[13] + $4E0811A1, 21);
    212.     A := B + LRot32(A + (C xor (B or (not D))) + Data[4] + $F7537E82, 6);
    213.     D := A + LRot32(D + (B xor (A or (not C))) + Data[11] + $BD3AF235, 10);
    214.     C := D + LRot32(C + (A xor (D or (not B))) + Data[2] + $2AD7D2BB, 15);
    215.     B := C + LRot32(B + (D xor (C or (not A))) + Data[9] + $EB86D391, 21);

    216.     Inc(CurrentHash[0], A);
    217.     Inc(CurrentHash[1], B);
    218.     Inc(CurrentHash[2], C);
    219.     Inc(CurrentHash[3], D);
    220.     Index := 0;
    221.     FillChar(HashBuffer, Sizeof(HashBuffer), 0);
    222.   end;

    223. begin
    224.   LenHi := 0;
    225.   LenLo := 0;
    226.   Index := 0;
    227.   FillChar(HashBuffer, Sizeof(HashBuffer), 0);
    228.   FillChar(CurrentHash, Sizeof(CurrentHash), 0);

    229.   CurrentHash[0] := $67452301;
    230.   CurrentHash[1] := $EFCDAB89;
    231.   CurrentHash[2] := $98BADCFE;
    232.   CurrentHash[3] := $10325476;

    233.   Inc(LenHi, Size shr 29);
    234.   Inc(LenLo, Size * 8);
    235.   if (LenLo < (Size * 8)) then Inc(LenHi);

    236.   PBuf := @Buffer;
    237.   while (Size > 0) do
    238.   begin
    239.     if (Sizeof(HashBuffer) - Index) <= DWord(Size) then
    240.     begin
    241.       Move(PBuf^, HashBuffer[Index], Sizeof(HashBuffer) - Index);
    242.       Dec(Size, Sizeof(HashBuffer) - Index);
    243.       Inc(PBuf, Sizeof(HashBuffer) - Index);
    244.       Compress;
    245.     end
    246.     else
    247.     begin
    248.       Move(PBuf^, HashBuffer[Index], Size);
    249.       Inc(Index, Size);
    250.       Size := 0;
    251.     end;
    252.   end;
    253.   HashBuffer[Index] := $80;
    254.   if (Index >= 56) then Compress;
    255.   PDWord(@HashBuffer[56])^ := LenLo;
    256.   PDWord(@HashBuffer[60])^ := LenHi;
    257.   Compress;
    258.   Move(CurrentHash, Digest, Sizeof(CurrentHash));
    259. end;

    260. end.
    复制代码
    PYG19周年生日快乐!
  • TA的每日心情
    开心
    半小时前
  • 签到天数: 1462 天

    [LV.10]以坛为家III

    发表于 2014-2-7 10:48:54 | 显示全部楼层
    群主编程功底很深,膜拜。
    PYG19周年生日快乐!
    您需要登录后才可以回帖 登录 | 加入我们

    本版积分规则

    快速回复 返回顶部 返回列表