IDEA数据加密算法实现

IDEA数据加密算法介绍之续篇，代码实现：
http://blog.youkuaiyun.com/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
* 开发工具:BorlandDelphi5
*
* 文件名称:IDEA.pas
* 简介:IDEA数据加密算法1.0版本
*
* 备注:任何人使用此文件时,请保留此段自述文件,谢谢 !
*
******************************************************************************/
unitIDEA;

interface

uses
Windows,Messages,SysUtils,Classes,Dialogs;
functionBinToHex(strBin:string):string;
functionHexToTen(strHex:string):int64;
functionLeftMove(S:string;P:integer):String;
functionModAdd(intAdd1,intAdd2:int64):int64;
functionModMul(intMul1,intMul2:int64;intFlag:integer):int64;
functionModXor(intXor1,intXor2:int64):int64;
procedureCreatePassword(strPassword:string;VARarrPassword:arrayofint64;VARarrOpenPassword:arrayofint64); // 产生加密子密钥函数
procedureGetOpenPassword(intSource:int64;VARintResult:int64;Flag:integer); // 求取解密子密钥函数
procedureCreateKeyTable(); // 产生加、解密子密钥之间的对应关系表
procedureRiddle(arrPassword:arrayofint64;arrRiddleKey:arrayofint64;VARarrOpenPassword:arrayofint64);StdCall;export; // IDEA数据解密函数
procedureCreateOpenPassword(VARarrOpenPassKey:arrayofint64); // 产生解密子密钥函数
procedureCreateKey(VARarrKey:arrayofint64;VARarrOpenKey:arrayofint64;VARstrOutKey:string);StdCall;export; // 产生加密密钥函数


implementation

ConststrNum:array[ 1 .. 16 ]ofstring[ 4 ] = ( ' 0000 ' , ' 0001 ' , ' 0010 ' , ' 0011 ' , ' 0100 ' , ' 0101 ' , ' 0110 ' , ' 0111 ' , ' 1000 ' , ' 1001 ' , ' 1010 ' , ' 1011 ' , ' 1100 ' , ' 1101 ' , ' 1110 ' , ' 1111 ' );
ConstchrHex: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 ]ofint64;
g_arr_Flag:array[ 1 .. 52 ]ofinteger;
g_arr_Table:array[ 1 .. 52 ]ofinteger;
... {--------------------------------------------------------------------}

procedureCreateKey(VARarrKey:arrayofint64;VARarrOpenKey:arrayofint64;VARstrOutKey: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;
... {--------------------------------------------------------------------}

functionBinToHex(strBin:string):string;
var
intLoop1,intLoop2:integer;
strTemp,strResult:string;
begin
intLoop1: = 1 ;
strResult: = '' ;
if Length(strBin) <> 16 thenShowMessage( ' 二进制数据长度有错! ' );
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;
... {--------------------------------------------------------------------}

functionHexToTen(strHex:string):int64; // 十六进制转十进制
var
intLoop1,intLoop2,intTemp:integer;
intResult:int64;
strTemp:string;
begin
intResult: = 0 ;
intTemp: = 0 ;
if Length(strHex) <> 4 thenShowMessage( ' 十六进制数据长度有错! ' );
for intLoop1: = 1 to 4 do
begin
CaseintLoop1of
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;
... {--------------------------------------------------------------------}

functionLeftMove(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 <= Pthen
str_Result: = S
else
begin
for i: = P + 1 toint_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;
... {--------------------------------------------------------------------}

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

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

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

procedureCreatePassword(strPassword:string;VARarrPassword:arrayofint64;VARarrOpenPassword:arrayofint64);
var
strKey:string;
strTemp:array[ 1 .. 52 ]ofstring[ 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 ((intCountmod 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;
... {--------------------------------------------------------------------}

procedureGetOpenPassword(intSource:int64;VARintResult:int64;Flag:integer);
var
int_Source,int_Result,int_Mod_Value:int64;
int_Loop:integer;
begin
int_Source: = intSource;
... {--------------------求取每个加密子密钥相应的解密子密钥部分-------------------}
CaseFlagof
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_Resultmodint_Source;
if int_Mod_Value = 0 then
begin
int_Result: = int_Resultdivint_Source;
intResult: = int_Result;
break ;
end;
end;
end;
end;
... {--------------------求取每个加密子密钥相应的解密子密钥部分-------------------}
end;
... {--------------------------------------------------------------------}

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

... {----------------求取每个加密子密钥与相应解密子密钥间的对应关系映射表部分-------------}
int_Count_CreatePassword: = 52 ;
int_Count_OpenPassword: = 1 ;
while (int_Count_CreatePassword >= 1 ) do
begin
Caseint_Count_CreatePasswordmod 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;
... {--------------------------------------------------------------------}


procedureCreateOpenPassword(VARarrOpenPassKey:arrayofint64);
var
int_Loop:integer;
arrTemp:array[ 1 .. 52 ]ofint64;
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;
... {--------------------------------------------------------------------}


procedureRiddle(arrPassword:arrayofint64;arrRiddleKey:arrayofint64;VARarrOpenPassword:arrayofint64);
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 ]ofint64;
begin
... {------------------------数据"解密"算法实现部分------------------}
for i: = Low(arrPassword)toHigh(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.