hash.pas

说明：支持标准MD5、SHA1、Inno密码、QQ密码、Serv-U密码。 支持多线程。 支持进度保存、读取。

Function SHA1File(Const FileName: String): TSHA1Digest;
Var
  FS: TFileStream;
Begin
  FS := TFileStream.Create(FileName, fmOpenRead Or fmShareDenyNone);
  Try
    Result := SHA1Stream(FS);
  Finally
    FS.Free;
  End;
End;

Function SHA1Print(Digest: TSHA1Digest): String;
Begin
  Result := BufferToHex(Digest, SizeOf(Digest));
End;

Function SHA1Match(D1, D2: TSHA1Digest): Boolean;
Begin
  Result := CompareBuffers(D1, D2, SizeOf(D1));
End;

{MD5}
Procedure MD5Transform(Var Buffer: Array Of DWord; Const InBuf: Array Of DWord);
Const
  S11 = 7;
  S12 = 12;
  S13 = 17;
  S14 = 22;
  S21 = 5;
  S22 = 9;
  S23 = 14;
  S24 = 20;
  S31 = 4;
  S32 = 11;
  S33 = 16;
  S34 = 23;
  S41 = 6;
  S42 = 10;
  S43 = 15;
  S44 = 21;
Var
  Buf: Array[0..3] Of DWord;
  InA: Array[0..15] Of DWord;
Var
  A: DWord;
  B: DWord;
  C: DWord;
  D: DWord;

  Procedure FF(Var A: DWord; B, C, D, X, S, AC: DWord);
  Begin
    A := RolX(A + ((B And C) Or (Not B And D)) + X + AC, S) + B;
  End;

  Procedure GG(Var A: DWord; B, C, D, X, S, AC: DWord);
  Begin
    A := RolX(A + ((B And D) Or (C And Not D)) + X + AC, S) + B;
  End;

  Procedure HH(Var A: DWord; B, C, D, X, S, AC: DWord);
  Begin
    A := RolX(A + (B Xor C Xor D) + X + AC, S) + B;
  End;

  Procedure II(Var A: DWord; B, C, D, X, S, AC: DWord);
  Begin
    A := RolX(A + (C Xor (B Or Not D)) + X + AC, S) + B;
  End;

