【代替-置换网络】【对代替-置换网络的攻击】【现代密码学】

代替-置换网络

混淆扩散范例

• 混淆

$$F_k(x)=f_1(x_1)\cdots f_{16}(x_{16})$$

• 分散

  • 对得到的值进行重新排列

• 混淆-分散

  • 重复使用混淆与扩散确保输入中任何微小的改变都将混合以及传递到所有的输出比特

代替置换(SP)网络

• 单轮

  1. 输入明文$m$，子密钥$K_1$，输出$m\oplus K_1$，作为S盒的输入
  2. S盒对输入进行(区域)混淆，输出混淆值
  3. 对S盒的输出进行重排列，输出密文$c$

• 安全性的决定因素

  • S盒(Sbox)
  • 混合置换(MP, mixing permutations)
  • 密钥编排

设计原则

1. S盒可逆

   • 必须可逆，为了解密$c$
   • 需要小心的设计，而不是盲目的随机选择，为了满足雪崩效应

2. 雪崩效应

   • 随机混合置换产生非常弱的雪崩效应
   • 雪崩效应的要求
     1. S盒输入改变单比特，输出至少改变两比特
     2. 混合置换的设计要使任何给定的$S$盒的输出比特被传递到下一轮不同的$S$盒中

攻击1、2、3轮代替置换网络

• 1轮 $y=F_k(x)$

  1. $y_2\stackrel{M{P}^{-1}}{\leftarrow }y$
  2. $y_1\stackrel{Sbo{x}^{-1}}{\leftarrow }{y}_2$
  3. $k=x\oplus y_1$

• 2轮 $block=64bitSbox=4bitk\in \{0,1{\}}^{128}$

  1. $y_2^b\stackrel{M{P}_2^{-1}}{\leftarrow }y$

  2. $y_1^b\stackrel{Sbo{x}_1^{-1}}{\leftarrow }{y}_2^b$，$y_1^b=w_1{w}_2\cdots w_{16}$

  3. $w_1=k_1^b\oplus {\alpha }_1$，其中

     $\alpha ={\alpha }_1{\alpha }_2\cdots {\alpha }_{16}$为第一轮输出(未知)，且

     $\alpha \stackrel{M{P}_1}{\leftarrow }{y}_2^a\stackrel{Sbo{x}_1}{\leftarrow }{y}_1^a=x\oplus k^a$

  4. 逆转$\alpha$(不需要知道具体值)的混合置换，可以知道${\alpha }_1$的4bit来自哪些$Sbox$，最坏情况下，4bit分别来自4个不同的$Sbox$，4个$Sbox$的输入共16bit，由输入$x$和第一轮密钥$k^a$的对应16bit异或得到，设$k^a$的对应16bit为$k_{l_1}^a$

  5. 猜测$k_{l_1}^a$，并得到相应的${\alpha }_1\leftarrow k_{l_1}^a$；同时猜测$k_1^b$，用$Step3$中的$w_1=k_1^b\oplus {\alpha }_1$验证猜测

     由于该过程的映射为$\{0,1{\}}^{16+4}\to \{0,1{\}}^4$，因此穷举空间为$2^{20}$，通过测试的概率为$\frac{1}{2^{|w_1|}}=\frac{1}{2^4}=\frac{1}{16}$，因此通过测试的$k_{l_1}^a|k_1^b$的个数为$2^{20}\times 2^{-4}=2^{16}$

  6. 使用多对不同$(x,y)$测试，每对测试期望筛除$\frac{15}{16}$(留下$\frac{1}{2^4}$)的候选$k_{l_1}^a|k_1^b$，至少需要$5(1+4)$对输入/输出$(x,y)$进行验证，才可能留下唯一的一种$k_{l_1}^a|k_1^b$

  复杂度分析

  1. 假设使用8对$(x,y)$最终确定了唯一可能的$k_{l_1}^a|k_1^b$，复杂度为$8\times 2^{20}=2^{23}$(实际小于这个值)

  2. 对$k^b$的所有16个部分按上述方法攻击，复杂度为$16\times 2^{23}=2^{27}$(实际也小于这个值)

  3. 在确定$k^b$的同时，也确定了$k^a$的所有位，因此总复杂度为$2^{27}$，这远小于穷举密钥空间$2^{128}$的复杂度

     原因在于，2轮并没有使密钥的所有比特影响输出的所有比特(仅有20bit影响了输出的前4bit)

• 3轮

  • 雪崩效应依然未完成，改变输入的1bit，输出将会有很多保持不变，因此很容易和随机置换区别开来
  • 获得密钥需要更高的复杂度