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”）;
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）