RC4加密解密算法123

       RC4是一种对称密码算法，它属于对称密码算法中的序列密码(streamcipher,也称为流密码)，它是可变密钥长度，面向字节操作的流密码。

RC4是流密码streamcipher中的一种，为序列密码。RC4加密算法是Ron Rivest在1987年设计出的密钥长度可变的加密算法簇。起初该算法是商业机密，直到1994年，它才公诸于众。由于RC4具有算法简单，运算速度快，软硬件实现都十分容易等优点，使其在一些协议和标准里得到了广泛应用。

流密码也属于对称密码，但与分组加密算法不同的是，流密码不对明文数据进行分组，而是用密钥生成与明文一样长短的密码流对明文进行加密，加解密使用相同的密钥。

RC4算法特点：(1)、算法简洁易于软件实现，加密速度快，安全性比较高；(2)、密钥长度可变，一般用256个字节。

        对称密码算法的工作方式有四种：电子密码本(ECB, electronic codebook)方式、密码分组链接(CBC, cipherblock chaining)方式、密文反馈(CFB, cipher-feedback)方式、输出反馈(OFB, output-feedback)方式。

         RC4算法采用的是输出反馈工作方式，所以可以用一个短的密钥产生一个相对较长的密钥序列。

         OFB方式的最大的优点是消息如果发生错误(这里指的是消息的某一位发生了改变，而不是消息的某一位丢失)，错误不会传递到产生的密钥序列上；缺点是对插入攻击很敏感，并且对同步的要求比较高。

         RC4的执行速度相当快，它大约是分块密码算法DES的5倍，是3DES的15倍，且比高级加密算法AES也快很多。RC4算法简单，实现容易。RC4的安全保证主要在于输入密钥的产生途径，只要在这方面不出现漏洞，采用128bit的密钥是非常安全的。

         RC4算法加密流程：包括密钥调度算法KSA和伪随机子密码生成算法PRGA两大部分(以密钥长度为256个字节为例)。

         密钥调度算法：首先初始化状态矢量S，矢量S中元素的值被按升序从0到255排列，即S[0]=00, S[1]=1, …, S[255]=255.同时建立一个临时矢量T，如果密钥K的长度为256字节，则将K赋给T。否则，若密钥长度为keylen字节，则将K的值赋给T的前keylen个元素，并循环重复用K的值赋给T剩下的元素，直到T的所有元素都被赋值。

      

在介绍RC4算法原理之前，先看看算法中的几个关键变量：

       1、密钥流：RC4算法的关键是根据明文和密钥生成相应的密钥流，密钥流的长度和明文的长度是对应的，也就是说明文的长度是500字节，那么密钥流也是500字节。当然，加密生成的密文也是500字节，因为密文第i字节=明文第i字节^密钥流第i字节；

       2、状态向量S：长度为256，S[0],S[1].....S[255]。每个单元都是一个字节，算法运行的任何时候，S都包括0-255的8比特数的排列组合，只不过值的位置发生了变换；

       3、临时向量T：长度也为256，每个单元也是一个字节。如果密钥的长度是256字节，就直接把密钥的值赋给T，否则，轮转地将密钥的每个字节赋给T；

       4、密钥K：长度为1-256字节，注意密钥的长度keylen 与明文长度、密钥流的长度没有必然关系，通常密钥的长度趣味16字节（128比特）。

RC4的原理分为三步：

1、初始化S和T

for i=0 to 255 do

   S[i] =i;

   T[i]=K[ imodkeylen ];

2、初始排列S

for i=0 to 255 do

   j= ( j+S[i]+T[i])mod256;

   swap(S[i],S[j]);

3、产生密钥流

for r=0 to len do  //r为明文长度，r字节

   i=(i+1) mod 256;

   j=(j+S[i])mod 256;

   swap(S[i],S[j]);

   t=(S[i]+S[j])mod 256;

   k[r]=S[t];

下面给出RC4加密解密的C++实现：

加密类：

/*
	加密类
*/
class RC4 {
public:
	/*
		构造函数，参数为密钥长度
	*/
	RC4(int kl):keylen(kl) {
		srand((unsigned)time(NULL));
		for(int i=0;i//随机生产长度为keylen字节的密钥
			int tmp=rand()%256;
			K.push_back(char(tmp));
		}
	}
	/*
		由明文产生密文
	*/
	void encryption(const string &,const string &,const string &);

private:
	unsigned char S[256]; //状态向量，共256字节
	unsigned char T[256]; //临时向量，共256字节
	int keylen;		//密钥长度，keylen个字节，取值范围为1-256
	vector<char> K;	  //可变长度密钥
	vector<char> k;	  //密钥流

