RC4加密解密算法

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<kl;++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="<<j<<endl;
			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<lenFile;++i){
		outks<<(k[i]);
	}
	outks.close();
 
	//明文内容读入bits中
	unsigned char *bits=new unsigned char[lenFile];
	in.read((char *)bits,lenFile);
	in.close();
 
 
	out.open(ciphertext);
	//将明文按字节依次与密钥流异或后输出到密文文件中
	for(int i=0;i<lenFile;++i){
		out<<(unsigned 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;i<lenFile;++i)
		out<<(unsigned 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

解密文件:我爱小兔子!

阅读更多
换一批

没有更多推荐了,返回首页