IDEA数据加密算法实现

  IDEA数据加密算法介绍之续篇，代码实现：
http://blog.csdn.net/CXXSoft/archive/2006/08/23/1109279.aspx

5、   源码：

// *******************************************************************************
  *         IDEA数据加密算法1.0版本
  *         开发作者:    成晓旭
  *         项目简述:    IDEA数据加密算法1.0版本
  *         启动时间:    2000年05月08日  
  *         完成时间:    2000年01月14日   20 : 09 : 00      < 1个晚上 >
  *
  *         开发环境:    Windows98
  *         开发工具:    Borland Delphi5
  *
  *         文件名称:    IDEA.pas
  *         简    介:    IDEA数据加密算法1.0版本
  *
  *            备注:       任何人使用此文件时,请保留此段自述文件,谢谢 !
  *
  ******************************************************************************/
unit IDEA;

interface

uses
  Windows, Messages, SysUtils, Classes,Dialogs;
  function BinToHex(strBin:string):string;
  function HexToTen(strHex:string):int64;
  function LeftMove(S:string;P:integer):String;
  function ModAdd(intAdd1,intAdd2:int64):int64;
  function ModMul(intMul1,intMul2:int64;intFlag:integer):int64;
  function ModXor(intXor1,intXor2:int64):int64;
  procedure CreatePassword(strPassword:string;VAR arrPassword:array of int64;VAR arrOpenPassword:array of int64);        // 产生加密子密钥函数
  procedure GetOpenPassword(intSource:int64;VAR intResult:int64;Flag:integer);        // 求取解密子密钥函数
  procedure CreateKeyTable();                          // 产生加、解密子密钥之间的对应关系表
  procedure Riddle(arrPassword:array of int64;arrRiddleKey:array of int64;VAR arrOpenPassword:array of int64);StdCall;export;          // IDEA数据解密函数
  procedure CreateOpenPassword(VAR arrOpenPassKey:array of int64);                      // 产生解密子密钥函数
  procedure CreateKey(VAR arrKey:array of int64;VAR arrOpenKey:array of int64;VAR strOutKey:string);StdCall;export;      // 产生加密密钥函数


implementation

Const strNum:array[ 1 .. 16 ] of string[ 4 ] = ( ' 0000 ' , ' 0001 ' , ' 0010 ' , ' 0011 ' , ' 0100 ' , ' 0101 ' , ' 0110 ' , ' 0111 ' , ' 1000 ' , ' 1001 ' , ' 1010 ' , ' 1011 ' , ' 1100 ' , ' 1101 ' , ' 1110 ' , ' 1111 ' );
Const chrHex:array[ 1 .. 16 ] of  char = ( ' 0 ' , ' 1 ' , ' 2 ' , ' 3 ' , ' 4 ' , ' 5 ' , ' 6 ' , ' 7 ' , ' 8 ' , ' 9 ' , ' A ' , ' B ' , ' C ' , ' D ' , ' E ' , ' F ' );
var
  g_arr_Ten_Password:array[ 1 .. 52 ] of int64;
  g_arr_Flag:array[ 1 .. 52 ] of integer;
  g_arr_Table:array[ 1 .. 52 ] of integer;
... {--------------------------------------------------------------------}

procedure CreateKey(VAR arrKey:array of int64;VAR arrOpenKey:array of int64;VAR strOutKey:string);StdCall;export;
var
intKey,intLoop1,intLoop2,intLoop3:integer;
hexKey,ch,strTemp:string;
strKey:string[ 128 ];
begin
strKey: = '' ;
Randomize;
for  intLoop1: = 1  to  8   do
 begin
   intKey: = Random( 65536 );
   hexKey: = IntToHex(intKey, 4 );
   strTemp: = '' ;
    for  intLoop2: = 1  to  4   do
    begin
     ch: = Copy(hexKey,intLoop2, 1 );
      for  intLoop3: = 1  to  16   do
      begin
         if  ch  =  chrHex[intLoop3] then
          begin
           ch: =  strNum[intLoop3];
            break ;
          end;
      end;
     strTemp: = strTemp + ch;
    end;
   strKey: = strKey + strTemp;
 end;
strOutKey: = strKey;                          
CreatePassword(strKey,arrKey,arrOpenKey);        // 调用产生加密子密钥过程
end;
... {--------------------------------------------------------------------}

