RC5分组密码算法是1994由麻萨诸塞技术研究所的Ronald L. Rivest教授发明的,并由RSA实验室分析。它是参数可变的分组密码算法,三个可变的参数是:分组大小、密钥大小和加密轮数。在此算法中使用了三种运算:异或、加和循环。
简介
RC5是种比较新的算法,Rivest设计了RC5的一种特殊的实现方式,因此RC5算法有一个面向字的结构:RC5-w/r/b,这里w是字长其值可以是16、32或64对于不同的字长明文和密文块的分组长度为2w位,r是加密轮数,b是密钥字节长度。由于RC5一个分组长度可变的密码算法,为了便于说明在本文中主要是针对64位的分组w=32进行处理的,下面详细说明了RC5加密解密的处理过程:
加密解密
1、创建密钥组
RC5算法加密时使用了2r+2个密钥相关的的32位字: ,这里r表示加密的轮数。创建这个密钥组的过程是非常复杂的但也是直接的,首先将密钥字节拷贝到32位字的数组L中(此时要注意处理器是little-endian顺序还是big-endian顺序),如果需要,最后一个字可以用零填充。然后利用线性同余发生器模2初始化数组S:
对于i=1到2(r+1)-1: (本应模 ,本文中令w=32)
其中对于16位字32位分组的RC5,P=0xb7e1 Q=0x9e37
对于32位字和64位分组的RC5,P=0xb7e15163 Q=0x9e3779b9
对于64位字和128位分组,P=0xb7151628aed2a6b Q=0x9e3779b97f4a7c15
最后将L与S混合,混合过程如下:
i=j=0
A=B=0
处理3n次(这里n是2(r+1)和c中的最大值,其中c表示输入的密钥字的个数)
2、加密处理
在创建完密钥组后开始进行对明文的加密,加密时,首先将明文分组划分为两个32位字:A和B(在假设处理器字节顺序是little-endian、w=32的情况下,第一个明文字节进入A的最低字节,第四个明文字节进入A的最高字节,第五个明文字节进入B的最低字节,以此类推),其中操作符《《《表示循环左移,加运算是模 (本应模 ,本文中令w=32)的。
输出的密文是在寄存器A和B中的内容
3、解密处理
解密也是很容易的,把密文分组划分为两个字:A和B(存储方式和加密一样),这里符合》》》是循环右移,减运算也是模 (本应模 ,本文中令w=32)的。
RSA试验室花费了相当的时间来分析64位分组的RC5算法,在5轮后统计特性看起来非常好。在8轮后,每一个明文位至少影响一个循环。对于5轮的RC5,差分攻击需要 个选择明文;对10轮需要 个;对于12轮需要 个;对15轮需要 个。而对于64位的分组只有 个可能的明文,所以对于15轮或以上的RC5的差分攻击是失败的。在6轮后线性分析就是安全的了,Rivest推荐至少12轮,甚至可能是16轮。这个轮数可以进行选择。
RC5 分组密钥算法 C语言实现
[cpp] view plain copy/*RC5 C代码实现
w/r/b=32/12/16
基本的RC5 3种算法组成,即密钥扩展算法、加密算法和解密算法。故RC5的C语言实现也由以下几个部分构成。
1、 参数的定义
*/
#include 《stdlib.h》
#include 《stdio.h》
#include 《string.h》
#include 《math.h》
int w=32;//字长 32bit 4字节
int r=12;//12;//加密轮数12
int b=16;//主密钥(字节为单位8bit)个数 这里有16个
int t=26;//2*r+2=12*2+2=26
int c=4; //主密钥个数*8/w = 16*8/32
typedef unsigned long int FOURBYTEINT;//四字节
typedef unsigned short int TWOBYTEINT;//2字节
typedef unsigned char BYTE;
void IniTIalKey(unsigned char* KeyK,int b);
void generateChildKey(unsigned char* KeyK,FOURBYTEINT* ChildKeyS);
void Encipher(FOURBYTEINT* In,FOURBYTEINT* Out,FOURBYTEINT* S);
void Decipher(FOURBYTEINT* In,FOURBYTEINT* Out,FOURBYTEINT* S);
#define NoOfData 4
/**2、循环移位函数
由于在生成子密钥,加密,解密过程中都要进行循环移位,故要首先定义循环以为函数。
* 循环左移和右移函数
* x : 被循环的数
* y : 将要循环的位数
*/
#define ROTL(x,y) (((x)《《(y&(w-1))) | ((x)》》(w-(y&(w-1)))))
#define ROTR(x,y) (((x)》》(y&(w-1))) | ((x)《《(w-(y&(w-1)))))
/**3、 初始密钥产生函数
生成一个初始的长度为b字节的密钥。
产生初始密钥的函数
*/
void IniTIalKey(unsigned char* KeyK,int b)
{
int i,j;
int inTISeed=3;
for( i=0;i《b;i++)//初始化
{
KeyK[i]=0;
}
KeyK[0]=inTISeed;
printf(“初始主密钥(16字节共128位):%.2lx ”,KeyK[0]);
for(j=1;j《b;j++)//生成
{
KeyK[j] = (BYTE)( (int)pow(3,j)%(255-j) ); //pow(x,y) x^y: 2^3=8
printf(“%.2X ”,KeyK[j]);
//KeyK[j] = (BYTE) ( ((int)(pow(double(3),j))%(255-j)));
}
printf(“\n”);
}
/**4、 密钥扩展函数
由于需加密r轮,每轮需要两个子密钥,所以需要密钥扩展函数根据初始密钥来扩展出2r+2个子密钥。
产生子密钥的函数
*/
void generateChildKey(unsigned char* KeyK,FOURBYTEINT* ChildKeyS)
{
//const double e = 2.718281828459;
//const double Phia = 1.618033988749;
int PW = 0xB7E15163;//0xb7e1;
int QW = 0x9E3779B9;//0x9e37;//genggai
int i;
int u =w/8;// b/8;
FOURBYTEINT A,B,X,Y;
FOURBYTEINT L[4]; //c=16*8/32
A=B=X=Y=0;
//初始化数组S
ChildKeyS[0]=PW;
printf(“\n初始子密钥(没有主密钥的参与):\n%.8X ”, ChildKeyS[0]);
for (i=1;i《t;i++) //t=26
{
if(i%13==0)printf(“\n”);
ChildKeyS[i]=(ChildKeyS[i-1]+ QW);
printf(“%.8X ”, ChildKeyS[i]);
}
printf(“\n”);
//将K数组转换为L数组
for(i=0;i《c;i++)//初始化L数组c=8
{
L[i]=0;
}
for (i=b-1;i!=-1; i--)//b=16 转换主密钥数组(16个 单位为8bit)为L数组(8个单位为16bit),数组L每一元素长为16bit,数组K每一元素长为8bit
{
L[i/u] = (L[i/u]《《8)+KeyK[i];
}
printf(“\n把主密钥变换为4字节单位:\n”);
for (i=0;i《c;i++)//16进制输出gaidong
{
printf(“%.8X ”,L[i]);
}
printf(“\n\n”);
//产生子密钥,存储在ChildKeyS中
for(i=0;i《3*t;i++)
{
X = ChildKeyS[A] = ROTL(ChildKeyS[A]+X+Y,3);
A = (A+1) % t;
Y = L[B] = ROTL(L[B]+X+Y,(X+Y));
B = (B+1) % c;
}
printf(“生成的子密钥(初始主密钥参与和初始子密钥也参与):”);
for (i=0;i《t;i++)//16进制输出
{
if(i%13==0)printf(“\n”);
printf(“%.8X ”,ChildKeyS[i]);
}
printf(“\n\n”);
}
/**5、 加密函数
加密函数
*/
void Encipher(FOURBYTEINT * In,FOURBYTEINT * Out,FOURBYTEINT* S)
{
FOURBYTEINT X,Y; //定义两个16位存储器
int i,j;
for(j=0;j《NoOfData;j+=2)
{
X = In[j]+S[0]; //In[j]+S[0];
Y = In[j+1]+S[1]; //In[j+1]+S[1];
for( i=1;i《=r;i++)
{
X=ROTL((X^Y),Y) + S[2*i]; // X=ROTL((X^Y),Y) + S[2*i]; 异或,循环移位,相加 //ROTL(x,y) (((x)《《(y&(w-1))) | ((x)》》(w-(y&(w-1)))))
Y=ROTL((Y^X),X) + S[2*i+1]; //Y=ROTL((Y^X),X) + S[2*i+1];
}
Out[j]=X;
Out[j+1]=Y; //密文
}
}
/**6、 解密函数
解密函数
*/
void Decipher(FOURBYTEINT* In,FOURBYTEINT* Out,FOURBYTEINT* S)
{
int i=0,j;
FOURBYTEINT X,Y;
for(j=0;j《NoOfData;j+=2)
{
X = In[j];
Y = In[j+1];
for(i=r;i》0;i--)
{
Y = ROTR(Y-S[2*i+1],X)^X; //Y = ROTR(Y-S[2*i+1],X)^X;相减,循环移位,异或 //ROTR(x,y) (((x)》》(y&(w-1))) | ((x)《《(w-(y&(w-1)))))
X = ROTR(X-S[2*i],Y)^Y; // X = ROTR(X-S[2*i],Y)^Y;
}
Out[j]=X - S[0]; //Out[j]=X - S[0];
Out[j+1]=Y - S[1]; //明文 Out[j+1]=Y - S[1];
}
}
/**7、 主函数测试
主函数
*/
int main(void)
{
int k;
FOURBYTEINT ChildKeyS[2*12+2]; // r=12 子密钥个数为26
FOURBYTEINT ChildKey1[26]; //
BYTE KeyK[16]; //8bit=byte 16=b 主密钥共16字节
FOURBYTEINT Source[]={0xfffff2fe,0x56211681,0xee111560,0x44575555}; //测试明文
FOURBYTEINT Dest[NoOfData]; //用来存储密文
FOURBYTEINT Data[NoOfData]={0}; //用来存储解密后的密文
InitialKey(KeyK,b);//生成初始密钥
generateChildKey(KeyK,ChildKeyS); //根据初始密钥生成子密钥
printf(“加密以前的明文:”);
for (k=0;k《NoOfData;k++)
{
if (k%2==0)
{
printf(“ ”);
}
printf(“%.8X ”,Source[k]); //16进制输出
}
printf(“\n”);
for(k=0;k《26;k++)
{ //************************************有问题
ChildKey1[k]=ChildKeyS[k];//如果此处自定义简单的数值为加密密钥,则可以解密出密文
}
Encipher(Source,Dest,ChildKey1); //加密
printf(“\n”);
printf(“加密以后的密文:”);
for (k=0;k《NoOfData;k++)
{
if (k%2==0)
{
printf(“ ”);
}
printf(“%.8X ”,Dest[k]);
}
printf(“\n”);
Decipher(Dest,Data,ChildKey1); //解密
printf(“解密以后的明文:”);
for (k=0;k《NoOfData;k++)
{
if (k%2==0)
{
printf(“ ”);
}
printf(“%.8X ”,Data[k]);
}
printf(“\n”);
//printf(“sizeof unsigned short int: %d”,sizeof(unsigned short int));
// system(“pause\n”);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
/*RC5 C代码实现
w/r/b=16/12/16
基本的RC5 3种算法组成,即密钥扩展算法、加密算法和解密算法。故RC5的C语言实现也由以下几个部分构成。
1、 参数的定义
*/
#include 《stdlib.h》
#include 《stdio.h》
#include 《string.h》
#include 《math.h》
int w=16;//字长
int r=10;//12;//轮数12
int b=16;//密钥字节个数
int t=26;//2*r+2=12*2+2=26
int c=8; //b*8/w = 16*8/16
//typedef unsigned long int FOURBYTEINT;//四字节
typedef unsigned short int TWOBYTEINT;//2字节
typedef unsigned char BYTE;
void InitialKey(unsigned char* KeyK,int b);
void generateChildKey(unsigned char* KeyK,TWOBYTEINT* ChildKeyS);
void Encipher(TWOBYTEINT* In,TWOBYTEINT* Out,TWOBYTEINT* S);
void Decipher(TWOBYTEINT* In,TWOBYTEINT* Out,TWOBYTEINT* S);
#define NoOfData 4
/**2、循环移位函数
由于在生成子密钥,加密,解密过程中都要进行循环移位,故要首先定义循环以为函数。
* 循环左移和右移函数
* x : 被循环的数
* y : 将要循环的位数
*/
#define ROTL(x,y) (((x)《《(y&(w-1))) | ((x)》》(w-(y&(w-1)))))
#define ROTR(x,y) (((x)》》(y&(w-1))) | ((x)《《(w-(y&(w-1)))))
/**3、 初始密钥产生函数
生成一个初始的长度为b字节的密钥。
产生初始密钥的函数
*/
void InitialKey(unsigned char* KeyK,int b)
{
int i,j;
int intiSeed=3;
for( i=0;i《b;i++)//初始化
{
KeyK[i]=0;
}
KeyK[0]=intiSeed;
printf(“初始主密钥(16字节共128位):%.2lx ”,KeyK[0]);
for(j=1;j《b;j++)//生成
{
KeyK[j] = (BYTE)( (int)pow(3,j)%(255-j) ); //pow(x,y) x^y: 2^3=8
printf(“%.2X ”,KeyK[j]);
//KeyK[j] = (BYTE) ( ((int)(pow(double(3),j))%(255-j)));
}
printf(“\n”);
}
/**4、 密钥扩展函数
由于需加密r轮,每轮需要两个子密钥,所以需要密钥扩展函数根据初始密钥来扩展出2r+2个子密钥。
产生子密钥的函数
*/
void generateChildKey(unsigned char* KeyK,TWOBYTEINT* ChildKeyS)
{
//const double e = 2.718281828459;
//const double Phia = 1.618033988749;
int PW = 0xb7e1;
int QW = 0x9e37;//genggai
int i;
int u = w/8;
TWOBYTEINT A,B,X,Y;
TWOBYTEINT L[8]; //c=b*8/w=8
A=B=X=Y=0;
//初始化数组S
ChildKeyS[0]=PW;
printf(“\n初始子密钥(没有主密钥的参与):\n%.4lx ”, ChildKeyS[0]);
for (i=1;i《t;i++) //t=26
{
if(i%13==0)printf(“\n”);
ChildKeyS[i]=(ChildKeyS[i-1]+ QW);
printf(“%.4X ”, ChildKeyS[i]);
}
printf(“\n”);
//将K数组转换为L数组
for(i=0;i《c;i++)//初始化L数组c=8
{
L[i]=0;
}
for (i=b-1;i!=-1; i--)//b=16 转换主密钥数组(16个 单位为8bit)为L数组(8个单位为16bit),数组L每一元素长为16bit,数组K每一元素长为8bit
{
L[i/u] = (L[i/u]《《8)+KeyK[i];
}
printf(“\n把主密钥变换为2字节单位:\n”);
for (i=0;i《c;i++)//16进制输出gaidong
{
printf(“%.4X ”,L[i]);
}
printf(“\n\n”);
//产生子密钥,存储在ChildKeyS中
for(i=0;i《3*t;i++)
{
X = ChildKeyS[A] = ROTL(ChildKeyS[A]+X+Y,3);
A = (A+1) % t;
Y = L[B] = ROTL(L[B]+X+Y,(X+Y));
B = (B+1) % c;
}
printf(“生成的子密钥(初始主密钥参与和初始子密钥也参与):”);
for (i=0;i《t;i++)//16进制输出
{
if(i%13==0)printf(“\n”);
printf(“%.4X ”,ChildKeyS[i]);
}
printf(“\n\n”);
}
/**5、 加密函数
加密函数
*/
void Encipher(TWOBYTEINT * In,TWOBYTEINT * Out,TWOBYTEINT* S)
{
TWOBYTEINT X,Y; //定义两个16位存储器
int i,j;
for(j=0;j《NoOfData;j+=2)
{
X = In[j]+S[0]; //In[j]+S[0];
Y = In[j+1]+S[1]; //In[j+1]+S[1];
for( i=1;i《=r;i++)
{
X=ROTL((X^Y),Y) + S[2*i]; // X=ROTL((X^Y),Y) + S[2*i]; 异或,循环移位,相加 //ROTL(x,y) (((x)《《(y&(w-1))) | ((x)》》(w-(y&(w-1)))))
Y=ROTL((Y^X),X) + S[2*i+1]; //Y=ROTL((Y^X),X) + S[2*i+1];
}
Out[j]=X;
Out[j+1]=Y; //密文
}
}
/**6、 解密函数
解密函数
*/
void Decipher(TWOBYTEINT* In,TWOBYTEINT* Out,TWOBYTEINT* S)
{
int i=0,j;
TWOBYTEINT X,Y;
for(j=0;j《NoOfData;j+=2)
{
X = In[j];
Y = In[j+1];
for(i=r;i》0;i--)
{
//***********重要*****************一定要强制转换为unsigned short int 否则循环右移出错
Y = ROTR((unsigned short int)(Y-S[2*i+1]),X)^X; //Y = ROTR(Y-S[2*i+1],X)^X;相减,循环移位,异或 //ROTR(x,y) (((x)》》(y&(w-1))) | ((x)《《(w-(y&(w-1)))))
X = ROTR((unsigned short int)(X-S[2*i]),Y)^Y; // X = ROTR(X-S[2*i],Y)^Y;
}
Out[j]=X - S[0]; //Out[j]=X - S[0];
Out[j+1]=Y - S[1]; //明文 Out[j+1]=Y - S[1];
}
}
/**7、 主函数测试
主函数
*/
int main(void)
{
unsigned int aa=0xffffFFF1;
unsigned int bb=0xffffFFF2;
unsigned int cc;
int k;
TWOBYTEINT ChildKeyS[2*12+2]; // r=12 子密钥个数为26
TWOBYTEINT ChildKey1[26]; //
BYTE KeyK[16]; //8bit=byte 16=b 主密钥共16字节
TWOBYTEINT Source[]={25142,1681,11561,5555}; //测试明文
TWOBYTEINT Dest[NoOfData]; //用来存储密文
TWOBYTEINT Data[NoOfData]={0}; //用来存储解密后的密文
InitialKey(KeyK,b);//生成初始密钥
generateChildKey(KeyK,ChildKeyS); //根据初始密钥生成子密钥
printf(“加密以前的明文:”);
for (k=0;k《NoOfData;k++)
{
printf(“%.4lX ”,Source[k]); //16进制输出
}
printf(“\n”);
for(k=0;k《26;k++)
{ //************************************有问题
ChildKey1[k]=ChildKeyS[k];//如果此处自定义简单的数值为加密密钥,则可以解密出密文
// printf(“%.4lX ”,ChildKey1[k]);
}
Encipher(Source,Dest,ChildKey1); //加密
printf(“\n”);
printf(“加密以后的密文:”);
for (k=0;k《NoOfData;k++)
{
printf(“%.4lX ”,Dest[k]);
}
printf(“\n”);
Decipher(Dest,Data,ChildKey1); //解密
printf(“解密以后的明文:”);
for (k=0;k《NoOfData;k++)
{
printf(“%.4lX ”,Data[k]);
}
printf(“\n”);
cc=aa+bb;
// printf(“\n%16X\n”,cc);
// printf(“%8X\n”,(cc-aa));
//printf(“sizeof unsigned short int: %d”,sizeof(unsigned short int));
// system(“pause\n”);
}
技术专区
- Alexa语音服务软件扩展STM32Cube
- 结合DNN API驱动未来神经网络应用的解决方案
- 针对于高端移动通信和汽车市场的四集群设计
- 一款基于帧捕捉的开源图形调试器应用设计
- 即将成为标准配置的最新安全技术:后视摄像系统