RC5 加密算法

RC5 是 Ron Rivest 于 1994 年设计的对称密钥块加密算法。它以简单、快速(因为只使用 XOR、移位等原始计算机操作)和消耗更少内存而著称。

例子：

Key : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Plain Text : 00000000 00000000
Cipher Text : EEDBA521 6D8F4B15

RC5 是一种分组密码，一次寻址两个字块。
根据输入纯文本块大小、轮数和密钥大小，可以定义 RC5 的各种实例，每个实例表示为 RC5-w/r/b，其中 w=字大小(以位为单位)，r=轮数和 b = 密钥大小(以字节为单位)。
允许的值为：

Parameter	Possible Value
block/word size (bits)	16, 32, 64
Number of Rounds	0 – 255
Key Size (bytes)	0 – 255

注 –由于 RC5 一次使用 2 个字块，因此纯文本块大小可以是 32、64 或 128 位。

算法中使用的符号：

Symbol	Operation
x <<< y	Cyclic left shift of x by y bits
+	Two’s complement addition of words where addition is modulo $2^w$
^	Bit wise Exclusive-OR

步骤 1：初始化常数 P 和 Q。
RC5 使用 2 个魔法常数 P 和 Q，其值由字长 w 定义。

Word Size (bits)	P (Hexadecimal)	Q (Hexadecimal)
16	b7e1	9e37
32	b7e15163	9e3779b9
64	b7e151628aed2a6b	9e3779b97f4a7c15

对于任何其他字长，P 和 Q 可以确定为：

P = 奇数((e-2) $2^w$ ) Q = 奇数(( $\phi$ -2) $2^w$ )

其中，Odd(x) 是最接近 x 的奇数，e 是自然对数的底， $\phi$是黄金比例。

步骤 2：将密钥 K 从字节转换为字。
大小为 b 字节的密钥 K 用于初始化由 c 个字组成的数组 L，其中 c = b/u、u = w/8 和 w = 用于该特定 RC5 实例的字大小。例如，如果我们选择 w=32 位并且密钥 k 的大小为 96 字节，则 u=32/8=4，c=b/u=96/4=24。
L 在添加密钥 K 之前被预初始化为 0 值。

for i=b-1 to 0
    L[i/u] = (L[u/i] <<< 8) + K[i]

Step-3：初始化子密钥S。
大小为 t=2(r+1) 的子密钥 S 使用魔法常数 P 和 Q 进行初始化。

S[0] = P
for i = 1 to 2(r+1)-1
    S[i] = S[i-1] + Q)

步骤 4：子密钥混合。
RC5 加密算法使用子密钥 S。L 只是，基于用户输入的秘密密钥形成的临时数组。
将用户的密钥与 S 和 L 混合。

i = j = 0
A = B = 0
do 3 * max(t, c) times:
    A = S[i] = (S[i] + A + B) <<< 3
    B = L[j] = (L[j] + A + B) <<< (A + B)
    i = (i + 1) % t
    j = (j + 1) % c

第 5 步：加密。
我们将输入的纯文本块分成两个寄存器 A 和 B，每个寄存器的大小为 w 位。经过加密处理后，A和B的结果共同构成密文块。
RC5加密算法：

1. 通过将 S[0] 和 S[1] 分别添加到 A 和 B 对纯文本块 A 和 B 进行一次初始化。这些操作是mod $2^w$ .
2. 异或 A 和 B。A=A^B
3. 循环左移 A 的新值 B 位。
4. 将 S[2*i] 添加到上一步的输出中。这是 A 的新值。
5. XOR B 与 A 的新值并存储在 B 中。
6. 循环左移 B 的新值 A 位。
7. 将 S[2*i+1] 添加到上一步的输出中。这是 B 的新值。
8. 重复整个过程(一次初始化除外)r 次。

A = A + S[0] 
B = B + S[1]
for i = 1 to r do:
    A = ((A ^ B) <<< B) + S[2 * i]
    B = ((B ^ A) <<< A) + S[2 * i + 1]
return A, B

或者，RC5 解密可以定义为：

for i = r down to 1 do:
    B = ((B - S[2 * i + 1]) >>> A) ^ A
    A = ((A - S[2 * i]) >>> B) ^ B
B = B - S[1]
A = A - S[0]
return A, B