Begin
  Move(Buffer, Buf, SizeOf(Buf));       {!!.01}
  Move(InBuf, InA, SizeOf(InA));        {!!.01}
  A := Buf[0];
  B := Buf[1];
  C := Buf[2];
  D := Buf[3];

  {round 1}
  FF(A, B, C, D, InA[0], S11, $D76AA478); { 1 }
  FF(D, A, B, C, InA[1], S12, $E8C7B756); { 2 }
  FF(C, D, A, B, InA[2], S13, $242070DB); { 3 }
  FF(B, C, D, A, InA[3], S14, $C1BDCEEE); { 4 }
  FF(A, B, C, D, InA[4], S11, $F57C0FAF); { 5 }
  FF(D, A, B, C, InA[5], S12, $4787C62A); { 6 }
  FF(C, D, A, B, InA[6], S13, $A8304613); { 7 }
  FF(B, C, D, A, InA[7], S14, $FD469501); { 8 }
  FF(A, B, C, D, InA[8], S11, $698098D8); { 9 }
  FF(D, A, B, C, InA[9], S12, $8B44F7AF); { 10 }
  FF(C, D, A, B, InA[10], S13, $FFFF5BB1); { 11 }
  FF(B, C, D, A, InA[11], S14, $895CD7BE); { 12 }
  FF(A, B, C, D, InA[12], S11, $6B901122); { 13 }
  FF(D, A, B, C, InA[13], S12, $FD987193); { 14 }
  FF(C, D, A, B, InA[14], S13, $A679438E); { 15 }
  FF(B, C, D, A, InA[15], S14, $49B40821); { 16 }

  {round 2}
  GG(A, B, C, D, InA[1], S21, $F61E2562); { 17 }
  GG(D, A, B, C, InA[6], S22, $C040B340); { 18 }
  GG(C, D, A, B, InA[11], S23, $265E5A51); { 19 }
  GG(B, C, D, A, InA[0], S24, $E9B6C7AA); { 20 }
  GG(A, B, C, D, InA[5], S21, $D62F105D); { 21 }
  GG(D, A, B, C, InA[10], S22, $02441453); { 22 }
  GG(C, D, A, B, InA[15], S23, $D8A1E681); { 23 }
  GG(B, C, D, A, InA[4], S24, $E7D3FBC8); { 24 }
  GG(A, B, C, D, InA[9], S21, $21E1CDE6); { 25 }
  GG(D, A, B, C, InA[14], S22, $C33707D6); { 26 }
  GG(C, D, A, B, InA[3], S23, $F4D50D87); { 27 }
  GG(B, C, D, A, InA[8], S24, $455A14ED); { 28 }
  GG(A, B, C, D, InA[13], S21, $A9E3E905); { 29 }
  GG(D, A, B, C, InA[2], S22, $FCEFA3F8); { 30 }
  GG(C, D, A, B, InA[7], S23, $676F02D9); { 31 }
  GG(B, C, D, A, InA[12], S24, $8D2A4C8A); { 32 }

  {round 3}
  HH(A, B, C, D, InA[5], S31, $FFFA3942); { 33 }
  HH(D, A, B, C, InA[8], S32, $8771F681); { 34 }
  HH(C, D, A, B, InA[11], S33, $6D9D6122); { 35 }
  HH(B, C, D, A, InA[14], S34, $FDE5380C); { 36 }
  HH(A, B, C, D, InA[1], S31, $A4BEEA44); { 37 }
  HH(D, A, B, C, InA[4], S32, $4BDECFA9); { 38 }
  HH(C, D, A, B, InA[7], S33, $F6BB4B60); { 39 }
  HH(B, C, D, A, InA[10], S34, $BEBFBC70); { 40 }
  HH(A, B, C, D, InA[13], S31, $289B7EC6); { 41 }
  HH(D, A, B, C, InA[0], S32, $EAA127FA); { 42 }
  HH(C, D, A, B, InA[3], S33, $D4EF3085); { 43 }
  HH(B, C, D, A, InA[6], S34, $4881D05); { 44 }
  HH(A, B, C, D, InA[9], S31, $D9D4D039); { 45 }
  HH(D, A, B, C, InA[12], S32, $E6DB99E5); { 46 }
  HH(C, D, A, B, InA[15], S33, $1FA27CF8); { 47 }
  HH(B, C, D, A, InA[2], S34, $C4AC5665); { 48 }

  {round 4}
  II(A, B, C, D, InA[0], S41, $F4292244); { 49 }
  II(D, A, B, C, InA[7], S42, $432AFF97); { 50 }
  II(C, D, A, B, InA[14], S43, $AB9423A7); { 51 }
  II(B, C, D, A, InA[5], S44, $FC93A039); { 52 }
  II(A, B, C, D, InA[12], S41, $655B59C3); { 53 }
  II(D, A, B, C, InA[3], S42, $8F0CCC92); { 54 }
  II(C, D, A, B, InA[10], S43, $FFEFF47D); { 55 }
  II(B, C, D, A, InA[1], S44, $85845DD1); { 56 }
  II(A, B, C, D, InA[8], S41, $6FA87E4F); { 57 }
  II(D, A, B, C, InA[15], S42, $FE2CE6E0); { 58 }
  II(C, D, A, B, InA[6], S43, $A3014314); { 59 }
  II(B, C, D, A, InA[13], S44, $4E0811A1); { 60 }
  II(A, B, C, D, InA[4], S41, $F7537E82); { 61 }
  II(D, A, B, C, InA[11], S42, $BD3AF235); { 62 }
  II(C, D, A, B, InA[2], S43, $2AD7D2BB); { 63 }
  II(B, C, D, A, InA[9], S44, $EB86D391); { 64 }

  Inc(Buf[0], A);
  Inc(Buf[1], B);
  Inc(Buf[2], C);
  Inc(Buf[3], D);

  Move(Buf, Buffer, SizeOf(Buffer));
End;

Procedure MD5Init(Var Context: TMD5Context);
Var
  MD5: TMD5ContextEx;
Begin
  Move(Context, MD5, SizeOf(MD5));
  MD5.Count[0] := 0;
  MD5.Count[1] := 0;

  MD5.State[0] := $67452301;
  MD5.State[1] := $EFCDAB89;
  MD5.State[2] := $98BADCFE;
  MD5.State[3] := $10325476;
  Move(MD5, Context, SizeOf(Context));
End;

Procedure MD5Update(Var Context: TMD5Context; Const Buf; BufSize: Longint);
Var
  MD5: TMD5ContextEx;
  InBuf: Array[0..15] Of DWord;
  BufOfs: Longint;
  MDI: Word;
  I: Word;
  II: Word;