	/*
		初始化状态向量S和临时向量T，供keyStream方法调用
	*/
	void initial() {
		for(int i=0;i<256;++i){
			S[i]=i;
			T[i]=K[i%keylen];
		}
	}
	/*
		初始排列状态向量S，供keyStream方法调用
	*/
	void rangeS() {
		int j=0;
		for(int i=0;i<256;++i){
			j=(j+S[i]+T[i])%256;
			//cout<<"j="<
			S[i]=S[i]+S[j];
			S[j]=S[i]-S[j];
			S[i]=S[i]-S[j];
		}
	}
	/*
		生成密钥流
		len:明文为len个字节
	*/
	void keyStream(int len);

};
void RC4::keyStream(int len) {
	initial();
	rangeS();

	int i=0,j=0,t;
	while(len--){
		i=(i+1)%256;
		j=(j+S[i])%256;

		S[i]=S[i]+S[j];
		S[j]=S[i]-S[j];
		S[i]=S[i]-S[j];

		t=(S[i]+S[j])%256;
		k.push_back(S[t]);
	}
}
void RC4::encryption(const string &plaintext,const string &ks,const string &ciphertext) {
	ifstream in;
	ofstream out,outks;

	in.open(plaintext);
	//获取输入流的长度
	in.seekg(0,ios::end);
	int lenFile=in.tellg();
	in.seekg(0, ios::beg);

	//生产密钥流
	keyStream(lenFile);
	outks.open(ks);
	for(int i=0;i//明文内容读入bits中
	unsigned char *bits=new unsigned char[lenFile];
	in.read((char *)bits,lenFile);
	in.close();


	out.open(ciphertext);
	//将明文按字节依次与密钥流异或后输出到密文文件中
	for(int i=0;iunsigned char)(bits[i]^k[i]);
	}
        out.close();

	delete []bits;
}

解密类：

/*
	解密类
*/
class RC4_decryption{
public:
	/*
		构造函数，参数为密钥流文件和密文文件
	*/
	RC4_decryption(const string ks,const string ct):keystream(ks),ciphertext(ct) {}
	/*
		解密方法，参数为解密文件名
	*/
	void decryption(const string &);

private:
	string ciphertext,keystream;
};
void RC4_decryption::decryption(const string &res){
	ifstream inks,incp;
	ofstream out;

	inks.open(keystream);
	incp.open(ciphertext);

	//计算密文长度
	inks.seekg(0,ios::end);
	const int lenFile=inks.tellg();
	inks.seekg(0, ios::beg);
	//读入密钥流
	unsigned char *bitKey=new unsigned char[lenFile];
	inks.read((char *)bitKey,lenFile);
	inks.close();
	//读入密文
	unsigned char *bitCip=new unsigned char[lenFile];
	incp.read((char *)bitCip,lenFile);
	incp.close();

	//解密后结果输出到解密文件
	out.open(res);
	for(int i=0;iunsigned char)(bitKey[i]^bitCip[i]);

	out.close();
}

程序实现时，需要注意的是，状态向量数组S和临时向量数组T的类型应设为unsigned char，而不是char。因为在一些机器下，将char默认做为signed char看待，在算法中计算下标i，j的时候，会涉及char转int，如果是signed的char，那么将char的8位拷贝到int的低8位后，还会根据char的符号为，在int的高位补0或1。由于密钥是随机产生的，如果遇到密钥的某个字节的高位为1的话，那么计算得到的数组下标为负数，就会越界。

程序运行示例

main函数：

int main(){
	RC4 rc4(16); //密钥长16字节
	rc4.encryption("明文.txt","密钥流.txt","密文.txt");

	RC4_decryption decrypt("密钥流.txt","密文.txt");
	decrypt.decryption("解密文件.txt");

}

明文：我爱小兔子！

密文：'柀L&t餥6洲

密钥流：镈膺嚬3屽u

解密文件：我爱小兔子！

From：

http://blog.csdn.net/fengbingchun/article/details/42929883      这里面有调用OPENSSL中API的实例

http://www.tuicool.com/articles/AjAjm2

注：遇到RC4加密的数据 想解密数据 故此摘录