RC4加密算法C++实现

RC4算法简介

RC4是由Rivest于1987年设计的一种序列密码，被广泛应用于Windows和无线通信系统等；
RC4是一种基于字节的序列的非移位寄存器序列，输出字节流；
RC4使用了一个28字节大小的非线性数据表(简称S表)；S表的值S0, S1, …, S255是数字0到255的一个排列。对S表进行非线性变换，得到密钥流；
RC4支持不同密钥长度，美国政府规定用于出口的密钥长度不得超过40位。
RC4算法简单、高效，特别适合软件实现，加密速度比DES大约快10倍

在WLAN的WEP协议中，支持 64 位和128 位加密，由于密钥是5或13个ASCII 字符，64 位加密有时称为 40 位加密;128 位加密有时称为 104 位加密。其中的24bit由初始化向量填充，但因为初始向量太短而不安全,若正确使用密钥，则RC4依然安全

RC4算法原理

RC4对S表的初始化算法: 两个计数器I和J，I=0，J=0

1. 对S表进行线性填充：SI=I, 0 ≤I<255
2. 用密钥填充另一个256字节的数组K，如果密钥长度小于256字节，则依次重复填充，直至填满这个数组， K0, K1, …, K255
3. 对于I=0到255重复以下步骤：
   (1) J=J+SI+KI mod 256
   (2) 交换SI和SJ

S表的开始256个状态舍弃则更安全

RC4输出密钥流字节z的算法

1. I=0，J=0
2. I=I+1 mod 256
3. J=J+SI mod 256
4. 交换SI和SJ
5. t=SI+SJ mod 256
6. z=St .
   
   
   

C++实现

加密函数为char* RC4(char* C,char* key)（解密只需再做一次RC4加密）
另外还有两个辅助函数void char_2_Hex(char* Char, char* Hex) void Hex_2_char(char*Hex, char* Char)用于将char型字符串与16进制（以字符串保存）互转

#include 
#include 
using namespace std;

//char -> 16
void char_2_Hex(char* Char, char* Hex)
{
    int length = strlen(Char);
    for (size_t i = 0; i < length; i++)
    {
        int tmp = int(Char[i]);
        if(Char[i] < 0)
        tmp = (-1) * Char[i] + 128;
        int high = tmp / 16;
        int low = tmp % 16;
        char HIHG;
        char LOW;

        if(high >= 10)
            HIHG = char(high - 10 + 65);
        else
            HIHG = char(high + 48);

        if(low >= 10)
            LOW = char(low - 10 + 65);
        else
            LOW = char(low + 48);

        Hex[2*i] = HIHG;
        Hex[2*i+1] = LOW;
    }
}

//16 -> char 
void Hex_2_char(char*Hex, char* Char)
{
    int length = strlen(Hex) / 2;
    for (size_t i = 0; i < length; i++)
    {
        int high;
        int low;
        if(int(Hex[2*i])>=65)
            high = int(Hex[2*i] - 65 + 10);
        else
            high = int(Hex[2*i]- 48);
    
        if(int(Hex[2*i+1])>=65)
            low = int(Hex[2*i+1] - 65 + 10);
        else
            low = int(Hex[2*i+1] - 48);

        Char[i] = char(high*16 + low);
    }
}



char* RC4(char* C,char* key)
{
 int S[256];
 int T[256];

 int  count = 0;
count = strlen(key);

 for(int i = 0; i < 256; i++)
 {
     S[i] = i;
     int tmp = i % count;
     T[i] = key[tmp];
 }

 int j = 0;

 for(int  i = 0; i < 256; i++)
 {
     j = (j + S[i] + T[i]) % 256;
     int tmp;
     tmp = S[j];
     S[j] = S[i];
     S[i] = tmp;
 }
 
 int length = 0;
 length = strlen(C);

 int i,j;
 i=0,j=0;
 
 for(int p = 0; p < length; p++)
 {

    i = (i + 1) % 256;
    j = (j + S[i]) % 256;
    int tmp;
    tmp = S[j];
    S[j] = S[i];
    S[i] = tmp;
    
    int k = S[(S[i] + S[j]) % 256];
    C[p]=C[p]^k;
 }
 
 return C;
}


int main()
{

    char A[1000] = "aaaaaaaaaaa;
    cout << "C =" << A <