home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 December / Chip_2002-12_cd1.bin / ctenari / Hytha / MultiHSH.exe / SR.RAR / SR / DCPCrypt / Ciphers / DCPcast128.pas < prev    next >
Pascal/Delphi Source File  |  2002-07-08  |  18KB  |  380 lines
  1. {******************************************************************************}
  2. {* DCPcrypt v2.0 written by David Barton (crypto@cityinthesky.co.uk) **********}
  3. {******************************************************************************}
  4. {* A binary compatible implementation of Cast128 ******************************}
  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 DCPcast128;
  26.  
  27. interface
  28. uses
  29.   Classes, Sysutils, DCPcrypt2, DCPconst, DCPblockciphers;
  30.  
  31. type
  32.   TDCP_cast128= class(TDCP_blockcipher64)
  33.   protected
  34.     KeyData: array[0..31] of DWord;
  35.     Rounds: longword;
  36.     procedure InitKey(const Key; Size: longword); override;
  37.   public
  38.     class function GetID: integer; override;
  39.     class function GetAlgorithm: string; override;
  40.     class function GetMaxKeySize: integer; override;
  41.     class function SelfTest: boolean; override;
  42.     procedure Burn; override;
  43.     procedure EncryptECB(const InData; var OutData); override;
  44.     procedure DecryptECB(const InData; var OutData); override;
  45.   end;
  46.  
  47.  
  48. {******************************************************************************}
  49. {******************************************************************************}
  50. implementation
  51. {$R-}{$Q-}
  52.  
  53. {$I DCPcast128.inc}
  54.  
  55. function LRot32(a, n: dword): dword;
  56. begin
  57.   Result:= (a shl n) or (a shr (32-n));
  58. end;
  59.  
  60. class function TDCP_cast128.GetMaxKeySize: integer;
  61. begin
  62.   Result:= 128;
  63. end;
  64.  
  65. class function TDCP_cast128.GetID: integer;
  66. begin
  67.   Result:= DCP_cast128;
  68. end;
  69.  
  70. class function TDCP_cast128.GetAlgorithm: string;
  71. begin
  72.   Result:= 'Cast128';
  73. end;
  74.  
  75. class function TDCP_cast128.SelfTest: boolean;
  76. const
  77.   Key: array[0..15] of byte=
  78.     ($01,$23,$45,$67,$12,$34,$56,$78,$23,$45,$67,$89,$34,$56,$78,$9A);
  79.   InBlock: array[0..7] of byte=
  80.     ($01,$23,$45,$67,$89,$AB,$CD,$EF);
  81.   Out128: array[0..7] of byte=
  82.     ($23,$8B,$4F,$E5,$84,$7E,$44,$B2);
  83.   Out80: array[0..7] of byte=
  84.     ($EB,$6A,$71,$1A,$2C,$02,$27,$1B);
  85.   Out40: array[0..7] of byte=
  86.     ($7A,$C8,$16,$D1,$6E,$9B,$30,$2E);
  87. var
  88.   Block: array[0..7] of byte;
  89.   Cipher: TDCP_cast128;
  90. begin
  91.   Cipher:= TDCP_cast128.Create(nil);
  92.   Cipher.Init(Key,128,nil);
  93.   Cipher.EncryptECB(InBlock,Block);
  94.   Result:= boolean(CompareMem(@Block,@Out128,8));
  95.   Cipher.DecryptECB(Block,Block);
  96.   Result:= Result and boolean(CompareMem(@Block,@InBlock,8));
  97.   Cipher.Burn;
  98.   Cipher.Init(Key,80,nil);
  99.   Cipher.EncryptECB(InBlock,Block);
  100.   Result:= Result and boolean(CompareMem(@Block,@Out80,8));
  101.   Cipher.DecryptECB(Block,Block);
  102.   Result:= Result and boolean(CompareMem(@Block,@InBlock,8));
  103.   Cipher.Burn;
  104.   Cipher.Init(Key,40,nil);
  105.   Cipher.EncryptECB(InBlock,Block);
  106.   Result:= Result and boolean(CompareMem(@Block,@Out40,8));
  107.   Cipher.DecryptECB(Block,Block);
  108.   Result:= Result and boolean(CompareMem(@Block,@InBlock,8));
  109.   Cipher.Burn;
  110.   Cipher.Free;
  111. end;
  112.  
  113. procedure TDCP_cast128.InitKey(const Key; Size: longword);
  114. var
  115.   x, t, z: array[0..3] of DWord;
  116.   i: longword;
  117. begin
  118.   Size:= Size div 8;
  119.   if Size<= 10 then
  120.     Rounds:= 12
  121.   else
  122.     Rounds:= 16;
  123.   FillChar(x,Sizeof(x),0);
  124.   Move(Key,x,Size);
  125.   x[0]:= (x[0] shr 24) or ((x[0] shr 8) and $FF00) or ((x[0] shl 8) and $FF0000) or (x[0] shl 24);
  126.   x[1]:= (x[1] shr 24) or ((x[1] shr 8) and $FF00) or ((x[1] shl 8) and $FF0000) or (x[1] shl 24);
  127.   x[2]:= (x[2] shr 24) or ((x[2] shr 8) and $FF00) or ((x[2] shl 8) and $FF0000) or (x[2] shl 24);
  128.   x[3]:= (x[3] shr 24) or ((x[3] shr 8) and $FF00) or ((x[3] shl 8) and $FF0000) or (x[3] shl 24);
  129.   i:= 0;
  130.   while i< 32 do
  131.   begin
  132.     case (i and 4) of
  133.       0:
  134.         begin
  135.           z[0]:= x[0] xor cast_sbox5[(x[3] shr 16) and $FF] xor
  136.            cast_sbox6[x[3] and $FF] xor cast_sbox7[x[3] shr 24] xor
  137.            cast_sbox8[(x[3] shr 8) and $FF] xor cast_sbox7[x[2] shr 24];
  138.           t[0]:= z[0];
  139.           z[1]:= x[2] xor cast_sbox5[z[0] shr 24] xor
  140.            cast_sbox6[(z[0] shr 8) and $FF] xor cast_sbox7[(z[0] shr 16) and $FF] xor
  141.            cast_sbox8[z[0] and $FF] xor cast_sbox8[(x[2] shr 8) and $FF];
  142.           t[1]:= z[1];
  143.           z[2]:= x[3] xor cast_sbox5[z[1] and $FF] xor
  144.            cast_sbox6[(z[1] shr 8) and $FF] xor cast_sbox7[(z[1] shr 16) and $FF] xor
  145.            cast_sbox8[z[1] shr 24] xor cast_sbox5[(x[2] shr 16) and $FF];
  146.           t[2]:= z[2];
  147.           z[3]:= x[1] xor cast_sbox5[(z[2] shr 8) and $FF] xor
  148.            cast_sbox6[(z[2] shr 16) and $FF] xor cast_sbox7[z[2] and $FF] xor
  149.            cast_sbox8[z[2] shr 24] xor cast_sbox6[x[2] and $FF];
  150.           t[3]:= z[3];
  151.         end;
  152.       4:
  153.         begin
  154.           x[0]:= z[2] xor cast_sbox5[(z[1] shr 16) and $FF] xor
  155.            cast_sbox6[z[1] and $FF] xor cast_sbox7[z[1] shr 24] xor
  156.            cast_sbox8[(z[1] shr 8) and $FF] xor cast_sbox7[z[0] shr 24];
  157.           t[0]:= x[0];
  158.           x[1]:= z[0] xor cast_sbox5[x[0] shr 24] xor
  159.            cast_sbox6[(x[0] shr 8) and $FF] xor cast_sbox7[(x[0] shr 16) and $FF] xor
  160.            cast_sbox8[x[0] and $FF] xor cast_sbox8[(z[0] shr 8) and $FF];
  161.           t[1]:= x[1];
  162.           x[2]:= z[1] xor cast_sbox5[x[1] and $FF] xor
  163.            cast_sbox6[(x[1] shr 8) and $FF] xor cast_sbox7[(x[1] shr 16) and $FF] xor
  164.            cast_sbox8[x[1] shr 24] xor cast_sbox5[(z[0] shr 16) and $FF];
  165.           t[2]:= x[2];
  166.           x[3]:= z[3] xor cast_sbox5[(x[2] shr 8) and $FF] xor
  167.            cast_sbox6[(x[2] shr 16) and $FF] xor cast_sbox7[x[2] and $FF] xor
  168.            cast_sbox8[x[2] shr 24] xor cast_sbox6[z[0] and $FF];
  169.           t[3]:= x[3];
  170.         end;
  171.     end;
  172.     case (i and 12) of
  173.       0,12:
  174.         begin
  175.           KeyData[i+0]:= cast_sbox5[t[2] shr 24] xor cast_sbox6[(t[2] shr 16) and $FF] xor
  176.            cast_sbox7[t[1] and $FF] xor cast_sbox8[(t[1] shr 8) and $FF];
  177.           KeyData[i+1]:= cast_sbox5[(t[2] shr 8) and $FF] xor cast_sbox6[t[2] and $FF] xor
  178.            cast_sbox7[(t[1] shr 16) and $FF] xor cast_sbox8[t[1] shr 24];
  179.           KeyData[i+2]:= cast_sbox5[t[3] shr 24] xor cast_sbox6[(t[3] shr 16) and $FF] xor
  180.            cast_sbox7[t[0] and $FF] xor cast_sbox8[(t[0] shr 8) and $FF];
  181.           KeyData[i+3]:= cast_sbox5[(t[3] shr 8) and $FF] xor cast_sbox6[t[3] and $FF] xor
  182.            cast_sbox7[(t[0] shr 16) and $FF] xor cast_sbox8[t[0] shr 24];
  183.         end;
  184.       4,8:
  185.         begin
  186.           KeyData[i+0]:= cast_sbox5[t[0] and $FF] xor cast_sbox6[(t[0] shr 8) and $FF] xor
  187.            cast_sbox7[t[3] shr 24] xor cast_sbox8[(t[3] shr 16) and $FF];
  188.           KeyData[i+1]:= cast_sbox5[(t[0] shr 16) and $FF] xor cast_sbox6[t[0] shr 24] xor
  189.            cast_sbox7[(t[3] shr 8) and $FF] xor cast_sbox8[t[3] and $FF];
  190.           KeyData[i+2]:= cast_sbox5[t[1] and $FF] xor cast_sbox6[(t[1] shr 8) and $FF] xor
  191.            cast_sbox7[t[2] shr 24] xor cast_sbox8[(t[2] shr 16) and $FF];
  192.           KeyData[i+3]:= cast_sbox5[(t[1] shr 16) and $FF] xor cast_sbox6[t[1] shr 24] xor
  193.            cast_sbox7[(t[2] shr 8) and $FF] xor cast_sbox8[t[2] and $FF];
  194.         end;
  195.     end;
  196.     case (i and 12) of
  197.       0:
  198.         begin
  199.           KeyData[i+0]:= KeyData[i+0] xor cast_sbox5[(z[0] shr 8) and $FF];
  200.           KeyData[i+1]:= KeyData[i+1] xor cast_sbox6[(z[1] shr 8) and $FF];
  201.           KeyData[i+2]:= KeyData[i+2] xor cast_sbox7[(z[2] shr 16) and $FF];
  202.           KeyData[i+3]:= KeyData[i+3] xor cast_sbox8[z[3] shr 24];
  203.         end;
  204.       4:
  205.         begin
  206.           KeyData[i+0]:= KeyData[i+0] xor cast_sbox5[x[2] shr 24];
  207.           KeyData[i+1]:= KeyData[i+1] xor cast_sbox6[(x[3] shr 16) and $FF];
  208.           KeyData[i+2]:= KeyData[i+2] xor cast_sbox7[x[0] and $FF];
  209.           KeyData[i+3]:= KeyData[i+3] xor cast_sbox8[x[1] and $FF];
  210.         end;
  211.       8:
  212.         begin
  213.           KeyData[i+0]:= KeyData[i+0] xor cast_sbox5[(z[2] shr 16) and $FF];
  214.           KeyData[i+1]:= KeyData[i+1] xor cast_sbox6[z[3] shr 24];
  215.           KeyData[i+2]:= KeyData[i+2] xor cast_sbox7[(z[0] shr 8) and $FF];
  216.           KeyData[i+3]:= KeyData[i+3] xor cast_sbox8[(z[1] shr 8) and $FF];
  217.         end;
  218.       12:
  219.         begin
  220.           KeyData[i+0]:= KeyData[i+0] xor cast_sbox5[x[0] and $FF];
  221.           KeyData[i+1]:= KeyData[i+1] xor cast_sbox6[x[1] and $FF];
  222.           KeyData[i+2]:= KeyData[i+2] xor cast_sbox7[x[2] shr 24];
  223.           KeyData[i+3]:= KeyData[i+3] xor cast_sbox8[(x[3] shr 16) and $FF];
  224.         end;
  225.     end;
  226.     if (i >= 16) then
  227.     begin
  228.       KeyData[i+0]:= KeyData[i+0] and 31;
  229.       KeyData[i+1]:= KeyData[i+1] and 31;
  230.       KeyData[i+2]:= KeyData[i+2] and 31;
  231.       KeyData[i+3]:= KeyData[i+3] and 31;
  232.     end;
  233.     Inc(i,4);
  234.   end;
  235. end;
  236.  
  237. procedure TDCP_cast128.Burn;
  238. begin
  239.   FillChar(KeyData,Sizeof(KeyData),$FF);
  240.   Rounds:= 0;
  241.   inherited Burn;
  242. end;
  243.  
  244. procedure TDCP_cast128.EncryptECB(const InData; var OutData);
  245. var
  246.   t, l, r: DWord;
  247. begin
  248.   if not fInitialized then
  249.     raise EDCP_blockcipher.Create('Cipher not initialized');
  250.   l:= Pdword(@InData)^;
  251.   r:= Pdword(longword(@InData)+4)^;
  252.   l:= (l shr 24) or ((l shr 8) and $FF00) or ((l shl 8) and $FF0000) or (l shl 24);
  253.   r:= (r shr 24) or ((r shr 8) and $FF00) or ((r shl 8) and $FF0000) or (r shl 24);
  254.   t:= LRot32(KeyData[0]+r, KeyData[0+16]);
  255.   l:= l xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  256.     cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  257.   t:= LRot32(KeyData[1] xor l, KeyData[1+16]);
  258.   r:= r xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  259.     cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  260.   t:= LRot32(KeyData[2]-r, KeyData[2+16]);
  261.   l:= l xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  262.     cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  263.   t:= LRot32(KeyData[3]+l, KeyData[3+16]);
  264.   r:= r xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  265.     cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  266.   t:= LRot32(KeyData[4] xor r, KeyData[4+16]);
  267.   l:= l xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  268.     cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  269.   t:= LRot32(KeyData[5]-l, KeyData[5+16]);
  270.   r:= r xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  271.     cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  272.   t:= LRot32(KeyData[6]+r, KeyData[6+16]);
  273.   l:= l xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  274.     cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  275.   t:= LRot32(KeyData[7] xor l, KeyData[7+16]);
  276.   r:= r xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  277.     cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  278.   t:= LRot32(KeyData[8]-r, KeyData[8+16]);
  279.   l:= l xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  280.     cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  281.   t:= LRot32(KeyData[9]+l, KeyData[9+16]);
  282.   r:= r xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  283.     cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  284.   t:= LRot32(KeyData[10] xor r, KeyData[10+16]);
  285.   l:= l xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  286.     cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  287.   t:= LRot32(KeyData[11]-l, KeyData[11+16]);
  288.   r:= r xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  289.     cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  290.   if Rounds> 12 then
  291.   begin
  292.     t:= LRot32(KeyData[12]+r, KeyData[12+16]);
  293.     l:= l xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  294.       cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  295.     t:= LRot32(KeyData[13] xor l, KeyData[13+16]);
  296.     r:= r xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  297.       cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  298.     t:= LRot32(KeyData[14]-r, KeyData[14+16]);
  299.     l:= l xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  300.       cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  301.     t:= LRot32(KeyData[15]+l, KeyData[15+16]);
  302.     r:= r xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  303.       cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  304.   end;
  305.   l:= (l shr 24) or ((l shr 8) and $FF00) or ((l shl 8) and $FF0000) or (l shl 24);
  306.   r:= (r shr 24) or ((r shr 8) and $FF00) or ((r shl 8) and $FF0000) or (r shl 24);
  307.   Pdword(@OutData)^:= r;
  308.   Pdword(longword(@OutData)+4)^:= l;
  309. end;
  310.  
  311. procedure TDCP_cast128.DecryptECB(const InData; var OutData);
  312. var
  313.   t, l, r: DWord;
  314. begin
  315.   if not fInitialized then
  316.     raise EDCP_blockcipher.Create('Cipher not initialized');
  317.   r:= Pdword(@InData)^;
  318.   l:= Pdword(longword(@InData)+4)^;
  319.   l:= (l shr 24) or ((l shr 8) and $FF00) or ((l shl 8) and $FF0000) or (l shl 24);
  320.   r:= (r shr 24) or ((r shr 8) and $FF00) or ((r shl 8) and $FF0000) or (r shl 24);
  321.   if Rounds> 12 then
  322.   begin
  323.     t:= LRot32(KeyData[15]+l, KeyData[15+16]);
  324.     r:= r xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  325.       cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  326.     t:= LRot32(KeyData[14]-r, KeyData[14+16]);
  327.     l:= l xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  328.       cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  329.     t:= LRot32(KeyData[13] xor l, KeyData[13+16]);
  330.     r:= r xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  331.       cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  332.     t:= LRot32(KeyData[12]+r, KeyData[12+16]);
  333.     l:= l xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  334.       cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  335.   end;
  336.   t:= LRot32(KeyData[11]-l, KeyData[11+16]);
  337.   r:= r xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  338.     cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  339.   t:= LRot32(KeyData[10] xor r, KeyData[10+16]);
  340.   l:= l xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  341.     cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  342.   t:= LRot32(KeyData[9]+l, KeyData[9+16]);
  343.   r:= r xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  344.     cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  345.   t:= LRot32(KeyData[8]-r, KeyData[8+16]);
  346.   l:= l xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  347.     cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  348.   t:= LRot32(KeyData[7] xor l, KeyData[7+16]);
  349.   r:= r xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  350.     cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  351.   t:= LRot32(KeyData[6]+r, KeyData[6+16]);
  352.   l:= l xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  353.     cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  354.   t:= LRot32(KeyData[5]-l, KeyData[5+16]);
  355.   r:= r xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  356.     cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  357.   t:= LRot32(KeyData[4] xor r, KeyData[4+16]);
  358.   l:= l xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  359.     cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  360.   t:= LRot32(KeyData[3]+l, KeyData[3+16]);
  361.   r:= r xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  362.     cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  363.   t:= LRot32(KeyData[2]-r, KeyData[2+16]);
  364.   l:= l xor (((cast_sbox1[t shr 24] + cast_sbox2[(t shr 16) and $FF]) xor
  365.     cast_sbox3[(t shr 8) and $FF]) - cast_sbox4[t and $FF]);
  366.   t:= LRot32(KeyData[1] xor l, KeyData[1+16]);
  367.   r:= r xor (((cast_sbox1[t shr 24] - cast_sbox2[(t shr 16) and $FF]) +
  368.     cast_sbox3[(t shr 8) and $FF]) xor cast_sbox4[t and $FF]);
  369.   t:= LRot32(KeyData[0]+r, KeyData[0+16]);
  370.   l:= l xor (((cast_sbox1[t shr 24] xor cast_sbox2[(t shr 16) and $FF]) -
  371.     cast_sbox3[(t shr 8) and $FF]) + cast_sbox4[t and $FF]);
  372.   l:= (l shr 24) or ((l shr 8) and $FF00) or ((l shl 8) and $FF0000) or (l shl 24);
  373.   r:= (r shr 24) or ((r shr 8) and $FF00) or ((r shl 8) and $FF0000) or (r shl 24);
  374.   Pdword(@OutData)^:= l;
  375.   Pdword(longword(@OutData)+4)^:= r;
  376. end;
  377.  
  378.  
  379. end.
  380.