function BinToHex(strBin:string):string;
var
intLoop1,intLoop2:integer;
strTemp,strResult:string;
begin
intLoop1: = 1 ;
strResult: = '' ;
if  Length(strBin)  <>   16  then ShowMessage( ' 二进制数据长度有错! ' );
while  (intLoop1 <= 16 )  do
 begin
  strTemp: = Copy(strBin,intLoop1, 4 );
   for   intLoop2: = 1  to  16   do
    if  strTemp = strNum[intLoop2] then
    begin
      strTemp: = chrHex[intLoop2];
       break ;
    end;
  strResult: = strResult + strTemp;
  intLoop1: = intLoop1  +   4 ;
 end;
BinToHex: = strResult;
end;
... {--------------------------------------------------------------------}

function HexToTen(strHex:string):int64;          // 十六进制转十进制
var
intLoop1,intLoop2,intTemp:integer;
intResult:int64;
strTemp:string;
begin
intResult: = 0 ;
intTemp: = 0 ;
if  Length(strHex)  <>   4  then ShowMessage( ' 十六进制数据长度有错! ' );
for  intLoop1: = 1  to  4   do
 begin
  Case intLoop1 of
    1 :intTemp: = 4096 ;
    2 :intTemp: = 256 ;
    3 :intTemp: = 16 ;
    4 :intTemp: = 1
  end;
  strTemp: = Copy(strHex,intLoop1, 1 );
   for  intLoop2: = 1  to  16   do
    if  UpperCase(strTemp)  =  chrHex[intLoop2] then
    begin
     intResult: = intResult + (Int64(intLoop2)  -   1 ) * Int64(intTemp);
      break ;
    end;
 end;
HexToTen: = intResult;
end;
... {--------------------------------------------------------------------}

function LeftMove(S:string;P:integer):String;
var
int_Len,i:integer;
str_Result,str_Num:string;
begin
int_Len: = length(s);
str_Num: = S;
str_Result: = '' ;
if  int_Len  <=  P then
  str_Result : = S
else
begin
   for  i: = P + 1  to int_Len  do
    str_Result: = str_Result + copy(str_Num,i, 1 );
  str_Result: = str_Result + copy(str_Num, 1 ,p);
end;
LeftMove: = Trim(str_Result);
end;
... {--------------------------------------------------------------------}

function ModAdd(intAdd1,intAdd2:int64):int64;
begin
ModAdd: = (intAdd1  +  intAdd2) mod  65536 ;    // 模65536求和
end;

function ModMul(intMul1,intMul2:int64;intFlag:integer):int64;
var intTemp:int64;
begin
intTemp: = (intMul1  *  intMul2) mod  65537 ; 
if  intFlag  =   0  then
 begin
   if  intMul1  =   0      then    intTemp: = 65537   -  intMul2;
   if  intMul2  =   0      then    intTemp: = 65537   -  intMul1;
   if  intTemp  =   65536  then    intTemp: = 0 ;
   if  intTemp  =   65537  then    intTemp: = 1 ;
 end
else
 begin
   if  intMul1  =   0      then    intTemp: = 65537   -  intMul2;
   if  intMul2  =   0      then    intTemp: = 65537   -  intMul1;
   if  intTemp  =   0      then    intTemp: = 65536 ;
   if  intTemp  =   65537  then    intTemp: = 1 ;
   if  intTemp  =   65536  then    intTemp: = 0 ;                   
 end;
ModMul: = intTemp;
end;

function ModXor(intXor1,intXor2:int64):int64;
begin
ModXor: =  intXor1 xor intXor2;
end;
... {--------------------------------------------------------------------}

procedure CreatePassword(strPassword:string;VAR arrPassword:array of int64;VAR arrOpenPassword:array of int64);
var
strKey:string;
strTemp:array[ 1 .. 52 ] of string[ 4 ];
intStart,intCount:integer;
begin
strKey: = strPassword;                                                                                                                    //
intCount: = 1 ;
intStart: = 1 ;
... {--------------------产生52个16bit的加密子密钥部分-------------------}
while  (intCount <= 52 )  do
 begin
  strTemp[intCount]: = BinToHex(Copy(strKey,intStart, 16 ));
  intStart: = intStart + 16 ;
  intCount: = intCount + 1 ;
   if  ((intCount mod  8 )  =   1 ) then
   begin
    strKey: = LeftMove(strKey, 25 );
    intStart: = 1 ;
   end;
 end;
