RC4算法的原理和实现

https://ift.tt/2KOKRRr

---

• before learnng
  • RC4 简介
  • RC4的安全性
  • 算法中的几个关键变量
    • 密钥流
    • 状态向量S
    • 暂时向量T
    • 密钥K
• 原理
  • 初始化S和T
  • 初始化排列S
  • 产生密钥流
• cpp 工程
• 参考

---

before learnng

RC4 简介

RC4和DES一样，是一种对称加密算法。通常常听见的对称加密算法是DES，不过RC4和DES不同的是，RC4是以字节流的方式一次加密明文中的每个字节，解密的时候也是以字节流的方式解密密文中的每个字节。

RC4介绍(wikipedia)

RC4的安全性

理论上来讲，RC4是很难通过暴力破解的。RC4中用到的key是[1,256]的unsigned char 字符串，可能性约等于256²⁵⁶ ，量级超级大。当时，如果密钥用的byte比较少那还是挺好爆破的。

算法中的几个关键变量

密钥流

RC4算法的关键是依据明文和密钥生成相应的密钥流。密钥流的长度和明文的长度是相对应的。也就说说明文的长度是500字节，那么密钥流也是500字节，加密生成的密文也是500字节。

密文的第i字节 = 明文的i字节 ^ 密钥流第i字节

状态向量S

长度为256。


S[0],S[1].....S[255]


每一个单元都是一个字节。算法执行的不论什么时候，S都包含0-255 的8比特数的排列组合。仅仅只是值的位置发生了变换。

暂时向量T

长度也为256，每一个单元也是一个字节。

假设密钥的长度是256个字节，那就直接把密钥的值赋给T，否则，轮转的将密钥的每一个字节赋给T。

密钥K

长度为1-256 字节。

注意：密钥的长度keylen 与明文长度，密钥流的长度没有必定关系。

原理

初始化S和T

for (int i = 0; i < 256;++i)
        {
            S[i] = i;
            T[i] = K[i%keylen];
        }

初始化排列S

//目的：让S的位置发生变化，并使得每个
void rangeS(){
        int j = 0;
        for (int i = 0; i < 256;i++)
        {
            j = (j + S[i] + T[i]) % 256;
            S[i] = S[i] + S[j];
            S[j] = S[i] - S[j];
            S[i] = S[i] - S[j];
        }
    }

产生密钥流

   
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]);
}
        

cpp 工程

// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <time.h>
#include <stdlib.h>
#include <vector>
#include <stdio.h>
using namespace std;
//////////////////////////////////////////////////////////////////////////
//  加密类

class RC4_EN{

public:
    // 构造函数。参数为密钥长度
    RC4_EN(int k1) :keylen(k1){
        srand((unsigned)time(NULL));

        //随机生成长度为keylen字节的密钥

        for (int i = 0; i < k1; ++i)
        {
            int tmp = rand() % 256;
            K.push_back(tmp);
        }
    }


    //初始化向量s和暂时向量T，供keyStream方法调用
    void inital(){
        
        for (int i = 0; i < 256;++i)
        {
            S[i] = i;
            T[i] = K[i%keylen];
        }
    }

    //初始排列状态向量S

    void rangeS(){
        int j = 0;
        for (int i = 0; i < 256;i++)
        {
            j = (j + S[i] + T[i]) % 256;
            S[i] = S[i] + S[j];
            S[j] = S[i] - S[j];
            S[i] = S[i] - S[j];
        }
    }

    //生成密钥流，
    // 参数：密文长度len
    void keystream(int len){
        inital();
        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 encryption(char* plaintext){
        
        int nTextSize = strlen(plaintext);
        
        //产生密钥流
        keystream(nTextSize);

        unsigned char* cyptertext = new unsigned char[nTextSize]();
        //生成密文
        for (int i = 0; i < nTextSize;i++)
        {
            cyptertext[i] = k[i] ^ plaintext[i];
        }

        //打印明文，密钥，和加密后的密文
        printf("-------加密完成--------------\n");
        printf("明文:%s\n", plaintext);
        printf("密钥流:");
        for (int i = 0; i < k.size();i++)
        {
            printf("%c", k[i]);
        }
        printf("\n");
        printf("密文:%x", cyptertext);

        delete[] cyptertext;

    }
private:
    int keylen;
    unsigned char S[256];//状态向量，共256字节
    unsigned char T[256];//暂时向量，共256字节
    vector<char>K; //可变长度密钥
    vector<char>k;//密钥流


};

int _tmain(int argc, _TCHAR* argv[])
{
    printf("输入加密明文:");
    char plaintext[256] = { 0 };
    scanf_s("%s", plaintext, 256);
    printf("输入密钥长度:");
    int nkeylen = -1;
    scanf_s("%d", &nkeylen, 4);
    RC4_EN rc4_en(nkeylen);
    rc4_en.encryption(plaintext);
    return 0;
}

参考

RC4的破解与防范

The post RC4算法的原理和实现 appeared first on cole.

https://ift.tt/eA8V8J c++ July 06, 2018 at 03:44PM