delphi 64位MD5算法

看到网上有人说indy的md5在64位下计算结果与32位下不一致。我测试了一下，确实如此，因此把自己用的64位计算结果正确的md5函数代码发出来。

说明1：这个单元的代码是从indy的md5代码修改而来的。

说明2：计算TBytes和String的MD5值可以使用TBytesStream或TStringStream。

说明3：计算结果转换为HEX字符的代码请自行编写。

 

unit BambooMD5;

interface

uses
  SysUtils,
  Classes;

function BambooMD5Stream(aStream: TStream): TBytes;

implementation

uses
  Math;

type
  T4x4LongWordRecord = array [0 .. 3] of LongWord;
  T16x4LongWordRecord = array [0 .. 15] of LongWord;

function ROL(const AVal: LongWord; AShift: Byte): LongWord; assembler;
asm
  {$IFDEF CPUX64}
  mov  eax, ecx
  {$ELSE}
  {$ENDIF !CPUX64}
  mov  cl, dl
  rol  eax, cl
end;

const
  MD4_INIT_VALUES: T4x4LongWordRecord = ($67452301, $EFCDAB89, $98BADCFE, $10325476);

  MD5_SINE: array [1 .. 64] of LongWord = (
    { Round 1. }
    $D76AA478, $E8C7B756, $242070DB, $C1BDCEEE, $F57C0FAF, $4787C62A, $A8304613, $FD469501, $698098D8, $8B44F7AF, $FFFF5BB1, $895CD7BE, $6B901122, $FD987193, $A679438E, $49B40821,
    { Round 2. }
    $F61E2562, $C040B340, $265E5A51, $E9B6C7AA, $D62F105D, $02441453, $D8A1E681, $E7D3FBC8, $21E1CDE6, $C33707D6, $F4D50D87, $455A14ED, $A9E3E905, $FCEFA3F8, $676F02D9, $8D2A4C8A,
    { Round 3. }
    $FFFA3942, $8771F681, $6D9D6122, $FDE5380C, $A4BEEA44, $4BDECFA9, $F6BB4B60, $BEBFBC70, $289B7EC6, $EAA127FA, $D4EF3085, $04881D05, $D9D4D039, $E6DB99E5, $1FA27CF8, $C4AC5665,
    { Round 4. }
    $F4292244, $432AFF97, $AB9423A7, $FC93A039, $655B59C3, $8F0CCC92, $FFEFF47D, $85845DD1, $6FA87E4F, $FE2CE6E0, $A3014314, $4E0811A1, $F7537E82, $BD3AF235, $2AD7D2BB, $EB86D391);
{$Q-}

procedure MDCoder(const FCBuffer: TBytes; var FState: T4x4LongWordRecord);
var
  A, B, C, D: LongWord;
  i: Integer;
  X: T16x4LongWordRecord;