intCount: = 1 ;
while  (intCount <= 52 )  do
 begin
  arrPassword[intCount - 1 ]: = HexToTen(strTemp[intCount]);
  g_arr_Ten_Password[intCount]: = arrPassword[intCount - 1 ];
  intCount: = intCount + 1 ;
 end;
CreateOpenPassword(arrOpenPassword);                       
... {--------------------产生52个16bit的加密子密钥部分-------------------}
end;
... {--------------------------------------------------------------------}

procedure GetOpenPassword(intSource:int64;VAR intResult:int64;Flag:integer);
var
int_Source,int_Result,int_Mod_Value:int64;
int_Loop:integer;
begin
int_Source: = intSource;
... {--------------------求取每个加密子密钥相应的解密子密钥部分-------------------}
Case Flag of
   0 :    intResult: = int_Source;
   1 :    intResult: = 65536 - int_Source;
   2 :
    begin
       if  int_Source = 0  then
         intResult: = int_Source
       else
         for  int_Loop: = 1  to  65536   do
         begin
          int_Result: = Int64(int_Loop) * 65537 + 1 ;
          int_Mod_Value: = int_Result mod int_Source;
           if  int_Mod_Value  =   0  then
            begin
              int_Result: = int_Result div int_Source;
              intResult: = int_Result;
               break ;
            end;
         end;
    end;
end;
... {--------------------求取每个加密子密钥相应的解密子密钥部分-------------------}
end;
... {--------------------------------------------------------------------}

procedure CreateKeyTable();
var
int_Count_CreatePassword,int_Count_OpenPassword,int_ExChange:integer;
begin
... {----------------求取在产生解密子密钥时所用的参数标志对应表部分-------------}
for  int_Count_CreatePassword: = 52  downto  1   do
  Case int_Count_CreatePassword mod  6  of
     0 , 5 :begin g_arr_Flag[int_Count_CreatePassword]: = 0 ; end;
     2 , 3 :begin g_arr_Flag[int_Count_CreatePassword]: = 1 ; end;
     1 , 4 :begin g_arr_Flag[int_Count_CreatePassword]: = 2 ; end;
  end;
... {----------------求取在产生解密子密钥时所用的参数标志对应表部分-------------}

... {----------------求取每个加密子密钥与相应解密子密钥间的对应关系映射表部分-------------}
int_Count_CreatePassword: = 52 ;
int_Count_OpenPassword: = 1 ;
while  (int_Count_CreatePassword >= 1 )  do
begin
  Case int_Count_CreatePassword mod  6  of
     1 , 2 , 3 , 4 :
    begin
      g_arr_Table[int_Count_OpenPassword]: = int_Count_CreatePassword - 3 ;
      g_arr_Table[int_Count_OpenPassword + 1 ]: = int_Count_CreatePassword - 1 ;
      g_arr_Table[int_Count_OpenPassword + 2 ]: = int_Count_CreatePassword - 2 ;
      g_arr_Table[int_Count_OpenPassword + 3 ]: = int_Count_CreatePassword;
       if  (int_Count_CreatePassword  >= 48 ) or (int_Count_CreatePassword  <= 4  ) then   // 首轮和末轮处理不需交换,故要再换回来
        begin
          int_ExChange: = g_arr_Table[int_Count_OpenPassword + 1 ];
          g_arr_Table[int_Count_OpenPassword + 1 ]: = g_arr_Table[int_Count_OpenPassword + 2 ];
          g_arr_Table[int_Count_OpenPassword + 2 ]: = int_ExChange;
        end;
      int_Count_CreatePassword: = int_Count_CreatePassword - 4 ;
      int_Count_OpenPassword: = int_Count_OpenPassword + 4 ;
    end;
     0 , 5 :
    begin
      g_arr_Table[int_Count_OpenPassword]: = int_Count_CreatePassword - 1 ;
      g_arr_Table[int_Count_OpenPassword + 1 ]: = int_Count_CreatePassword;
      int_Count_CreatePassword: = int_Count_CreatePassword - 2 ;
      int_Count_OpenPassword: = int_Count_OpenPassword + 2 ;
    end;
  end;
