IDEA数据加密算法实现

2006年08月23日 17:57:00

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