home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 December / Chip_2002-12_cd1.bin / ctenari / Hytha / MultiHSH.exe / SR.RAR / SR / DCPCrypt / Ciphers / DCPrc4.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  2002-07-08  |  6.8 KB  |  210 lines
  1. {******************************************************************************}
  2. {* DCPcrypt v2.0 written by David Barton (crypto@cityinthesky.co.uk) **********}
  3. {******************************************************************************}
  4. {* A binary compatible implementation of RC4 **********************************}
  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 DCPrc4;
  26.  
  27. interface
  28. uses
  29.   Classes, Sysutils, DCPcrypt2, DCPconst;
  30.  
  31. type
  32.   TDCP_rc4= class(TDCP_cipher)
  33.   protected
  34.     KeyData, KeyOrg: array[0..255] of byte;
  35.   public
  36.     class function GetID: integer; override;
  37.     class function GetAlgorithm: string; override;
  38.     class function GetMaxKeySize: integer; override;
  39.     class function SelfTest: boolean; override;
  40.     procedure Init(const Key; Size: longword; InitVector: pointer); override;
  41.     procedure Reset; override;
  42.     procedure Burn; override;
  43.     procedure Encrypt(const InData; var OutData; Size: longword); override;
  44.     procedure Decrypt(const InData; var OutData; Size: longword); override;
  45.   end;
  46.  
  47. {******************************************************************************}
  48. {******************************************************************************}
  49. implementation
  50. {$R-}{$Q-}
  51.  
  52. class function TDCP_rc4.GetID: integer;
  53. begin
  54.   Result:= DCP_rc4;
  55. end;
  56.  
  57. class function TDCP_rc4.GetAlgorithm: string;
  58. begin
  59.   Result:= 'RC4';
  60. end;
  61.  
  62. class function TDCP_rc4.GetMaxKeySize: integer;
  63. begin
  64.   Result:= 2048;
  65. end;
  66.  
  67. class function TDCP_rc4.SelfTest: boolean;
  68. const
  69.   Key1: array[0..4] of byte= ($61,$8A,$63,$D2,$FB);
  70.   InData1: array[0..4] of byte= ($DC,$EE,$4C,$F9,$2C);
  71.   OutData1: array[0..4] of byte= ($F1,$38,$29,$C9,$DE);
  72. var
  73.   Cipher: TDCP_rc4;
  74.   Data: array[0..4] of byte;
  75. begin
  76.   Cipher:= TDCP_rc4.Create(nil);
  77.   Cipher.Init(Key1,Sizeof(Key1)*8,nil);
  78.   Cipher.Encrypt(InData1,Data,Sizeof(Data));
  79.   Result:= boolean(CompareMem(@Data,@OutData1,Sizeof(Data)));
  80.   Cipher.Reset;
  81.   Cipher.Decrypt(Data,Data,Sizeof(Data));
  82.   Result:= boolean(CompareMem(@Data,@InData1,Sizeof(Data))) and Result;
  83.   Cipher.Burn;
  84.   Cipher.Free;
  85. end;
  86.  
  87. procedure TDCP_rc4.Init(const Key; Size: longword; InitVector: pointer);
  88. var
  89.   i, j, t: longword;
  90.   xKey: array[0..255] of byte;
  91. begin
  92.   if fInitialized then
  93.     Burn;
  94.   inherited Init(Key,Size,nil);
  95.   Size:= Size div 8;
  96.   i:= 0;
  97.   while i< 255 do
  98.   begin
  99.     KeyData[i]:= i;
  100.     xKey[i]:= PByte(longword(@Key)+(i mod Size))^;
  101.     KeyData[i+1]:= i+1;
  102.     xKey[i+1]:= PByte(longword(@Key)+((i+1) mod Size))^;
  103.     KeyData[i+2]:= i+2;
  104.     xKey[i+2]:= PByte(longword(@Key)+((i+2) mod Size))^;
  105.     KeyData[i+3]:= i+3;
  106.     xKey[i+3]:= PByte(longword(@Key)+((i+3) mod Size))^;
  107.     KeyData[i+4]:= i+4;
  108.     xKey[i+4]:= PByte(longword(@Key)+((i+4) mod Size))^;
  109.     KeyData[i+5]:= i+5;
  110.     xKey[i+5]:= PByte(longword(@Key)+((i+5) mod Size))^;
  111.     KeyData[i+6]:= i+6;
  112.     xKey[i+6]:= PByte(longword(@Key)+((i+6) mod Size))^;
  113.     KeyData[i+7]:= i+7;
  114.     xKey[i+7]:= PByte(longword(@Key)+((i+7) mod Size))^;
  115.     Inc(i,8);
  116.   end;
  117.   j:= 0;
  118.   i:= 0;
  119.   while i< 255 do
  120.   begin
  121.     j:= (j+KeyData[i]+xKey[i]) and $FF;
  122.     t:= KeyData[i];
  123.     KeyData[i]:= KeyData[j];
  124.     KeyData[j]:= t;
  125.     j:= (j+KeyData[i+1]+xKey[i+1]) and $FF;
  126.     t:= KeyData[i+1];
  127.     KeyData[i+1]:= KeyData[j];
  128.     KeyData[j]:= t;
  129.     j:= (j+KeyData[i+2]+xKey[i+2]) and $FF;
  130.     t:= KeyData[i+2];
  131.     KeyData[i+2]:= KeyData[j];
  132.     KeyData[j]:= t;
  133.     j:= (j+KeyData[i+3]+xKey[i+3]) and $FF;
  134.     t:= KeyData[i+3];
  135.     KeyData[i+3]:= KeyData[j];
  136.     KeyData[j]:= t;
  137.     j:= (j+KeyData[i+4]+xKey[i+4]) and $FF;
  138.     t:= KeyData[i+4];
  139.     KeyData[i+4]:= KeyData[j];
  140.     KeyData[j]:= t;
  141.     j:= (j+KeyData[i+5]+xKey[i+5]) and $FF;
  142.     t:= KeyData[i+5];
  143.     KeyData[i+5]:= KeyData[j];
  144.     KeyData[j]:= t;
  145.     j:= (j+KeyData[i+6]+xKey[i+6]) and $FF;
  146.     t:= KeyData[i+6];
  147.     KeyData[i+6]:= KeyData[j];
  148.     KeyData[j]:= t;
  149.     j:= (j+KeyData[i+7]+xKey[i+7]) and $FF;
  150.     t:= KeyData[i+7];
  151.     KeyData[i+7]:= KeyData[j];
  152.     KeyData[j]:= t;
  153.     Inc(i,8);
  154.   end;
  155.   Move(KeyData,KeyOrg,Sizeof(KeyOrg));
  156. end;
  157.  
  158. procedure TDCP_rc4.Reset;
  159. begin
  160.   Move(KeyOrg,KeyData,Sizeof(KeyData));
  161. end;
  162.  
  163. procedure TDCP_rc4.Burn;
  164. begin
  165.   FillChar(KeyOrg,Sizeof(KeyOrg),$FF);
  166.   FillChar(KeyData,Sizeof(KeyData),$FF);
  167.   inherited Burn;
  168. end;
  169.  
  170. procedure TDCP_rc4.Encrypt(const InData; var OutData; Size: longword);
  171. var
  172.   i, j, t, k: longword;
  173. begin
  174.   if not fInitialized then
  175.     raise EDCP_cipher.Create('Cipher not initialized');
  176.   i:= 0; j:= 0;
  177.   for k:= 0 to Size-1 do
  178.   begin
  179.     i:= (i + 1) and $FF;
  180.     t:= KeyData[i];
  181.     j:= (j + t) and $FF;
  182.     KeyData[i]:= KeyData[j];
  183.     KeyData[j]:= t;
  184.     t:= (t + KeyData[i]) and $FF;
  185.     Pbytearray(@OutData)^[k]:= Pbytearray(@InData)^[k] xor KeyData[t];
  186.   end;
  187. end;
  188.  
  189. procedure TDCP_rc4.Decrypt(const InData; var OutData; Size: longword);
  190. var
  191.   i, j, t, k: longword;
  192. begin
  193.   if not fInitialized then
  194.     raise EDCP_cipher.Create('Cipher not initialized');
  195.   i:= 0; j:= 0;
  196.   for k:= 0 to Size-1 do
  197.   begin
  198.     i:= (i + 1) and $FF;
  199.     t:= KeyData[i];
  200.     j:= (j + t) and $FF;
  201.     KeyData[i]:= KeyData[j];
  202.     KeyData[j]:= t;
  203.     t:= (t + KeyData[i]) and $FF;
  204.     Pbytearray(@OutData)^[k]:= Pbytearray(@InData)^[k] xor KeyData[t];
  205.   end;
  206. end;
  207.  
  208.  
  209. end.
  210.