c语言实现RC5分组密钥算法的应用

  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混合,混合过程如下:

  c语言实现RC5分组密钥算法的应用

  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驱动未来神经网络应用的解决方案
  • 针对于高端移动通信和汽车市场的四集群设计
  • 一款基于帧捕捉的开源图形调试器应用设计
  • 即将成为标准配置的最新安全技术:后视摄像系统
  • c语言实现RC5分组密钥算法的应用已关闭评论
    A+
发布日期:2019年07月14日  所属分类:物联网