md5.pas

一个delphi中可以用的MD5类,并且附带使用这个类的例子程序.

unit md5;
{
   MD5??????

   ??:??
   ??:2003.3.10

}
interface

type
  TIntData = array of Integer;

  TMd5Digest = class(TObject)
    protected
      function Add(X, Y: Integer): Integer;
      function Rol(X, n: Integer): Integer;
      function Cmn(q, a, b, x, s, t: Integer): Integer;
      function Cvt(S: String): TIntData;
      function rHex(X: Integer): String; 
      function ff(a, b, c, d, x, s, t: Integer): Integer;
      function gg(a, b, c, d, x, s, t: Integer): Integer;
      function hh(a, b, c, d, x, s, t: Integer): Integer;
      function ii(a, b, c, d, x, s, t: Integer): Integer;

    public
      function Md5(S: String): String;

    published

  end;


implementation

{ TMd5Digest }

function TMd5Digest.Add(X, Y: Integer): Integer;
var
  lsw, msw: Integer;
begin
  // ?????????
  // ??????,? 2^32 ??. This uses 16-bit operations internally
  //to work around bugs in some JS interpreters.
  lsw := (X and $ffff) + (Y and $ffff);
  msw := (X shr 16) + (Y shr 16) + (lsw shr 16);
  Result := (msw shl 16) or (lsw and $ffff);
end;

function TMd5Digest.Cmn(q, a, b, x, s, t: Integer): Integer;
begin
  Result := Add(Rol(Add(Add(a, q), Add(x, t)), s), b);
end;

function TMd5Digest.Cvt(S: String): TIntData;
var
  nblk: Integer;
  len, i: Integer;
begin
  len := Length(S);
  nblk := ((len + 8) shr 6) + 1;
  SetLength(Result, nblk * 16);
  for i := 0 to (nblk * 16 - 1) do Result[i] := 0;
  for i := 0 to len - 1 do
    Result[i shr 2] := Result[i shr 2] or
      (Ord(S[i + 1]) shl ((i mod 4) * 8));
  Result[len shr 2] := Result[len shr 2] or
    ($80 shl ((len mod 4) * 8));
  Result[nblk * 16 - 2] := len * 8;
end;

function TMd5Digest.ff(a, b, c, d, x, s, t: Integer): Integer;
begin
  Result := Cmn((b and c) or (not b and d), a, b, x, s, t);
end;

function TMd5Digest.gg(a, b, c, d, x, s, t: Integer): Integer;
begin
  Result := Cmn((b and d) or (c and not d), a, b, x, s, t);
end;

function TMd5Digest.hh(a, b, c, d, x, s, t: Integer): Integer;
begin
  Result := Cmn(b xor c xor d, a, b, x, s, t);
end;

function TMd5Digest.ii(a, b, c, d, x, s, t: Integer): Integer;
begin
  Result := Cmn(c xor (b or not d), a, b, x, s, t);
end;

function TMd5Digest.Md5(S: String): String;
var
  x: TIntData;
  a, b, c, d: Integer;
  olda, oldb, oldc, oldd: Integer;
  len, i: Integer;
