home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 December / Chip_2002-12_cd1.bin / ctenari / Hytha / MultiHSH.exe / SR.RAR / SR / DCPCrypt / Ciphers / DCPrc2.pas < prev    next >
Pascal/Delphi Source File  |  2002-07-08  |  7KB  |  188 lines
  1. {******************************************************************************}
  2. {* DCPcrypt v2.0 written by David Barton (crypto@cityinthesky.co.uk) **********}
  3. {******************************************************************************}
  4. {* A binary compatible implementation of RC2 **********************************}
  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 DCPrc2;
  26.  
  27. interface
  28. uses
  29.   Classes, Sysutils, DCPcrypt2, DCPconst, DCPblockciphers;
  30.  
  31. type
  32.   TDCP_rc2= class(TDCP_blockcipher64)
  33.   protected
  34.     KeyData: array[0..63] of word;
  35.     procedure InitKey(const Key; Size: longword); override;
  36.   public
  37.     class function GetID: integer; override;
  38.     class function GetAlgorithm: string; override;
  39.     class function GetMaxKeySize: integer; override;
  40.     class function SelfTest: boolean; override;
  41.     procedure Burn; override;
  42.     procedure EncryptECB(const InData; var OutData); override;
  43.     procedure DecryptECB(const InData; var OutData); override;
  44.   end;
  45.  
  46.  
  47. {******************************************************************************}
  48. {******************************************************************************}
  49. implementation
  50. {$R-}{$Q-}
  51.  
  52. {$I DCPrc2.inc}
  53.  
  54. function LRot16(a, n: word): word;
  55. begin
  56.   Result:= (a shl n) or (a shr (16-n));
  57. end;
  58.  
  59. function RRot16(a, n: word): word;
  60. begin
  61.   Result:= (a shr n) or (a shl (16-n));
  62. end;
  63.  
  64. class function TDCP_rc2.GetMaxKeySize: integer;
  65. begin
  66.   Result:= 1024;
  67. end;
  68.  
  69. class function TDCP_rc2.GetID: integer;
  70. begin
  71.   Result:= DCP_rc2;
  72. end;
  73.  
  74. class function TDCP_rc2.GetAlgorithm: string;
  75. begin
  76.   Result:= 'RC2';
  77. end;
  78.  
  79. class function TDCP_rc2.SelfTest: boolean;
  80. const
  81.   Key1: array[0..15] of byte=
  82.     ($00,$01,$02,$03,$04,$05,$06,$07,$08,$09,$0A,$0B,$0C,$0D,$0E,$0F);
  83.   InData1: array[0..7] of byte=
  84.     ($00,$00,$00,$00,$00,$00,$00,$00);
  85.   OutData1: array[0..7] of byte=
  86.     ($50,$DC,$01,$62,$BD,$75,$7F,$31);
  87.   Key2: array[0..15] of byte=
  88.     ($00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01);
  89.   InData2: array[0..7] of byte=
  90.     ($00,$00,$00,$00,$00,$00,$00,$00);
  91.   OutData2: array[0..7] of byte=
  92.     ($21,$82,$9C,$78,$A9,$F9,$C0,$74);
  93. var
  94.   Cipher: TDCP_rc2;
  95.   Data: array[0..7] of byte;
  96. begin
  97.   Cipher:= TDCP_rc2.Create(nil);
  98.   Cipher.Init(Key1,Sizeof(Key1)*8,nil);
  99.   Cipher.EncryptECB(InData1,Data);
  100.   Result:= boolean(CompareMem(@Data,@OutData1,Sizeof(Data)));
  101.   Cipher.DecryptECB(Data,Data);
  102.   Result:= boolean(CompareMem(@Data,@InData1,Sizeof(Data))) and Result;
  103.   Cipher.Burn;
  104.   Cipher.Init(Key2,Sizeof(Key2)*8,nil);
  105.   Cipher.EncryptECB(InData2,Data);
  106.   Result:= boolean(CompareMem(@Data,@OutData2,Sizeof(Data))) and Result;
  107.   Cipher.DecryptECB(Data,Data);
  108.   Result:= boolean(CompareMem(@Data,@InData2,Sizeof(Data))) and Result;
  109.   Cipher.Burn;
  110.   Cipher.Free;
  111. end;
  112.  
  113. procedure TDCP_rc2.InitKey(const Key; Size: longword);
  114. var
  115.   i: longword;
  116.   KeyB: array[0..127] of byte;
  117. begin
  118.   Move(Key,KeyB,Size div 8);
  119.   for i:= (Size div 8) to 127 do
  120.     KeyB[i]:= sBox[(KeyB[i-(Size div 8)]+KeyB[i-1]) and $FF];
  121.   KeyB[0]:= sBox[KeyB[0]];
  122.   Move(KeyB,KeyData,Sizeof(KeyData));
  123. end;
  124.  
  125. procedure TDCP_rc2.Burn;
  126. begin
  127.   FillChar(KeyData,Sizeof(KeyData),0);
  128.   inherited Burn;
  129. end;
  130.  
  131. procedure TDCP_rc2.EncryptECB(const InData; var OutData);
  132. var
  133.   i, j: longword;
  134.   w: array[0..3] of word;
  135. begin
  136.   if not fInitialized then
  137.     raise EDCP_blockcipher.Create('Cipher not initialized');
  138.   Pdword(@w[0])^:= Pdword(@InData)^;
  139.   Pdword(@w[2])^:= Pdword(longword(@InData)+4)^;
  140.   for i:= 0 to 15 do
  141.   begin
  142.     j:= i*4;
  143.     w[0]:= LRot16((w[0]+(w[1] and (not w[3]))+(w[2] and w[3])+KeyData[j+0]),1);
  144.     w[1]:= LRot16((w[1]+(w[2] and (not w[0]))+(w[3] and w[0])+KeyData[j+1]),2);
  145.     w[2]:= LRot16((w[2]+(w[3] and (not w[1]))+(w[0] and w[1])+KeyData[j+2]),3);
  146.     w[3]:= LRot16((w[3]+(w[0] and (not w[2]))+(w[1] and w[2])+KeyData[j+3]),5);
  147.     if (i= 4) or (i= 10) then
  148.     begin
  149.       w[0]:= w[0]+KeyData[w[3] and 63];
  150.       w[1]:= w[1]+KeyData[w[0] and 63];
  151.       w[2]:= w[2]+KeyData[w[1] and 63];
  152.       w[3]:= w[3]+KeyData[w[2] and 63];
  153.     end;
  154.   end;
  155.   Pdword(@OutData)^:= Pdword(@w[0])^;
  156.   Pdword(longword(@OutData)+4)^:= Pdword(@w[2])^;
  157. end;
  158.  
  159. procedure TDCP_rc2.DecryptECB(const InData; var OutData);
  160. var
  161.   i, j: longword;
  162.   w: array[0..3] of word;
  163. begin
  164.   if not fInitialized then
  165.     raise EDCP_blockcipher.Create('Cipher not initialized');
  166.   Pdword(@w[0])^:= Pdword(@InData)^;
  167.   Pdword(@w[2])^:= Pdword(longword(@InData)+4)^;
  168.   for i:= 15 downto 0 do
  169.   begin
  170.     j:= i*4;
  171.     w[3]:= RRot16(w[3],5)-(w[0] and (not w[2]))-(w[1] and w[2])-KeyData[j+3];
  172.     w[2]:= RRot16(w[2],3)-(w[3] and (not w[1]))-(w[0] and w[1])-KeyData[j+2];
  173.     w[1]:= RRot16(w[1],2)-(w[2] and (not w[0]))-(w[3] and w[0])-KeyData[j+1];
  174.     w[0]:= RRot16(w[0],1)-(w[1] and (not w[3]))-(w[2] and w[3])-KeyData[j+0];
  175.     if (i= 5) or (i= 11) then
  176.     begin
  177.       w[3]:= w[3]-KeyData[w[2] and 63];
  178.       w[2]:= w[2]-KeyData[w[1] and 63];
  179.       w[1]:= w[1]-KeyData[w[0] and 63];
  180.       w[0]:= w[0]-KeyData[w[3] and 63];
  181.     end;
  182.   end;
  183.   Pdword(@OutData)^:= Pdword(@w[0])^;
  184.   Pdword(longword(@OutData)+4)^:= Pdword(@w[2])^;
  185. end;
  186.  
  187. end. 
  188.