begin
  A := FState[0];
  B := FState[1];
  C := FState[2];
  D := FState[3];

  for i := 0 to 15 do
  begin
    X[i] := FCBuffer[i * 4 + 0] + (FCBuffer[i * 4 + 1] shl 8) + (FCBuffer[i * 4 + 2] shl 16) + (FCBuffer[i * 4 + 3] shl 24);
  end;
  { Round 1 }
  A := ROL(A + (((D xor C) and B) xor D) + X[0] + MD5_SINE[1], 7) + B;
  D := ROL(D + (((C xor B) and A) xor C) + X[1] + MD5_SINE[2], 12) + A;
  C := ROL(C + (((B xor A) and D) xor B) + X[2] + MD5_SINE[3], 17) + D;
  B := ROL(B + (((A xor D) and C) xor A) + X[3] + MD5_SINE[4], 22) + C;
  A := ROL(A + (((D xor C) and B) xor D) + X[4] + MD5_SINE[5], 7) + B;
  D := ROL(D + (((C xor B) and A) xor C) + X[5] + MD5_SINE[6], 12) + A;
  C := ROL(C + (((B xor A) and D) xor B) + X[6] + MD5_SINE[7], 17) + D;
  B := ROL(B + (((A xor D) and C) xor A) + X[7] + MD5_SINE[8], 22) + C;
  A := ROL(A + (((D xor C) and B) xor D) + X[8] + MD5_SINE[9], 7) + B;
  D := ROL(D + (((C xor B) and A) xor C) + X[9] + MD5_SINE[10], 12) + A;
  C := ROL(C + (((B xor A) and D) xor B) + X[10] + MD5_SINE[11], 17) + D;
  B := ROL(B + (((A xor D) and C) xor A) + X[11] + MD5_SINE[12], 22) + C;
  A := ROL(A + (((D xor C) and B) xor D) + X[12] + MD5_SINE[13], 7) + B;
  D := ROL(D + (((C xor B) and A) xor C) + X[13] + MD5_SINE[14], 12) + A;
  C := ROL(C + (((B xor A) and D) xor B) + X[14] + MD5_SINE[15], 17) + D;
  B := ROL(B + (((A xor D) and C) xor A) + X[15] + MD5_SINE[16], 22) + C;

  { Round 2 }
  A := ROL(A + (C xor (D and (B xor C))) + X[1] + MD5_SINE[17], 5) + B;
  D := ROL(D + (B xor (C and (A xor B))) + X[6] + MD5_SINE[18], 9) + A;
  C := ROL(C + (A xor (B and (D xor A))) + X[11] + MD5_SINE[19], 14) + D;
  B := ROL(B + (D xor (A and (C xor D))) + X[0] + MD5_SINE[20], 20) + C;
  A := ROL(A + (C xor (D and (B xor C))) + X[5] + MD5_SINE[21], 5) + B;
  D := ROL(D + (B xor (C and (A xor B))) + X[10] + MD5_SINE[22], 9) + A;
  C := ROL(C + (A xor (B and (D xor A))) + X[15] + MD5_SINE[23], 14) + D;
  B := ROL(B + (D xor (A and (C xor D))) + X[4] + MD5_SINE[24], 20) + C;
  A := ROL(A + (C xor (D and (B xor C))) + X[9] + MD5_SINE[25], 5) + B;
  D := ROL(D + (B xor (C and (A xor B))) + X[14] + MD5_SINE[26], 9) + A;
  C := ROL(C + (A xor (B and (D xor A))) + X[3] + MD5_SINE[27], 14) + D;
  B := ROL(B + (D xor (A and (C xor D))) + X[8] + MD5_SINE[28], 20) + C;
  A := ROL(A + (C xor (D and (B xor C))) + X[13] + MD5_SINE[29], 5) + B;
  D := ROL(D + (B xor (C and (A xor B))) + X[2] + MD5_SINE[30], 9) + A;
  C := ROL(C + (A xor (B and (D xor A))) + X[7] + MD5_SINE[31], 14) + D;
  B := ROL(B + (D xor (A and (C xor D))) + X[12] + MD5_SINE[32], 20) + C;

  { Round 3. }
  A := ROL(A + (B xor C xor D) + X[5] + MD5_SINE[33], 4) + B;
  D := ROL(D + (A xor B xor C) + X[8] + MD5_SINE[34], 11) + A;
  C := ROL(C + (D xor A xor B) + X[11] + MD5_SINE[35], 16) + D;
  B := ROL(B + (C xor D xor A) + X[14] + MD5_SINE[36], 23) + C;
  A := ROL(A + (B xor C xor D) + X[1] + MD5_SINE[37], 4) + B;
  D := ROL(D + (A xor B xor C) + X[4] + MD5_SINE[38], 11) + A;
  C := ROL(C + (D xor A xor B) + X[7] + MD5_SINE[39], 16) + D;
  B := ROL(B + (C xor D xor A) + X[10] + MD5_SINE[40], 23) + C;
  A := ROL(A + (B xor C xor D) + X[13] + MD5_SINE[41], 4) + B;
  D := ROL(D + (A xor B xor C) + X[0] + MD5_SINE[42], 11) + A;
  C := ROL(C + (D xor A xor B) + X[3] + MD5_SINE[43], 16) + D;
  B := ROL(B + (C xor D xor A) + X[6] + MD5_SINE[44], 23) + C;
  A := ROL(A + (B xor C xor D) + X[9] + MD5_SINE[45], 4) + B;
  D := ROL(D + (A xor B xor C) + X[12] + MD5_SINE[46], 11) + A;
  C := ROL(C + (D xor A xor B) + X[15] + MD5_SINE[47], 16) + D;
  B := ROL(B + (C xor D xor A) + X[2] + MD5_SINE[48], 23) + C;

  { Round 4. }
  A := ROL(A + ((B or not D) xor C) + X[0] + MD5_SINE[49], 6) + B;
  D := ROL(D + ((A or not C) xor B) + X[7] + MD5_SINE[50], 10) + A;
  C := ROL(C + ((D or not B) xor A) + X[14] + MD5_SINE[51], 15) + D;
  B := ROL(B + ((C or not A) xor D) + X[5] + MD5_SINE[52], 21) + C;
  A := ROL(A + ((B or not D) xor C) + X[12] + MD5_SINE[53], 6) + B;
  D := ROL(D + ((A or not C) xor B) + X[3] + MD5_SINE[54], 10) + A;
  C := ROL(C + ((D or not B) xor A) + X[10] + MD5_SINE[55], 15) + D;
  B := ROL(B + ((C or not A) xor D) + X[1] + MD5_SINE[56], 21) + C;
  A := ROL(A + ((B or not D) xor C) + X[8] + MD5_SINE[57], 6) + B;
  D := ROL(D + ((A or not C) xor B) + X[15] + MD5_SINE[58], 10) + A;
  C := ROL(C + ((D or not B) xor A) + X[6] + MD5_SINE[59], 15) + D;
  B := ROL(B + ((C or not A) xor D) + X[13] + MD5_SINE[60], 21) + C;
  A := ROL(A + ((B or not D) xor C) + X[4] + MD5_SINE[61], 6) + B;
  D := ROL(D + ((A or not C) xor B) + X[11] + MD5_SINE[62], 10) + A;
  C := ROL(C + ((D or not B) xor A) + X[2] + MD5_SINE[63], 15) + D;
  B := ROL(B + ((C or not A) xor D) + X[9] + MD5_SINE[64], 21) + C;

  Inc(FState[0], A);
  Inc(FState[1], B);
  Inc(FState[2], C);
  Inc(FState[3], D);