begin
  x := Cvt(S);
  len := Length(x);
  a :=  1732584193;
  b := -271733879;
  c := -1732584194;
  d :=  271733878;

  i := 0;
  while i < len do begin
    olda := a;
    oldb := b;
    oldc := c;
    oldd := d;

    a := ff(a, b, c, d, x[i+ 0], 7 , -680876936);
    d := ff(d, a, b, c, x[i+ 1], 12, -389564586);
    c := ff(c, d, a, b, x[i+ 2], 17,  606105819);
    b := ff(b, c, d, a, x[i+ 3], 22, -1044525330);
    a := ff(a, b, c, d, x[i+ 4], 7 , -176418897);
    d := ff(d, a, b, c, x[i+ 5], 12,  1200080426);
    c := ff(c, d, a, b, x[i+ 6], 17, -1473231341);
    b := ff(b, c, d, a, x[i+ 7], 22, -45705983);
    a := ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
    d := ff(d, a, b, c, x[i+ 9], 12, -1958414417);
    c := ff(c, d, a, b, x[i+10], 17, -42063);
    b := ff(b, c, d, a, x[i+11], 22, -1990404162);
    a := ff(a, b, c, d, x[i+12], 7 ,  1804603682);
    d := ff(d, a, b, c, x[i+13], 12, -40341101);
    c := ff(c, d, a, b, x[i+14], 17, -1502002290);
    b := ff(b, c, d, a, x[i+15], 22,  1236535329);

    a := gg(a, b, c, d, x[i+ 1], 5 , -165796510);
    d := gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
    c := gg(c, d, a, b, x[i+11], 14,  643717713);
    b := gg(b, c, d, a, x[i+ 0], 20, -373897302);
    a := gg(a, b, c, d, x[i+ 5], 5 , -701558691);
    d := gg(d, a, b, c, x[i+10], 9 ,  38016083);
    c := gg(c, d, a, b, x[i+15], 14, -660478335);
    b := gg(b, c, d, a, x[i+ 4], 20, -405537848);
    a := gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
    d := gg(d, a, b, c, x[i+14], 9 , -1019803690);
    c := gg(c, d, a, b, x[i+ 3], 14, -187363961);
    b := gg(b, c, d, a, x[i+ 8], 20,  1163531501);
    a := gg(a, b, c, d, x[i+13], 5 , -1444681467);
    d := gg(d, a, b, c, x[i+ 2], 9 , -51403784);
    c := gg(c, d, a, b, x[i+ 7], 14,  1735328473);
    b := gg(b, c, d, a, x[i+12], 20, -1926607734);

    a := hh(a, b, c, d, x[i+ 5], 4 , -378558);
    d := hh(d, a, b, c, x[i+ 8], 11, -2022574463);
    c := hh(c, d, a, b, x[i+11], 16,  1839030562);
    b := hh(b, c, d, a, x[i+14], 23, -35309556);
    a := hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
    d := hh(d, a, b, c, x[i+ 4], 11,  1272893353);
    c := hh(c, d, a, b, x[i+ 7], 16, -155497632);
    b := hh(b, c, d, a, x[i+10], 23, -1094730640);
    a := hh(a, b, c, d, x[i+13], 4 ,  681279174);
    d := hh(d, a, b, c, x[i+ 0], 11, -358537222);
    c := hh(c, d, a, b, x[i+ 3], 16, -722521979);
    b := hh(b, c, d, a, x[i+ 6], 23,  76029189);
    a := hh(a, b, c, d, x[i+ 9], 4 , -640364487);
    d := hh(d, a, b, c, x[i+12], 11, -421815835);
    c := hh(c, d, a, b, x[i+15], 16,  530742520);
    b := hh(b, c, d, a, x[i+ 2], 23, -995338651);

    a := ii(a, b, c, d, x[i+ 0], 6 , -198630844);
    d := ii(d, a, b, c, x[i+ 7], 10,  1126891415);
    c := ii(c, d, a, b, x[i+14], 15, -1416354905);
    b := ii(b, c, d, a, x[i+ 5], 21, -57434055);
    a := ii(a, b, c, d, x[i+12], 6 ,  1700485571);
    d := ii(d, a, b, c, x[i+ 3], 10, -1894986606);
    c := ii(c, d, a, b, x[i+10], 15, -1051523);
    b := ii(b, c, d, a, x[i+ 1], 21, -2054922799);
    a := ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
    d := ii(d, a, b, c, x[i+15], 10, -30611744);
    c := ii(c, d, a, b, x[i+ 6], 15, -1560198380);
    b := ii(b, c, d, a, x[i+13], 21,  1309151649);
    a := ii(a, b, c, d, x[i+ 4], 6 , -145523070);
    d := ii(d, a, b, c, x[i+11], 10, -1120210379);
    c := ii(c, d, a, b, x[i+ 2], 15,  718787259);
    b := ii(b, c, d, a, x[i+ 9], 21, -343485551);

    a := add(a, olda);
    b := add(b, oldb);
    c := add(c, oldc);
    d := add(d, oldd);
    i := i + 16;
  end;
  Result := rHex(a) + rHex(b) + rHex(c) + rHex(d);
end;

function TMd5Digest.rHex(X: Integer): String;
const
  HexChs: String = '0123456789abcdef';
var
  i: Integer;
begin
  SetLength(Result, 8);
  //for i := 1 to 8 do
  //  Result[i] := HexChs[(X shr ((8 - i) shl 2)) and $f + 1];
  //???16????????IntToHex???
  for i := 0 to 3 do begin
    Result[i * 2 + 1] := HexChs[(X shr (i * 8 + 4)) and $f + 1];
    Result[i * 2 + 2] := HexChs[(X shr (i * 8)) and $f + 1];
  end;
end;

function TMd5Digest.Rol(X, n: Integer): Integer;
begin
  //Bitwise rotate a 32-bit number to the left
  Result := (X shl n) or (X shr (32 - n));
end;

end.