爬虫逆向加密技术详解之对称加密算法：RC4加密解密

一、对称加密介绍

---

RC4属于对称加密算法，不知道什么是对称加密的小伙伴请看这篇文章：https://blog.youkuaiyun.com/thy525/article/details/147700959

---

二、RC4算法简介

RC4（Rivest Cipher 4）是一种由Ron Rivest于1987年设计的流加密算法，属于对称加密体系。其核心特点是通过伪随机数生成器（PRNG）与明文逐字节异或实现加密，解密过程完全相同。该算法曾广泛应用于SSL/TLS、WEP/WPA等协议，但因安全性问题（如密钥流相关性、弱密钥攻击）逐渐被淘汰，但在某些旧系统或特定场景中仍可见其身影。

---

相关参数定义 ：

1. 密钥（Key）

   • 密钥长度可变，范围为1-256字节（8-2048比特）。
   • 密钥通过KSA（密钥调度算法）生成初始置换表（S盒），直接影响加密安全性。

2. 密钥位数

   • 推荐使用至少128位（16字节）密钥以抵御暴力破解。

3. 初始向量（IV）

   • RC4 算法本身不需要初始向量，但是还是可以设置初始向量的。初始向量通常用于分组加密算法，以增加加密的随机性和安全性。而 RC4 是流加密算法，它通过密钥流生成器生成一个与明文长度相同的密钥流，然后将密钥流与明文进行异或运算得到密文。

4. 加密模式

   • RC4为流密码，无分组模式（如CBC、GCM），直接对字节流操作。

5. 填充方式

   • 不需要填充（Padding），因RC4逐字节处理，明文与密文长度一致。

---

三、RC4加密解密原理

1. 密钥调度算法（KSA）

KSA的作用是初始化一个长度为256的S盒，S盒是一个包含0到255的排列数组。具体步骤如下：

• 初始化S盒，S[i] = i，其中i从0到255。
• 初始化一个长度为256的T数组，将密钥循环填充到T数组中。
• 初始化一个变量j = 0。
• 对于i从0到255，执行以下操作：
  • j = (j + S[i] + T[i]) % 256。
  • 交换S[i]和S[j]的值。

2. 伪随机数生成算法（PRGA）

PRGA的作用是生成与明文长度相同的密钥流。具体步骤如下：

• 初始化i = 0，j = 0。
• 对于每一个要加密或解密的字节，执行以下操作：
  • i = (i + 1) % 256。
  • j = (j + S[i]) % 256。
  • 交换S[i]和S[j]的值。
  • t = (S[i] + S[j]) % 256。
  • 从S盒中取出S[t]作为密钥流的一个字节。

3. 加密和解密过程

加密和解密过程是相同的，都是将明文或密文与密钥流进行异或运算。具体步骤如下：

• 对明文或密文的每一个字节，从密钥流中取出一个对应的字节。
• 将明文或密文的字节与密钥流的字节进行异或运算，得到密文或明文。

---

四、快速识别RC4加密的方法

4.1 密文长度判断

由于 RC4 是流加密算法，密文的长度与明文的长度相同。如果密文长度与明文长度一致，且没有明显的分组特征（如分组长度固定），则有可能是使用了流加密算法，包括 RC4。

4.2 验证密文字符集

RC4 加密后的密文通常是二进制数据，没有明显的字符集特征。如果密文包含大量随机的二进制数据，而不是可识别的文本字符集（如 ASCII、UTF-8 等），则有可能是经过加密处理的，包括 RC4 加密。

4.3 代码特征识别

KSA阶段：

• 存在长度为256的循环，对S数组进行置换。

  // 初始化S盒，将S[i]初始化为i，其中i从0到255
  for (let i = 0; i < 256; i++) {
     s[i] = i;
  }
  

PRGA阶段：

• 存在两个指针i和j的更新逻辑：

  // 更新i的值，使用模运算确保i在0到255之间
  i = (i + 1) % 256;
  // 根据S[i]更新j的值，使用模运算确保j在0到255之间
  j = (j + s[i]) % 256;
  

• 密钥流生成：

  // 用于从S盒中取出密钥流的一个字节
  s[(s[i] + s[j]) % 256]
  

总结：在代码实现中，RC4 算法通常会包含密钥调度算法（KSA）和伪随机数生成算法（PRGA）的实现。如果代码中出现了对 S 盒的初始化和交换操作，以及通过异或运算进行加密和解密的代码，那么很可能是使用了 RC4 算法。

