RC4加密算法初次接触以及深入学习

简单介绍：

RC4加密算法是大名鼎鼎的RSA三人组中的头号人物Ron Rivest在1987年设计的密钥长度可变的流加密算法簇。RC4算法是一种在电子信息领域加密的技术手段，用于无线通信网络，是一种电子密码，只有经过授权（缴纳相应费用）的用户才能享受该服务。和DES算法一样，是一种对称加密算法，也就是说使用的密钥为单钥（或称为私钥）。但不同于DES的是，RC4不是对明文进行分组处理，而是字节流的方式依次加密明文中的每一个字节，解密的时候也是依次对密文中的每一个字节进行解密。（ RC4是一种对称密码算法，它属于对称密码算法中的序列密码(streamcipher,也称为流密码)，它是可变密钥长度，面向字节操作的流密码。流密码也属于对称密码，但与分组加密算法不同的是，流密码不对明文数据进行分组，而是用密钥生成与明文一样长短的密码流对明文进行加密，加解密使用相同的密钥。）

何为对称加密算法。

对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。有时又叫传统密码算法，就是加密密钥能够从解密密钥中推算出来，同时解密密钥也可以从加密密钥中推算出来。而在大多数的对称算法中，加密密钥和解密密钥是相同的，所以也称这种加密算法为秘密密钥算法或单密钥算法。它要求发送方和接收方在安全通信之前，商定一个密钥。对称算法的安全性依赖于密钥，泄漏密钥就意味着任何人都可以对他们发送或接收的消息解密，所以密钥的保密性对通信的安全性至关重要。

　RC4算法的特点是算法简单，运行速度快，而且密钥长度是可变的，可变范围为1-256字节(8-2048比特)，在如今技术支持的前提下，当密钥长度为128比特时，用暴力法搜索密钥已经不太可行，所以可以预见RC4的密钥范围任然可以在今后相当长的时间里抵御暴力搜索密钥的攻击。实际上，如今也没有找到对于128bit密钥长度的RC4加密算法的有效攻击方法。

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

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

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

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

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

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比特）。

加密原理详细介绍：

1 , 通过密钥调度算法KSA初始化状态矢量S（S就是一个随机数发生器，称为S-box）

2 , 再通过伪随机数生成算法PRGA得到密钥流keystream

3 , 密钥流keystream 与明文进行xor运算得到密文，解密用 密钥流与密文xor

1.KSA

RC4首先使用密钥调度算法(KSA)来完成对大小为256的字节数组S(s-box)初始化及替换。在替换时使用密钥。其密钥长度一般取5~16字节，即40~128位，也可以更长，通常不超过256位。首先用0~255初始化数组S，然后使用密钥进行替换。



2.PRGA

数组S在完成初始化之后，输入密钥便不再被使用。密钥流的生成是从S[0]~S[255]，对每个S[i]，根据当前S的值，将S[i]与S中的另一字节置换。当S[255]完成转换后，操作继续重复执行。

得到的子密码k用以和明文进行XOR运算，得到密文，解密过程也完全相同。



接下来给出RC4加密算法的Java实现：