end;
{$Q+}

function ReadTIdBytesFromStream(const aStream: TStream; var VBytes: TBytes; const ACount: Int64): Int64;
var
  LActual: Integer;
begin
  Assert(aStream <> nil);
  Result := 0;

  if VBytes = nil then
    SetLength(VBytes, 0);

  LActual := ACount;
  if LActual < 0 then
    LActual := aStream.Size - aStream.Position;

  if LActual = 0 then
    Exit;

  if Length(VBytes) < (LActual) then
    SetLength(VBytes, LActual);

  Assert(VBytes <> nil);
  Result := aStream.Read(VBytes[0], LActual);
end;

procedure CopyTIdLongWord(const ASource: LongWord; var VDest: TBytes; const ADestIndex: Integer);
begin
  PLongWord(@VDest[ADestIndex])^ := ASource;
end;

function GetHashBytes(aStream: TStream; ASize: Int64): TBytes;
var
  LStartPos: Integer;
  LSize: Int64;
  LBitSize: Int64;
  i, LReadSize: Integer;
  FState: T4x4LongWordRecord;
  FCBuffer: TBytes;
begin
  Result := nil;

  LSize := ASize;

  for i := 0 to 3 do
    FState[i] := MD4_INIT_VALUES[i];

  while LSize >= 64 do
  begin
    LReadSize := ReadTIdBytesFromStream(aStream, FCBuffer, 64);

    MDCoder(FCBuffer, FState);
    Dec(LSize, LReadSize);
  end;

  LStartPos := ReadTIdBytesFromStream(aStream, FCBuffer, 64);

  FCBuffer[LStartPos] := $80;
  Inc(LStartPos);

  if LStartPos > 56 then
  begin
    for i := LStartPos to 63 do
      FCBuffer[i] := 0;
    MDCoder(FCBuffer, FState);
    LStartPos := 0;
  end;

  for i := LStartPos to 55 do
    FCBuffer[i] := 0;

  LBitSize := ASize * 8;
  for i := 56 to 63 do
  begin
    FCBuffer[i] := LBitSize and $FF;
    LBitSize := LBitSize shr 8;
  end;
  MDCoder(FCBuffer, FState);

  SetLength(Result, SizeOf(LongWord) * 4);
  for i := 0 to 3 do
    CopyTIdLongWord(FState[i], Result, SizeOf(LongWord) * i);
end;

function Hash_Stream(aStream: TStream; const AStartPos, ASize: Int64): TBytes;
var
  LSize, LAvailable: Int64;
begin
  if AStartPos >= 0 then
    aStream.Position := AStartPos;
  LAvailable := aStream.Size - aStream.Position;
  if ASize < 0 then
    LSize := LAvailable
  else
    LSize := Min(LAvailable, ASize);
  Result := GetHashBytes(aStream, LSize);
end;

function BambooMD5Stream(aStream: TStream): TBytes;
begin
  if aStream = nil then
  begin
    Result := nil;
    Exit;
  end;
  aStream.Position := 0;
  Result := Hash_Stream(aStream, -1, -1);
end;

end.