end;
... {----------------求取每个加密子密钥与相应解密子密钥间的对应关系映射表部分-------------}
end;
... {--------------------------------------------------------------------}


procedure CreateOpenPassword(VAR arrOpenPassKey:array of int64);
var
int_Loop:integer;
arrTemp:array[ 1 .. 52 ] of int64;
begin
... {-------------通过调用产生加、解密子密钥对应关系函数产生对应关系表部分------------------}
CreateKeyTable;
... {-------------通过调用求解解密子密钥函数产生解密子密钥部分------------------}
for  int_Loop: = 1  to  52   do
 begin
  GetOpenPassword(g_arr_Ten_Password[int_Loop],arrTemp[g_arr_Table[int_Loop]],g_arr_Flag[int_Loop]);
 end;
for  int_Loop: = 1  to  52   do
  arrOpenPassKey[int_Loop - 1 ]: = arrTemp[int_Loop];
... {-------------通过调用求解解密子密钥函数产生解密子密钥部分------------------}
end;
... {--------------------------------------------------------------------}


procedure Riddle(arrPassword:array of int64;arrRiddleKey:array of int64;VAR arrOpenPassword:array of int64);
var
Count,i:integer;
V1,V2,V3,V4,V5,V6,V7,V8,V9,V10,V11,V12,V13,V14,C1,C2,C3,C4,ExChange:int64;
P:array[ 1 .. 4 ] of int64;
begin
... {------------------------数据 "解密" 算法实现部分------------------}
for  i: = Low(arrPassword) to High(arrPassword)  do
 P[i + 1 ]: = arrPassword[i];
Count: = 0 ;
while  (Count < 48 )  do
begin
  V1: =  ModMul(P[ 1 ],arrRiddleKey[Count], 1 );   // 相乘    1
  Inc(Count);
  V2: =  ModAdd(P[ 2 ],arrRiddleKey[Count]);   // 相加    2
  Inc(Count);
  V3: =  ModAdd(P[ 3 ],arrRiddleKey[Count]);   // 相加    3
  Inc(Count);
  V4: =  ModMul(P[ 4 ],arrRiddleKey[Count], 1 );   // 相乘    4
  Inc(Count);
  V5: =  ModXor(V1,V3);                                            // 异或    5
  V6: =  ModXor(V2,V4);                                            // 异或    6
  V7: =  ModMul(V5,arrRiddleKey[Count], 1 );     // 相乘    7
  Inc(Count);
  V8: =  ModAdd(V6,V7);                         // 相加    8
  V9: =  ModMul(V8,arrRiddleKey[Count], 1 );     // 相乘    9
  Inc(Count);
  V10: = ModAdd(V7,V9);                       // 相加    10
  V11: = ModXor(V1,V9);                       // 异或    11
  V12: = ModXor(V2,V10);                      // 异或    12
  V13: = ModXor(V3,V9);                       // 异或    13
  V14: = ModXor(V4,V10);                      // 异或    14
  P[ 1 ]: = V11;
  P[ 2 ]: = V13;                                 // 注意:交换中间两个输出结果
  P[ 3 ]: = V12;                                 // 注意:交换中间两个输出结果
  P[ 4 ]: = V14;
end;     // 结束8轮计算
ExChange: = P[ 2 ];
P[ 2 ]: = P[ 3 ];
P[ 3 ]: = ExChange;                             // 因为最后一轮无需转换,所以必须把P[2],P[3]再次转换回来
C1: =  ModMul(P[ 1 ],arrRiddleKey[ 48 ], 1 );   // 相乘    1
C2: =  ModAdd(P[ 2 ],arrRiddleKey[ 49 ]);   // 相加    2
C3: =  ModAdd(P[ 3 ],arrRiddleKey[ 50 ]);   // 相加    3
C4: =  ModMul(P[ 4 ],arrRiddleKey[ 51 ], 1 );   // 相乘    4
... {------------------------数据 "解密" 算法实现部分------------------}
arrOpenPassword[Low(arrOpenPassword)]: = C1;
arrOpenPassword[Low(arrOpenPassword) + 1 ]: = C2;
arrOpenPassword[Low(arrOpenPassword) + 2 ]: = C3;
arrOpenPassword[Low(arrOpenPassword) + 3 ]: = C4;
// 数据解密成功!
end;
... {--------------------------------------------------------------------}

end.

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1109321