---

五、代码实现

5.1 JavaScript原生实现RC4加密解密

// 定义RC4加密和解密函数，因为加密和解密使用相同的操作
function rc4(key, plaintext) {
    // 初始化S盒，S盒是一个长度为256的数组
    let s = [];
    // 初始化索引变量j
    let j = 0;
    // 用于交换S盒元素时的临时变量
    let x;
    // 存储加密或解密后的结果
    let result = '';

    // 初始化S盒，将S[i]初始化为i，其中i从0到255
    for (let i = 0; i < 256; i++) {
        s[i] = i;
    }

    // 密钥调度算法（KSA），用于打乱S盒的顺序
    for (let i = 0; i < 256; i++) {
        // 根据密钥更新j的值，使用模运算确保j在0到255之间
        j = (j + s[i] + key.charCodeAt(i % key.length)) % 256;
        // 交换S[i]和S[j]的值
        x = s[i];
        s[i] = s[j];
        s[j] = x;
    }

    // 伪随机数生成算法（PRGA），用于生成与明文长度相同的密钥流
    let i = 0;
    j = 0;
    for (let k = 0; k < plaintext.length; k++) {
        // 更新i的值，使用模运算确保i在0到255之间
        i = (i + 1) % 256;
        // 根据S[i]更新j的值，使用模运算确保j在0到255之间
        j = (j + s[i]) % 256;
        // 交换S[i]和S[j]的值
        x = s[i];
        s[i] = s[j];
        s[j] = x;
        // 计算t的值，用于从S盒中取出密钥流的一个字节
        let t = (s[i] + s[j]) % 256;
        // 将明文的一个字节与密钥流的一个字节进行异或运算，得到加密或解密后的结果
        result += String.fromCharCode(plaintext.charCodeAt(k) ^ s[t]);
    }

    // 返回加密或解密后的结果
    return result;
}

// 示例使用
// 定义密钥
let key = "secretkey";
// 定义明文
let plaintext = "Hello, World!";
// 调用rc4函数进行加密
let ciphertext = rc4(key, plaintext);
// 调用rc4函数进行解密
let decryptedText = rc4(key, ciphertext);


console.log("明文: ", plaintext);
console.log("明文长度: ", plaintext.length);
console.log("密文: ", ciphertext);
console.log("密文长度: ", ciphertext.length);
console.log("解密后的明文: ", decryptedText);

运行结果：

明文:  Hello, World!
明文长度:  13
密文:  íÍ°p#µGÞ'à£
密文长度:  13
解密后的明文:  Hello, World!

5.2 Python原生实现 RC4加密解密

def rc4(key, plaintext):
    # 初始化S盒
    s = list(range(256))
    j = 0
    # 密钥调度算法（KSA），用于打乱S盒的顺序
    for i in range(256):
        # 根据密钥更新j的值，使用模运算确保j在0到255之间
        j = (j + s[i] + ord(key[i % len(key)])) % 256
        # 交换S[i]和S[j]的值
        s[i], s[j] = s[j], s[i]

    # 伪随机数生成算法（PRGA），用于生成与明文长度相同的密钥流
    i = 0
    j = 0
    result = []
    for char in plaintext:
        # 更新i的值，使用模运算确保i在0到255之间
        i = (i + 1) % 256
        # 根据S[i]更新j的值，使用模运算确保j在0到255之间
        j = (j + s[i]) % 256
        # 交换S[i]和S[j]的值
        s[i], s[j] = s[j], s[i]
        # 计算t的值，用于从S盒中取出密钥流的一个字节
        t = (s[i] + s[j]) % 256
        # 将明文的一个字节与密钥流的一个字节进行异或运算，得到加密或解密后的结果
        result.append(chr(ord(char) ^ s[t]))

    return ''.join(result)


# 示例使用
# 定义密钥
key = "secretkey"
# 定义明文
plaintext = "Hello, World!"
# 调用rc4函数进行加密
ciphertext = rc4(key, plaintext)
# 调用rc4函数进行解密
decrypted_text = rc4(key, ciphertext)

print("明文: ", plaintext)
print("明文长度: ", len(plaintext))
print("密文: ", ciphertext)
print("密文长度: ", len(ciphertext))
print("解密后的明文: ", decrypted_text)

运行结果：

明文:  Hello, World!
明文长度:  13
密文:  íÍ°p#µGÞ'à£
密文长度:  13
解密后的明文:  Hello, World!