RC5分组密码算法是1994由麻萨诸塞技术研究所的Ronald L. Rivest教授发明的，并由RSA实验室分析。它是参数可变的分组密码算法，三个可变的参数是：分组大小、密钥大小和加密轮数。在此算法中使用了三种运算：异或、加和循环。
RC5是种比较新的算法，Rivest设计了RC5的一种特殊的实现方式，因此RC5算法有一个面向字的结构：RC5-w/r/b，这里w是字长其值可以是16、32或64对于不同的字长明文和密文块的分组长度为2w位，r是加密轮数，b是密钥字节长度。RC5是一个分组长度可变的密码算法.
加密解密
1、创建密钥组
RC5算法加密时使用了2r+2个密钥相关的的32位字： 这里r表示加密的轮数。
2、加密处理
在创建完密钥组后开始进行对明文的加密。
3、解密处理
RSA试验室花费了相当的时间来分析64位分组的RC5算法，在5轮后统计特性看起来非常好，在6轮后线性分析就是安全的了。在8轮后，每一个明文位至少影响一个循环。Rivest推荐至少12轮，甚至可能是16轮。轮数可以进行选择，一般是8轮、12轮或16轮。
代码如下（在实际项目中经过大量测试过）：
RC5加密算法头文件
/*
* rc5.h
*
* Created on: 2015年12月28日
* Author: chen
*/
#ifndef RC5_H_
#define RC5_H_
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define RC5_ENCRYPT 1
#define RC5_DECRYPT 0
/* 32 bit. For Alpha, things may get weird */
#define RC5_32_INT unsigned int
#define RC5_32_BLOCK 8
#define RC5_32_KEY_LENGTH 16 /* This is a default, max is 255 */
/* This are the only values supported. Tweak the code if you want more
* * The most supported modes will be
* * RC5-32/12/16
* * RC5-32/16/8
* */
#define RC5_8_ROUNDS 8
#define RC5_12_ROUNDS 12
#define RC5_16_ROUNDS 16
typedef struct rc5_key_st
{
/* Number of rounds */
int rounds;
RC5_32_INT data[2*(RC5_16_ROUNDS+1)];
} RC5_32_KEY;
#define c2ln(c,l1,l2,n) { \
c+=n; \
l1=l2=0; \
switch (n) { \
case 8: l2 =((RC5_32_INT )(*(--(c))))<<24L; \
case 7: l2|=((RC5_32_INT )(*(--(c))))<<16L; \
case 6: l2|=((RC5_32_INT )(*(--(c))))<< 8L; \
case 5: l2|=((RC5_32_INT )(*(--(c)))); \
case 4: l1 =((RC5_32_INT )(*(--(c))))<<24L; \
case 3: l1|=((RC5_32_INT )(*(--(c))))<<16L; \
case 2: l1|=((RC5_32_INT )(*(--(c))))<< 8L; \
case 1: l1|=((RC5_32_INT )(*(--(c)))); \
} \
}
#undef c2l
#define c2l(c,l) (l =((RC5_32_INT )(*((c)++))) , \
l|=((RC5_32_INT )(*((c)++)))<< 8L, \
l|=((RC5_32_INT )(*((c)++)))<<16L, \
l|=((RC5_32_INT )(*((c)++)))<<24L)
#define RC5_32_MASK 0xffffffffL
#define RC5_16_P 0xB7E1
#define RC5_16_Q 0x9E37
#define RC5_32_P 0xB7E15163L
#define RC5_32_Q 0x9E3779B9L
#define RC5_64_P 0xB7E151628AED2A6BLL
#define RC5_64_Q 0x9E3779B97F4A7C15LL
#define ROTATE_l32(a,n) (((a)<<(int)(n))|((a)>>(32-(int)(n))))
#define ROTATE_r32(a,n) (((a)>>(int)(n))|((a)<<(32-(int)(n))))
/*
* #define ROTATE_l32(a,n) _lrotl(a,n)
* #define ROTATE_r32(a,n) _lrotr(a,n)
* */
#define E_RC5_32(a,b,s,n) \
a^=b; \
a=ROTATE_l32(a,b); \
a+=s[n]; \
a&=RC5_32_MASK; \
b^=a; \
b=ROTATE_l32(b,a); \
b+=s[n+1]; \
b&=RC5_32_MASK;
#define D_RC5_32(a,b,s,n) \
b-=s[n+1]; \
b&=RC5_32_MASK; \
b=ROTATE_r32(b,a); \
b^=a; \
a-=s[n]; \
a&=RC5_32_MASK; \
a=ROTATE_r32(a,b); \
a^=b;
typedef void (* f_RC5_32_decrypt)(RC5_32_INT *d, RC5_32_KEY *key);
typedef void (* f_RC5_32_encrypt)(RC5_32_INT *d, RC5_32_KEY *key);
typedef void (* f_RC5_32_set_key)(RC5_32_KEY *key, int len, const unsigned char *data,
int rounds);
#endif /* RC5_H_ */RC5 加密算法源文件
#include "rc5.h"
void RC5_32_set_key(RC5_32_KEY *key, int len, const unsigned char *data,
int rounds)
{
RC5_32_INT L[64], l, ll, A, B, *S, k;
int i, j, m, c, t, ii, jj;
if ((rounds != RC5_16_ROUNDS) && (rounds != RC5_12_ROUNDS)
&& (rounds != RC5_8_ROUNDS))
rounds = RC5_16_ROUNDS;
key->rounds = rounds;
S = &(key->data[0]);
j = 0;
for (i = 0; i <= (len - 8); i += 8)
{
c2l(data, l);
L[j++] = l;
c2l(data, l);
L[j++] = l;
}
ii = len - i;
if (ii)
{
k = len & 0x07;
c2ln(data, l, ll, k);
L[j + 0] = l;
L[j + 1] = ll;
}
c = (len + 3) / 4;
t = (rounds + 1) * 2;
S[0] = RC5_32_P;
for (i = 1; i < t; i++)
S[i] = (S[i - 1] + RC5_32_Q) & RC5_32_MASK;
j = (t > c) ? t : c;
j *= 3;
ii = jj = 0;
A = B = 0;
for (i = 0; i < j; i++)
{
k = (S[ii] + A + B) & RC5_32_MASK;
A = S[ii] = ROTATE_l32(k, 3);
m = (int) (A + B);
k = (L[jj] + A + B) & RC5_32_MASK;
B = L[jj] = ROTATE_l32(k, m);
if (++ii >= t)
ii = 0;
if (++jj >= c)
jj = 0;
}
}
//加密函数
void RC5_32_encrypt(RC5_32_INT *d, RC5_32_KEY *key)
{
RC5_32_INT a, b, *s;
s = key->data;
a = d[0] + s[0];
b = d[1] + s[1];
E_RC5_32(a, b, s, 2);
E_RC5_32(a, b, s, 4);
E_RC5_32(a, b, s, 6);
E_RC5_32(a, b, s, 8);
E_RC5_32(a, b, s, 10);
E_RC5_32(a, b, s, 12);
E_RC5_32(a, b, s, 14);
E_RC5_32(a, b, s, 16);
if (key->rounds == 12)
{
E_RC5_32(a, b, s, 18);
E_RC5_32(a, b, s, 20);
E_RC5_32(a, b, s, 22);
E_RC5_32(a, b, s, 24);
}
else if (key->rounds == 16)
{
/* Do a full expansion to avoid a jump */
E_RC5_32(a, b, s, 18);
E_RC5_32(a, b, s, 20);
E_RC5_32(a, b, s, 22);
E_RC5_32(a, b, s, 24);
E_RC5_32(a, b, s, 26);
E_RC5_32(a, b, s, 28);
E_RC5_32(a, b, s, 30);
E_RC5_32(a, b, s, 32);
}
d[0] = a;
d[1] = b;
}
//解密函数
void RC5_32_decrypt(RC5_32_INT *d, RC5_32_KEY *key)
{
RC5_32_INT a, b, *s;
s = key->data;
a = d[0];
b = d[1];
if (key->rounds == 16)
{
D_RC5_32(a, b, s, 32);
D_RC5_32(a, b, s, 30);
D_RC5_32(a, b, s, 28);
D_RC5_32(a, b, s, 26);
/* Do a full expansion to avoid a jump */
D_RC5_32(a, b, s, 24);
D_RC5_32(a, b, s, 22);
D_RC5_32(a, b, s, 20);
D_RC5_32(a, b, s, 18);
}
else if (key->rounds == 12)
{
D_RC5_32(a, b, s, 24);
D_RC5_32(a, b, s, 22);
D_RC5_32(a, b, s, 20);
D_RC5_32(a, b, s, 18);
}
D_RC5_32(a, b, s, 16);
D_RC5_32(a, b, s, 14);
D_RC5_32(a, b, s, 12);
D_RC5_32(a, b, s, 10);
D_RC5_32(a, b, s, 8);
D_RC5_32(a, b, s, 6);
D_RC5_32(a, b, s, 4);
D_RC5_32(a, b, s, 2);
d[0] = a - s[0];
d[1] = b - s[1];
}加密解密封装头文件
/*
* CEncrypt.h
*
* Created on: 2015年12月28日
* Author: chen
*/
#ifndef CENCRYPT_H_
#define CENCRYPT_H_
#include "rc5.h"
//声明加密函数
extern void RC5_32_set_key(RC5_32_KEY *key, int len, const unsigned char *data,int rounds);
extern void RC5_32_encrypt(RC5_32_INT *d, RC5_32_KEY *key);
extern void RC5_32_decrypt(RC5_32_INT *d, RC5_32_KEY *key);
class CEncrypt
{
public:
CEncrypt();
enum encMethod
{
ENCDEC_NONE,
ENCDEC_RC5
};
void setEncMethod(encMethod method);
void set_key_rc5(const unsigned char *data, int nLen, int rounds);
int encdec(void *data, unsigned int nLen, bool enc);
void setEncMask(unsigned int m);
void setDecMask(unsigned int m);
int encdec_rc5(unsigned char *data, unsigned int nLen, bool enc);
private:
RC5_32_KEY key_rc5;
bool haveKey_rc5;
encMethod method;
unsigned int enc_mask;//需要加密的位置(默认都所有位置需要加密和解密，每比特标示需要加密8字节，依次循环)
unsigned int dec_mask;//需要解密的位置（跟加密位置一致）
};
#endif /* CENCRYPT_H_ */加密解密封装源文件
/*
* CEncrypt.cpp
*
* Created on: 2015年12月28日
* Author: chen
*/
#include "CEncrypt.h"
//加密解密封装源文件
CEncrypt::CEncrypt()
{
bzero(&key_rc5, sizeof(key_rc5));
haveKey_rc5 = false;
method = ENCDEC_NONE;
enc_mask = dec_mask = 0;
}
//设置加密方式
void CEncrypt::setEncMethod(encMethod m)
{
method = m;
enc_mask = dec_mask = RC5_32_MASK;//0xffffffffL
}
void CEncrypt::setEncMask(unsigned int m)
{
enc_mask = m;
}
void CEncrypt::setDecMask(unsigned int m)
{
dec_mask = m;
}
void CEncrypt::set_key_rc5(const unsigned char *data, int nLen, int rounds = RC5_8_ROUNDS)
{
::RC5_32_set_key(&key_rc5, nLen, data, rounds);
haveKey_rc5 = true;
}
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
int CEncrypt::encdec_rc5(unsigned char *data, unsigned int nLen, bool enc)
{
if (0==data) return -1;
unsigned int offset = 0;
while (offset<=nLen-8)
{
RC5_32_INT d[2];
if (0x80000000 & (enc?enc_mask:dec_mask))
{
memcpy(d, data+offset, sizeof(d));
if (enc)
RC5_32_encrypt(d, &key_rc5);
else
RC5_32_decrypt(d, &key_rc5);
memcpy(data+offset, d, sizeof(d));
}
offset += sizeof(d);//后移8字节
if (enc)
enc_mask = ROTATE_LEFT(enc_mask, 1);//循环左移
else
dec_mask = ROTATE_LEFT(dec_mask, 1);
}
return offset;
}
int CEncrypt::encdec(void *data, unsigned int nLen, bool enc)
{
if (ENCDEC_NONE==method) return -1;
if (ENCDEC_RC5==method) return encdec_rc5((unsigned char *)data, nLen, enc);
return -2;
}测试用例文件
/*
* testrc5.cpp
*
* Created on: 2015年12月28日
* Author: chen
*/
#include "CEncrypt.h"
int main()
{
unsigned char key[16] = { 0x3f,0x79,0xd5,0xe2,0x4a,0x8c,0xb6,0xc1,0xaf,0x31,0x5e,0xc7,0xeb,0x9d,0x6e,0xcb};//加密密钥
CEncrypt enc; /**< 加密接口 */
enc.setEncMethod(CEncrypt::ENCDEC_RC5);
enc.set_key_rc5((const unsigned char *)key, 16, 12);//加密密钥和轮数
char toEncrypt[32] = {0};
snprintf(toEncrypt,sizeof(toEncrypt),"123你好úù11\0\0\022");//加密前
printf("before Encrypt %s strlen(%d)\n",toEncrypt,strlen(toEncrypt));
int len = enc.encdec(toEncrypt,sizeof(toEncrypt),true);//加密
printf("after Encrypt %s len(%d)\n",toEncrypt,len);
len = enc.encdec(toEncrypt,sizeof(toEncrypt),false);//解密
printf("after decrypt %s len(%d) strlen(%d)\n",toEncrypt,len,strlen(toEncrypt));
if(toEncrypt[strlen(toEncrypt)] == '\0')
printf("strlen(%d) strlen(%d) + 1 is zero");
return 0;
}