Begin
  Move(Context, MD5, SizeOf(MD5));

  MDI := (MD5.Count[0] Shr 3) And $3F;

  If ((MD5.Count[0] + (DWord(BufSize) Shl 3)) < MD5.Count[0]) Then
    Inc(MD5.Count[1]);
  Inc(MD5.Count[0], BufSize Shl 3);
  Inc(MD5.Count[1], BufSize Shr 29);

  BufOfs := 0;
  While (BufSize > 0) Do
  Begin
    Dec(BufSize);
    MD5.Buf[MDI] := TByteArray(Buf)[BufOfs]; {!!.01}
    Inc(MDI);
    Inc(BufOfs);
    If (MDI = $40) Then
    Begin
      II := 0;
      For I := 0 To 15 Do
      Begin
        InBuf[I] := Longint(MD5.Buf[II + 3]) Shl 24 Or
          Longint(MD5.Buf[II + 2]) Shl 16 Or
          Longint(MD5.Buf[II + 1]) Shl 8 Or
          Longint(MD5.Buf[II]);
        Inc(II, 4);
      End;
      MD5Transform(MD5.State, InBuf);
      MD5Transform(TMD5ContextEx(Context).State, InBuf);
      MDI := 0;
    End;
  End;
  Move(MD5, Context, SizeOf(Context));  {!!.01}
End;

Procedure MD5Final(Var Context: TMD5Context; Var Digest: TMD5Digest);
Const
  Padding: Array[0..63] Of Byte = (
    $80, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00,
    $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00,
    $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00,
    $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00);
Var
  MD5: TMD5ContextEx;
  InBuf: Array[0..15] Of DWord;
  MDI: Longint;
  I: Word;
  II: Word;
  PadLen: Word;
Begin
  Move(Context, MD5, SizeOf(MD5));

  InBuf[14] := MD5.Count[0];
  InBuf[15] := MD5.Count[1];

  MDI := (MD5.Count[0] Shr 3) And $3F;

  If (MDI < 56) Then
    PadLen := 56 - MDI
  Else
    PadLen := 120 - MDI;
  MD5Update(Context, Padding, PadLen);

  Move(Context, MD5, SizeOf(MD5));

  II := 0;
  For I := 0 To 13 Do
  Begin
    InBuf[I] :=
      (Longint(MD5.Buf[II + 3]) Shl 24) Or
      (Longint(MD5.Buf[II + 2]) Shl 16) Or
      (Longint(MD5.Buf[II + 1]) Shl 8) Or
      Longint(MD5.Buf[II]);
    Inc(II, 4);
  End;
  MD5Transform(MD5.State, InBuf);
  II := 0;
  For I := 0 To 3 Do
  Begin
    Digest[II] := Byte(MD5.State[I] And $FF);
    Digest[II + 1] := Byte((MD5.State[I] Shr 8) And $FF);
    Digest[II + 2] := Byte((MD5.State[I] Shr 16) And $FF);
    Digest[II + 3] := Byte((MD5.State[I] Shr 24) And $FF);
    Inc(II, 4);
  End;
  Move(MD5, Context, SizeOf(Context));
End;

Procedure HashMD5(Var Digest: TMD5Digest; Const Buf; BufSize: Longint);
Var
  Context: TMD5Context;
Begin
  FillChar(Context, SizeOf(Context), $00);
  MD5Init(Context);
  MD5Update(Context, Buf, BufSize);
  MD5Final(Context, Digest);
End;

Function MD5String(Const Str: String): TMD5Digest;
Begin
  HashMD5(Result, Str[1], Length(Str));
End;

Function MD5Buffer(Const Buf; BufSize: Cardinal): TMD5Digest;
Begin
  HashMD5(Result, Buf, BufSize);
End;

Function MD5Stream(Stream: TStream): TMD5Digest;
Var
  Context: TMD5Context;
  BufSize: Integer;
  FBuf: Array[0..1023] Of Byte;
Begin
  MD5Init(Context);
  BufSize := Stream.Read(FBuf, SizeOf(FBuf));
  While (BufSize > 0) Do
  Begin
    MD5Update(Context, FBuf, BufSize);
    BufSize := Stream.Read(FBuf, SizeOf(FBuf));
  End;
  MD5Final(Context, Result);
End;

Function MD5File(Const FileName: String): TMD5Digest;
Var
  FS: TFileStream;
Begin
  FS := TFileStream.Create(FileName, fmOpenRead Or fmShareDenyNone);
  Try
    Result := MD5Stream(FS);
  Finally
    FS.Free;
  End;
End;

Function MD5Print(Digest: TMD5Digest): String;
Begin
  Result := BufferToHex(Digest, SizeOf(Digest));
End;

Function MD5Match(D1, D2: TMD5Digest): Boolean;
Begin
  Result := CompareBuffers(D1, D2, SizeOf(D1));
End;
End.