对称密码——RC4

1.基本原理

RC4属于对称密码算法中的流密码（逐字节进行加密）加密算法。
密钥长度可变,面向字节操作。
它以一个足够大的表S为基础,对表进行非线性（函数图像不是一条直线）变换,产生密钥流。

密文  XOR  密钥——>密文

明文  XOR  密钥——>明文

2.加密过程

1）初始化S表
     Step1:对S表（s[255]={0,1,2,...,255}    #用c语言概括来说）进行线性填充（不同的密钥有不同的S表）,一般为256个字节，根据需求比如设置成n个字节也可以; 

     Step2:用种子密钥填充另一个256字节的K表;

               eg:种子密钥是3 4 5，那么K表的值就是3 4 5 3 4 5 3......(共n个字节)

     Step3:用K表对S表进行初始置换。

S表

0 S[0]

1 S[1]

2 S[2]

3 S[3]

4 S[4]

5 S[5]

6 S[6]

                                                                             ↓

K表

3 K[0]

4 K[1]

5 K[2]

3 K[3]

4 K[4]

5 K[5]

3 K[6]

                                                                                ↓

j=0;
for i=0 to 255 do
j=(j+S[i]+K[i])mod n;  #取模运算是求两个数相除的余数。n一般为256，在这个例子中为了简便讲解取n=7
Swap(S[i],S[j]);

#第一次循环
#j=(0+S[0]+K[0]) mod 7=(0+0+3) mod 7=3
#将S[0]与S[3]互换
#此时S表顺序为3 1 2 0 4 5 6
#再这样循环7次得到最终的S表

                                                                                  ↓ 

S表

3 S[0]

0 S[1]

1 S[2]

4 S[3]

5 S[4]

2 S[5]

6 S[6]

2）密钥流的生成(为每个待加密的字节生成一个伪随机数,用来和明文异或)
     注:表S一旦完成初始化,种子密钥就不再被使用（每一轮的S表都不同）。

i,j=0;

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(这里的t相当于是S的下角标)就要找到S[i]和S[j]

t=(S[i]+S[j])mod 256；               #i=(i+1)mod 7=0+1=1;
K[r]=S[t];                                     #j=(j+S[i]) mod 7=0+S[1]=0+0=0；

                                                   #Swap(S[0], S[1])；           

                                                   # t=S[0]+S[1] mod 7=3

                                                   #S[3]=4;（4为要和明文异或的伪随机数）

                                                    #K[0]=S[3]=4

3.python示例

def ksa(key):
    """密钥调度算法 (KSA)"""
    # 初始化状态数组 S
    S = list(range(256))
    j = 0
    # 使用密钥打乱状态数组 S
    for i in range(256):
        j = (j + S[i] + key[i % len(key)]) % 256
        S[i], S[j] = S[j], S[i]
    return S

def prga(S, data_length):
    """伪随机数生成算法 (PRGA)"""
    i = 0
    j = 0
    key_stream = []
    # 生成伪随机字节流
    for _ in range(data_length):
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]
        key_stream.append(S[(S[i] + S[j]) % 256])
    return key_stream

def rc4_encrypt_decrypt(key, data):
    """RC4加密和解密"""
    # 将密钥转换为字节
    key = [ord(char) for char in key]
    # 使用 KSA 初始化 S 数组
    S = ksa(key)
    # 使用 PRGA 生成伪随机字节流
    key_stream = prga(S, len(data))
    # 将数据与伪随机字节流进行异或，完成加密或解密
    result = [chr(byte ^ key_stream[i]) for i, byte in enumerate(data)]
    return ''.join(result)

# 示例使用
key = "SecretKey"  # 密钥
plaintext = "Hello, RC4!"  # 明文

# 将明文转换为字节
plaintext_bytes = [ord(char) for char in plaintext]

# 加密
ciphertext = rc4_encrypt_decrypt(key, plaintext_bytes)
print(f"加密后的密文: {ciphertext}")

# 将密文转换为字节
ciphertext_bytes = [ord(char) for char in ciphertext]

# 解密
decrypted_text = rc4_encrypt_decrypt(key, ciphertext_bytes)
print(f"解密后的明文: {decrypted_text}")
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.youkuaiyun.com/qq_42568323/article/details/141687721

代码解释
KSA (密钥调度算法)：负责初始化和打乱状态数组S，使得输出的伪随机数具有良好的随机性。

PRGA (伪随机数生成算法)：通过状态数组S，不断生成伪随机字节流，并与明文或密文进行异或操作，实现加密或解密。

加密和解密：RC4的加密和解密过程是对称的，通过相同的函数进行字节流异或，实现数据的加密和解密。