public class RC4Demo {
public static String decry_RC4(byte[] data, String key) {
if (data == null || key == null) {
return null;
}
return asString(RC4Base(data, key));
}

public static String decry_RC4(String data, String key) {
if (data == null || key == null) {
return null;
}
return new String(RC4Base(HexString2Bytes(data), key));
}

public static byte[] encry_RC4_byte(String data, String key) {
if (data == null || key == null) {
return null;
}
byte b_data[] = data.getBytes();
return RC4Base(b_data, key);
}

public static String encry_RC4_string(String data, String key) {
if (data == null || key == null) {
return null;
}
return toHexString(asString(encry_RC4_byte(data, key)));
}

private static String asString(byte[] buf) {
StringBuffer strbuf = new StringBuffer(buf.length);
for (int i = 0; i < buf.length; i++) {
strbuf.append((char) buf[i]);
}
return strbuf.toString();
}

private static byte[] initKey(String aKey) {
byte[] b_key = aKey.getBytes();
byte state[] = new byte[256];

for (int i = 0; i < 256; i++) {
state[i] = (byte) i;
}
int index1 = 0;
int index2 = 0;
if (b_key == null || b_key.length == 0) {
return null;
}
for (int i = 0; i < 256; i++) {
index2 = ((b_key[index1] & 0xff) + (state[i] & 0xff) + index2) & 0xff;
byte tmp = state[i];
state[i] = state[index2];
state[index2] = tmp;
index1 = (index1 + 1) % b_key.length;
}
return state;
}

private static String toHexString(String s) {
String str = "";
for (int i = 0; i < s.length(); i++) {
int ch = (int) s.charAt(i);
String s4 = Integer.toHexString(ch & 0xFF);
if (s4.length() == 1) {
s4 = '0' + s4;
}
str = str + s4;
}
return str;// 0x表示十六进制
}

private static byte[] HexString2Bytes(String src) {
int size = src.length();
byte[] ret = new byte[size / 2];
byte[] tmp = null;
tmp = src.getBytes();
for (int i = 0; i < size / 2; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}

private static byte uniteBytes(byte src0, byte src1) {
char _b0 = (char)Byte.decode("0x" + new String(new byte[] { src0 }))
.byteValue();
_b0 = (char) (_b0 << 4);
char _b1 = (char)Byte.decode("0x" + new String(new byte[] { src1 }))
.byteValue();
byte ret = (byte) (_b0 ^ _b1);
return ret;
}

private static byte[] RC4Base (byte [] input, String mKkey) {
int x = 0;
int y = 0;
byte key[] = initKey(mKkey);
int xorIndex;
byte[] result = new byte[input.length];

for (int i = 0; i < input.length; i++) {
x = (x + 1) & 0xff;
y = ((key[x] & 0xff) + y) & 0xff;
byte tmp = key[x];
key[x] = key[y];
key[y] = tmp;
xorIndex = ((key[x] & 0xff) + (key[y] & 0xff)) & 0xff;
result[i] = (byte) (input[i] ^ key[xorIndex]);
}
return result;
}

public static void main(String[] args){
String inputStr = "RC4加密Demo";
String key = "12341234567";
String str = encry_RC4_string(inputStr, key);
System.out.println(str);
System.out.println(decry_RC4(str, key));
}
结果如下： 71ebbdd59b476483406d01d507  //加密前
RC4加密Demo        //加密后
}

上边的这种Java代码，是商业级的，把所需的全部封装好了。但是用在移动端性能比较差。因此给出下面这种加密方法，适合移动端。

package cn.exercise.bianchengTest;

public class RC4test3 {

public static String RC4Encry(String aInput, String aKey) {
int[] iS = new int[256];
byte[] iK = new byte[256];
/*初始化S盒*/
for (int i = 0; i < 256; i++)
iS[i] = i;

int j = 1;
/*密钥填充256数组*/
for (int i = 0; i < 256; i++) {
iK[i] = (byte) aKey.charAt((i % aKey.length()));
}

j = 0;
/*打乱S盒*/
for (int i = 0; i < 255; i++) {
j = (j + iS[i] + iK[i]) % 256;
int temp = iS[i];
iS[i] = iS[j];
iS[j] = temp;
}
/*加解密数据*/
int i = 0;
j = 0;
char[] iInputChar = aInput.toCharArray();
char[] iOutputChar = new char[iInputChar.length];
for (int x = 0; x < iInputChar.length; x++) {
i = (i + 1) % 256;
j = (j + iS[i]) % 256
beb9
;
int temp = iS[i];
iS[i] = iS[j];
iS[j] = temp;
int t = (iS[i] + (iS[j] % 256)) % 256;
int iY = iS[t];
char iCY = (char) iY;
iOutputChar[x] = (char) (iInputChar[x] ^ iCY);
}

return new String(iOutputChar);

}

public static String RC4DeEncry(String aInput, String aKey) {
String rc4Encry = RC4Encry(aInput, aKey);
return rc4Encry;
}

public static void main(String[] args) {
String inputStr = "一二三四五一二三四五一二三四五一二三四五一二三四五一二三四五";
String key = "abcdefg";
//执行加密操作
String str = RC4Encry(inputStr, key);
//执行解密操作
String result = RC4DeEncry(str, key);

// 打印加密后的字符串
System.out.println(str);
// 打印解密后的字符串
System.out.println(result);
}

}

结果如下： 仵亵乏嚫丠仝丿亄噉丑丽亟仏嘎乣义久乙噚仍乯严乤嘛亊产任亹嘰仩   //打印加密后的字符串
一二三四五一二三四五一二三四五一二三四五一二三四五一二三四五    //打印解密后的字符串

最后也是最重要的一点，本人设计出了可用于多线程的RC4加密算法，等毕设做完就开源出来。