home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 December / Chip_2002-12_cd1.bin / ctenari / Hytha / MultiHSH.exe / SR.RAR / SR / DCPCrypt / Hashes / DCPmd4.pas < prev    next >
Pascal/Delphi Source File  |  2002-07-08  |  9KB  |  234 lines
  1. {******************************************************************************}
  2. {* DCPcrypt v2.0 written by David Barton (crypto@cityinthesky.co.uk) **********}
  3. {******************************************************************************}
  4. {* A binary compatible implementation of MD4 **********************************}
  5. {******************************************************************************}
  6. {* Copyright (c) 1999-2002 David Barton                                       *}
  7. {* Permission is hereby granted, free of charge, to any person obtaining a    *}
  8. {* copy of this software and associated documentation files (the "Software"), *}
  9. {* to deal in the Software without restriction, including without limitation  *}
  10. {* the rights to use, copy, modify, merge, publish, distribute, sublicense,   *}
  11. {* and/or sell copies of the Software, and to permit persons to whom the      *}
  12. {* Software is furnished to do so, subject to the following conditions:       *}
  13. {*                                                                            *}
  14. {* The above copyright notice and this permission notice shall be included in *}
  15. {* all copies or substantial portions of the Software.                        *}
  16. {*                                                                            *}
  17. {* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *}
  18. {* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *}
  19. {* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *}
  20. {* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *}
  21. {* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING    *}
  22. {* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER        *}
  23. {* DEALINGS IN THE SOFTWARE.                                                  *}
  24. {******************************************************************************}
  25. unit DCPmd4;
  26.  
  27. interface
  28. uses
  29.   Classes, Sysutils, DCPcrypt2, DCPconst;
  30.  
  31. type
  32.   TDCP_md4= class(TDCP_hash)
  33.   protected
  34.     LenHi, LenLo: longword;
  35.     Index: DWord;
  36.     CurrentHash: array[0..3] of DWord;
  37.     HashBuffer: array[0..63] of byte;
  38.     procedure Compress;
  39.   public
  40.     class function GetId: integer; override;
  41.     class function GetAlgorithm: string; override;
  42.     class function GetHashSize: integer; override;
  43.     class function SelfTest: boolean; override;
  44.     procedure Init; override;
  45.     procedure Burn; override;
  46.     procedure Update(const Buffer; Size: longword); override;
  47.     procedure Final(var Digest); override;
  48.   end;
  49.  
  50.  
  51.  
  52. {******************************************************************************}
  53. {******************************************************************************}
  54. implementation
  55. {$R-}{$Q-}
  56.  
  57. function LRot32(a, b: longword): longword;
  58. begin
  59.   Result:= (a shl b) or (a shr (32-b));
  60. end;
  61.  
  62. procedure TDCP_md4.Compress;
  63. var
  64.   Data: array[0..15] of dword;
  65.   A, B, C, D: dword;
  66. begin
  67.   Move(HashBuffer,Data,Sizeof(Data));
  68.   A:= CurrentHash[0];
  69.   B:= CurrentHash[1];
  70.   C:= CurrentHash[2];
  71.   D:= CurrentHash[3];
  72.  
  73.   A:= LRot32(A + (D xor (B and (C xor D))) + Data[ 0],3);
  74.   D:= LRot32(D + (C xor (A and (B xor C))) + Data[ 1],7);
  75.   C:= LRot32(C + (B xor (D and (A xor B))) + Data[ 2],11);
  76.   B:= LRot32(B + (A xor (C and (D xor A))) + Data[ 3],19);
  77.   A:= LRot32(A + (D xor (B and (C xor D))) + Data[ 4],3);
  78.   D:= LRot32(D + (C xor (A and (B xor C))) + Data[ 5],7);
  79.   C:= LRot32(C + (B xor (D and (A xor B))) + Data[ 6],11);
  80.   B:= LRot32(B + (A xor (C and (D xor A))) + Data[ 7],19);
  81.   A:= LRot32(A + (D xor (B and (C xor D))) + Data[ 8],3);
  82.   D:= LRot32(D + (C xor (A and (B xor C))) + Data[ 9],7);
  83.   C:= LRot32(C + (B xor (D and (A xor B))) + Data[10],11);
  84.   B:= LRot32(B + (A xor (C and (D xor A))) + Data[11],19);
  85.   A:= LRot32(A + (D xor (B and (C xor D))) + Data[12],3);
  86.   D:= LRot32(D + (C xor (A and (B xor C))) + Data[13],7);
  87.   C:= LRot32(C + (B xor (D and (A xor B))) + Data[14],11);
  88.   B:= LRot32(B + (A xor (C and (D xor A))) + Data[15],19);
  89.  
  90.   A:= LRot32(A + ((B and C) or (B and D) or (C and D)) + Data[ 0] + $5a827999,3);
  91.   D:= LRot32(D + ((A and B) or (A and C) or (B and C)) + Data[ 4] + $5a827999,5);
  92.   C:= LRot32(C + ((D and A) or (D and B) or (A and B)) + Data[ 8] + $5a827999,9);
  93.   B:= LRot32(B + ((C and D) or (C and A) or (D and A)) + Data[12] + $5a827999,13);
  94.   A:= LRot32(A + ((B and C) or (B and D) or (C and D)) + Data[ 1] + $5a827999,3);
  95.   D:= LRot32(D + ((A and B) or (A and C) or (B and C)) + Data[ 5] + $5a827999,5);
  96.   C:= LRot32(C + ((D and A) or (D and B) or (A and B)) + Data[ 9] + $5a827999,9);
  97.   B:= LRot32(B + ((C and D) or (C and A) or (D and A)) + Data[13] + $5a827999,13);
  98.   A:= LRot32(A + ((B and C) or (B and D) or (C and D)) + Data[ 2] + $5a827999,3);
  99.   D:= LRot32(D + ((A and B) or (A and C) or (B and C)) + Data[ 6] + $5a827999,5);
  100.   C:= LRot32(C + ((D and A) or (D and B) or (A and B)) + Data[10] + $5a827999,9);
  101.   B:= LRot32(B + ((C and D) or (C and A) or (D and A)) + Data[14] + $5a827999,13);
  102.   A:= LRot32(A + ((B and C) or (B and D) or (C and D)) + Data[ 3] + $5a827999,3);
  103.   D:= LRot32(D + ((A and B) or (A and C) or (B and C)) + Data[ 7] + $5a827999,5);
  104.   C:= LRot32(C + ((D and A) or (D and B) or (A and B)) + Data[11] + $5a827999,9);
  105.   B:= LRot32(B + ((C and D) or (C and A) or (D and A)) + Data[15] + $5a827999,13);
  106.  
  107.   A:= LRot32(A + (B xor C xor D) + Data[ 0] + $6ed9eba1,3);
  108.   D:= LRot32(D + (A xor B xor C) + Data[ 8] + $6ed9eba1,9);
  109.   C:= LRot32(C + (D xor A xor B) + Data[ 4] + $6ed9eba1,11);
  110.   B:= LRot32(B + (C xor D xor A) + Data[12] + $6ed9eba1,15);
  111.   A:= LRot32(A + (B xor C xor D) + Data[ 2] + $6ed9eba1,3);
  112.   D:= LRot32(D + (A xor B xor C) + Data[10] + $6ed9eba1,9);
  113.   C:= LRot32(C + (D xor A xor B) + Data[ 6] + $6ed9eba1,11);
  114.   B:= LRot32(B + (C xor D xor A) + Data[14] + $6ed9eba1,15);
  115.   A:= LRot32(A + (B xor C xor D) + Data[ 1] + $6ed9eba1,3);
  116.   D:= LRot32(D + (A xor B xor C) + Data[ 9] + $6ed9eba1,9);
  117.   C:= LRot32(C + (D xor A xor B) + Data[ 5] + $6ed9eba1,11);
  118.   B:= LRot32(B + (C xor D xor A) + Data[13] + $6ed9eba1,15);
  119.   A:= LRot32(A + (B xor C xor D) + Data[ 3] + $6ed9eba1,3);
  120.   D:= LRot32(D + (A xor B xor C) + Data[11] + $6ed9eba1,9);
  121.   C:= LRot32(C + (D xor A xor B) + Data[ 7] + $6ed9eba1,11);
  122.   B:= LRot32(B + (C xor D xor A) + Data[15] + $6ed9eba1,15);
  123.  
  124.   Inc(CurrentHash[0],A);
  125.   Inc(CurrentHash[1],B);
  126.   Inc(CurrentHash[2],C);
  127.   Inc(CurrentHash[3],D);
  128.   Index:= 0;
  129.   FillChar(HashBuffer,Sizeof(HashBuffer),0);
  130. end;
  131.  
  132. class function TDCP_md4.GetHashSize: integer;
  133. begin
  134.   Result:= 128;
  135. end;
  136.  
  137. class function TDCP_md4.GetId: integer;
  138. begin
  139.   Result:= DCP_md4;
  140. end;
  141.  
  142. class function TDCP_md4.GetAlgorithm: string;
  143. begin
  144.   Result:= 'MD4';
  145. end;
  146.  
  147. class function TDCP_md4.SelfTest: boolean;
  148. const
  149.   Test1Out: array[0..15] of byte=
  150.     ($a4,$48,$01,$7a,$af,$21,$d8,$52,$5f,$c1,$0a,$e8,$7a,$a6,$72,$9d);
  151.   Test2Out: array[0..15] of byte=
  152.     ($d7,$9e,$1c,$30,$8a,$a5,$bb,$cd,$ee,$a8,$ed,$63,$df,$41,$2d,$a9);
  153. var
  154.   TestHash: TDCP_md4;
  155.   TestOut: array[0..19] of byte;
  156. begin
  157.   TestHash:= TDCP_md4.Create(nil);
  158.   TestHash.Init;
  159.   TestHash.UpdateStr('abc');
  160.   TestHash.Final(TestOut);
  161.   Result:= CompareMem(@TestOut,@Test1Out,Sizeof(Test1Out));
  162.   TestHash.Init;
  163.   TestHash.UpdateStr('abcdefghijklmnopqrstuvwxyz');
  164.   TestHash.Final(TestOut);
  165.   Result:= CompareMem(@TestOut,@Test2Out,Sizeof(Test2Out)) and Result;
  166.   TestHash.Free;
  167. end;
  168.  
  169. procedure TDCP_md4.Init;
  170. begin
  171.   Burn;
  172.   CurrentHash[0]:= $67452301;
  173.   CurrentHash[1]:= $efcdab89;
  174.   CurrentHash[2]:= $98badcfe;
  175.   CurrentHash[3]:= $10325476;
  176.   fInitialized:= true;
  177. end;
  178.  
  179. procedure TDCP_md4.Burn;
  180. begin
  181.   LenHi:= 0; LenLo:= 0;
  182.   Index:= 0;
  183.   FillChar(HashBuffer,Sizeof(HashBuffer),0);
  184.   FillChar(CurrentHash,Sizeof(CurrentHash),0);
  185.   fInitialized:= false;
  186. end;
  187.  
  188. procedure TDCP_md4.Update(const Buffer; Size: longword);
  189. var
  190.   PBuf: ^byte;
  191. begin
  192.   if not fInitialized then
  193.     raise EDCP_hash.Create('Hash not initialized');
  194.  
  195.   Inc(LenHi,Size shr 29);
  196.   Inc(LenLo,Size*8);
  197.   if LenLo< (Size*8) then
  198.     Inc(LenHi);
  199.  
  200.   PBuf:= @Buffer;
  201.   while Size> 0 do
  202.   begin
  203.     if (Sizeof(HashBuffer)-Index)<= DWord(Size) then
  204.     begin
  205.       Move(PBuf^,HashBuffer[Index],Sizeof(HashBuffer)-Index);
  206.       Dec(Size,Sizeof(HashBuffer)-Index);
  207.       Inc(PBuf,Sizeof(HashBuffer)-Index);
  208.       Compress;
  209.     end
  210.     else
  211.     begin
  212.       Move(PBuf^,HashBuffer[Index],Size);
  213.       Inc(Index,Size);
  214.       Size:= 0;
  215.     end;
  216.   end;
  217. end;
  218.  
  219. procedure TDCP_md4.Final(var Digest);
  220. begin
  221.   if not fInitialized then
  222.     raise EDCP_hash.Create('Hash not initialized');
  223.   HashBuffer[Index]:= $80;
  224.   if Index>= 56 then
  225.     Compress;
  226.   PDWord(@HashBuffer[56])^:= LenLo;
  227.   PDWord(@HashBuffer[60])^:= LenHi;
  228.   Compress;
  229.   Move(CurrentHash,Digest,Sizeof(CurrentHash));
  230.   Burn;
  231. end;
  232.  
  233. end.
  234.