RC4

RC4

原理：只需要一个KeyStream与明文进行异或即可，密钥流的长度和明文的长度是对应的。RC4算法的的主要代码还是在于如何生成秘钥流。特点是秘钥长度可变。

秘钥流的生成由两部分组成：

1. KSA（the Key-Scheduling Algorithm)
2. PRGA(the Pseudo-Random Generation Algorithm)

具体方法就看下面的代码吧

#include<stdio.h>
#include<string.h>
 
#define SBOX_LEN 256// 定义了S-box数组的长度为256。

#define rc4_encrypt rc4_crypt
#define rc4_decrypt rc4_crypt
 //定义了 rc4_encrypt 和 rc4_decrypt 分别为 rc4_crypt 的别名，即这三个宏都表示同一个函数。

static inline void swap_uchar(unsigned char *puc_x, unsigned char *puc_y)
{
    *puc_x = *puc_x ^ *puc_y;
    *puc_y = *puc_x ^ *puc_y;
    *puc_x = *puc_x ^ *puc_y;
    //用于交换两个 unsigned char 类型*puc_x和*puc_y的变量的值。
}
 
void hexdump(unsigned char *puc_data, int length)
{
    int i = 0;
 
    for (i = 0; i < length; i++) {
        printf("%02X", puc_data[i]);
        //使用 %02X 格式化字符串，以两位十六进制数的形式打印当前字节的值。这确保了不足两位的值会在前面用零填充。
        if (i && (i + 1) % 16 == 0) {
            putchar('\n');
        }
        //检查是否已经打印了16个字节，如果是，则在输出中插入一个换行符。这样可以使输出更加可读，每行显示16个字节。
    }
    printf("\n");
}
 
/**
 * 利用Key生成S盒
 * the Key-Scheduling Algorithm
 */
static void rc4_ksa(unsigned char *puc_sbox, unsigned char *puc_key, int key_length)
{
    int i = 0;
    int j = 0;
    char tmp[SBOX_LEN] = {0};
    //tmp 是一个辅助数组，用于存储重复的密钥。
 
    for (i = 0; i < SBOX_LEN; i++) {
        puc_sbox[i] = i;
        tmp[i] = puc_key[i % key_length];
        //同时，它使用一个重复的密钥（puc_key）初始化 tmp 数组，其中 i % key_length 确保如果密钥长度小于 256 字节，则会重复使用密钥。
    }
 
    for (i = 0; i < SBOX_LEN; i++) {
        j = (j + puc_sbox[i] + tmp[i]) % SBOX_LEN;
        swap_uchar(&puc_sbox[i], &puc_sbox[j]); 
        //交换puc_sbox[i]和puc_sbox[j]
    }
}
 
/**
 * 利用S盒生成密钥流
 * The pseudo-random generation algorithm(PRGA)
 */
static void rc4_prga(unsigned char *puc_sbox, unsigned char *puc_key_stream, unsigned long ul_data_length)
{
    int i = 0;
    int j = 0;
    int t = 0;
    unsigned long k = 0;
 
    for (k = 0; k < ul_data_length; k++) {
        i = (i + 1) % SBOX_LEN;
        //更新变量 i，确保它在 0 到 255 之间循环。
        j = (j + puc_sbox[i]) % SBOX_LEN;
        //更新变量 j，与 S-box 中的一个元素相加，同样确保它在 0 到 255 之间循环。
        swap_uchar(&puc_sbox[i], &puc_sbox[j]);
        //交换 S-box 中索引为 i 和 j 处的值，实现 S-box 的进一步置换。
        t = (puc_sbox[i] + puc_sbox[j]) % SBOX_LEN;
        //计算变量 t，再次确保它在 0 到 255 之间循环。
        /* 为了更清晰理解rc4算法流程，此处保存keystream，不直接进行XOR运算 */
        puc_key_stream[k] = puc_sbox[t];
    }
}
//整个循环重复执行，生成长度为 ul_data_length 的伪随机密钥流
 
/* 加解密 */
void rc4_crypt(unsigned char *puc_data, unsigned char *puc_key_stream, unsigned long ul_data_length)
{
    unsigned long i = 0;
 
    /* 把PRGA算法放在加解密函数中可以不需要保存keystream */
    for (i = 0; i < ul_data_length; i++) {
        puc_data[i] ^= puc_key_stream[i];
    }
}
 
int main(int argc, char *argv[])
{
    unsigned char sbox[SBOX_LEN] = {0};
    char key[SBOX_LEN] = {"abcdefghijklmnopqrstuvwxyz"}; //秘钥内容定义
    char data[512] = "bhjlvi;gyl/gi;";
    unsigned char puc_keystream[512] = {0};
    //puc_keystream 用于保存生成的密钥流
    unsigned long ul_data_length = strlen(data);
 
    printf("key=%s, length=%d\n\n", key, strlen(key));
    printf("Raw data string:%s\n", data);
    printf("Raw data hex:\n");
    hexdump(data, ul_data_length);
    //打印密钥和原始数据的信息。
    /* 生成S-box */
    rc4_ksa(sbox, (unsigned char *)key, strlen(key));
 
    /* 生成keystream并保存,S-box也会被更改 */
    rc4_prga(sbox, puc_keystream, ul_data_length);
 
    printf("S-box final status:\n");
    hexdump(sbox, sizeof(sbox));
 
    printf("key stream:\n");
    hexdump(puc_keystream, ul_data_length);
    ////打印S-box最终状态和生成的密钥流。
 
    /* 加密 */
    rc4_encrypt((unsigned char*)data, puc_keystream, ul_data_length);
    //调用 rc4_encrypt 函数对数据进行加密。
 
    printf("cipher hexdump:\n");
    hexdump(data, ul_data_length);
    //打印加密后的数据
 
    /* 解密 */
    rc4_decrypt((unsigned char*)data, puc_keystream, ul_data_length);
    //调用 rc4_decrypt 函数对数据进行解密。
 
    printf("decypt data:%s\n", data);
 
    return 0;
}