BUAA^AITMCLAB&LAB3题解

LAB3题解

• 分析加密过程：

  • 可以发现采用RSA对message列表进行了加密，并将每组的$<N,e,c>$ 输出到了txt文件中

  • from AITMCLAB.Crypto.Util.number import getPrime
    from AITMCLAB.libnum import s2n
    
    
    def RSA_encrypt(message):
        m = s2n(message)
        p = getPrime(1024)
        q = getPrime(1024)
        N = p * q
        e = 5
        c = pow(m, e, N)
        return N, e, c
    
    
    messages = ["*******", "*******", "************", "*********", "**********", "********",
                "**********", "*************", "**************", "******", "**********",
                "***************", "*********", "*********", "*******"]
    
    fp = open('output4.txt', 'w')
    for m in messages:
        N, e, c = RSA_encrypt(m)
        fp.write("n = %s" % N + '\n')
        fp.write("e = %s" % e + '\n')
        fp.write("c = %s" % c + '\n')
        fp.write('\n')
    

• 关于RSA算法：

  • 安全性：依赖于大整数质因数分解的难度

  • 加密变换：$m^e=cmodN$

    • 其中$m$为明文，$c$为密文

      • 公钥：$<N,e>$ 任何人拥有了公钥即可进行加密

        $$\begin{gathered} 1<e<(p-1)(q-1) \\ gcd(e,(p-1)(q-1))=1 \end{gathered}$$

  • 解密变换：$m=c^{d}modN$

    • 私钥：$<N,d>$ 其中：$N=pq$（p,q均为质数），

  $$de=1mod(p-1)\ast (q-1)$$

• 重中之重，本次Lab不可或缺的重点！

  1. '''
     Bangzhu likes talking with his junior schoolmate, but he is so lazy. 
     So he sometimes sends the same files of messages to elaborate them.
     To avoid being discovered by Doc Gao and Doc Wang, he uses an encryption to send messages.
     As a good students like you, you want to accuse Bangzhu and let your teachers know.
     Could u find the flag hidden in the messages? 
     '''
     

     • 注意注释中这句话： $sendsthesamefilesofmessages$，这意味着msg（message）片段是被不同的N相同的e加密多次的！

  2. 注意到加密指数$e=5$恒定 且 该定值很小

• 解密方法——低加密指数广播攻击

  1. 低加密指数：

     也就是LAB3的名称——LOW e，加密指数e很小，常见是$e=3$或者$e=2^{16}+1=65537$

  2. 广播：

     指采用同样的加密指数$e$采用不同的N对一份密文多次加密（这就是我之前强调的注释内容）

  3. 攻击方法：CRT（中国剩余定理）

     $$\begin{gathered} 设m_1,m_2,...,m_r是两两互素的自然数， \\ 令m=m_1{m}_2...m_r,M_i=\frac{m}{m_i},i=1,...,r,则方程组： \\ \{\begin{array}{l}x\equiv b_1(mod{m}_1)\\ x\equiv b_2(mod{m}_2)\\ ...\\ x\equiv b_r(mod{m}_r)\end{array}的解为： \\ x\equiv M_1^{\prime }{M}_1{b}_1+M_1^{\prime }{M}_2{b}_2+...M_r^{\prime }{M}_r{b}_r(modm) \\ 即x\equiv \sum _{i=1}^r{M}_i^{\prime }{M}_i{b}_i(modm) \\ 其中M_i^{\prime }满足M_i^{\prime }{M}_i\equiv 1(mod{m}_i) \end{gathered}$$

     • 对于本LAB：$x=m^e$如果CRT后有解我们可以开$e$次方根得到明文$m$(因为$x<m$)

• 接下来是离谱的心路历程（呜呜呜）

  1. 首先，考虑CRT成立的互素条件

     • 信心满满打算写一个判断互素的函数来判断这15组$<N,e,c>$该如何分组

       def is_coprime(n_lst):
           """判断是否两两互素"""
           l_n = len(n_lst)
           for a in range(l_n):
               for b in range(l_n):	
                   if gcd(n_lst[a], n_lst[b]) == 1:
                       print(a, b)
       

     • 运行结果有点无语，OS：？？？怎么两两互素！？

  2. 其次，打算想简单一点，观察messag内容$\ast$的个数来分组

     • 可是又双叒叕愉快地发现这星号的个数如此随意…

  3. 之后，打算暴力遍历分组情况

     • 回忆集合中幂集的定义：

       $$\begin{gathered} 设有集合A，由A的所有子集组成的集合，称为A的幂集， \\ 记作2^A，即:2^A=\{S|S\subseteq A\} \\ 若\left|A\right|=n,则\left|2^A\right|=2^n \end{gathered}$$

     • 对于模数n的列表（集合）：

       $$\begin{gathered} \left|nmod\_lst\right|=15 \\ 故其子集个数（分组情况可能为）2^{15}-1=32767(除去空集) \end{gathered}$$

     • 如何生成集合的幂集？(python中数据类型我们选择列表代替集合)

       方法：每一次遍历，在已有集合中加上一个新的元素
       $$\begin{gathered} 对于集合[1,2,3],有 \\ \{\begin{array}{l}[]\\ [][1]\\ [][1][2][1,2]\\ [][1][2][1,2][1,3][2,3][1,2,3]\end{array} \end{gathered}$$

       def subsets(lst):
           """生成集合的所有子集"""
           sub_lsts = [[]]
           for sub in lst:
               sub_lsts += [sub_lst + [sub] for sub_lst in sub_lsts]
           return sub_lsts
       

  4. 经过多次实验，发现子集大小为2/3/4/5才会解出有效明文

     • 在k个一组的所有情况中，当且仅当$k=5=e$时有不重复的三（15/5）组对应解，即得到三段明文，于是我写了挑选出大小为5的子集的函数：

       def judge_5(lsts):
           """挑选长度为5的列表"""
           sub_5 = []
           for lst in lsts:
               if len(lst) == 5:
                   sub_5.append(lst)
           return sub_5
       

     • 当$k=2/3/4$时，也可以解出有效明文，但是有重复

     • 主要代码实现如下：

       if __name__ == "__main__":
           t1 = time.time()
           e = 5
           filename = "output4.txt"
           cipher_lst, nmod_lst = file_proc(filename)
           # 从文件读取c/n列表
           cipher_lst = judge_5(subsets(cipher_lst))
           nmod_lst = judge_5(subsets(nmod_lst))
           # 生成子集->挑出长度5的
           lth = len(cipher_lst)
           msg = ""
           for i in range(lth):
             	# CRT计算x^e
               xe = crt(cipher_lst[i], nmod_lst[i])
        				# gmpy2.iroot()返回一个元组(int：整数部分，bool：是否成功开根)       
               res = gmpy2.iroot(xe, e)
               if res[1]:
                   msg = n2s(int(res[0])).decode("utf-8")
                   print(msg)
           t2 = time.time()
           print(t2 - t1)
       

• 背后的数学原理（悲，这个部分杀我

  • 这个部分的数学原理困扰了我好几天，直到我翻阅了出题人gfy大佬提供的一份英文文献（英文看不太懂，一知半解的去百度发现有中文译文（x）

  • 数学原理（证明略，有兴趣的同学可以看中文版在这里面找Low Public Exponent RSA

    定理1：这就是为什么我们可以使用CRT计算

    $$\begin{gathered} 假设N_1,N_2,...,N_k为k个互素的整数。设N_{min}=min(N_i), \\ {g}_i\in {\mathbb{Z}}_{N_i}[x](模N_i的多项式完全剩余系)为k个次数为d的多项式 \\ 假设存在唯一的M<Nmin，使得g_i(M)\equiv C_i(mod{N}_i),i\in 1,2,...,k \\ 故，如果k\ge d,可以有效的从（N_i,g_i,C_i{）}_{i=1}^k中找到M \end{gathered}$$

    定理2:这就是为什么取分组数为e可以恰好解出m

    $$\begin{gathered} 设N是整数，f\in {\mathbb{Z}}_N[x]是d阶的一元多项式（x^d的系数为1） \\ 那么我们可以找到所有的x\in \mathbb{Z},使\left|x\right|\le B和f(X)\equiv 0(modN) \\ 其中B=N^{\frac{1}{d}} \end{gathered}$$

    Proof:

    $$\begin{gathered} 设h_i=g_i-C_i,1\le i\le k.接下来寻找M，使得h_i(M)\equiv 0(mod{N}_i),i\in [1,k] \\ 使用CRT进行组合： \\ h(x)=\sum _{i=1}^k{T}_i{h}_i(x)(mod{N}_1{N}_2...N_k) \\ 其中T_i的选择使用CRT，以满足： \\ {T}_i=\{\begin{array}{l}1(mod{N}_j),i=j\\ 0(mod{N}_j),i\ne j\end{array} \\ 故h(x)满足： \\ 1.阶（次数）d=3 \\ 2.首一的(x^d的系数为1模任何N_i) \\ 3.h(M)\equiv 0(mod{N}_1{N}_2...N_k) \end{gathered}$$

    这时候我们应用定理2求M：

    $$\begin{gathered} 由k\ge d可得 \\ M<N_{min}\le (N_1{N}_2...N_k{)}^{\frac{1}{k}}\le (N_1{N}_2...N_k{)}^{\frac{1}{d}} \end{gathered}$$

    这也就解释了为什么2/3/4/5均可以解出明文的原因：

    • 本LAB中，$d=e=5$,且实际上三段明文各加密$k=5\ge d$次满足条件
      $$M<(N_1{N}_2...N_k{)}^{\frac{1}{d}}=(N_1{N}_2...N_k{)}^{\frac{1}{5}}<(N_1{N}_2...N_k{)}^{\frac{1}{2/3/4}}$$

    • 故$d=5$是M有解的一个上界，2/3/4也满足有解条件但是会导致重复（取1的时候显然不能使用CRT）

• 写在最后，说实话lab3消耗的时间远远多于QUIZ1（比如写这份wp就费了我一个下午，呜呜），其实没必要探究如此之深，但是相比于一个感兴趣的问题困扰我很久，我更喜欢去花费一些时间去探索解决，我觉得这些时间是值得的。

• 最后的最后，希望看到这篇wp的同学走过路过点个赞收藏一下什么的（狗头保命

• p.s附上lab3_solution.py

  # _*_ coding: utf-8 _*_
  """
  Time:     2022/9/19 17:21
  Author:   刘征昊(£·)
  Version:  V 1.1
  File:     lab3_solution.py
  Describe: 
  """
  import time
  from AITMCLAB.libnum import n2s, gcd
  import gmpy2
  from functools import reduce
  
  
  def crt(cpr_lst, n_lst):
      """
      中国剩余定理求解: x == c (mod n)
      params:
          cpr-lst 余数c列表
          n_lst 模数n列表
      return: x
      """
      # 累积 m = n1*n2*...*nk
      m = reduce(lambda x, y: x * y, (ni for ni in n_lst))
      result = 0
      data = zip(cpr_lst, n_lst)
      for ci, ni in data:
          mi = m // ni
          di = gmpy2.invert(mi, ni)
          result += (ci * mi * di) % m
      return result % m
  
  
  def file_proc(fn):
      """
      文件处理函数：从文件中读取每组 n 和 c
      params: fn文件名(含后缀名)
      return: 返回c和n的列表
      """
      cipher = []
      nmod = []
      with open(fn, "r") as fp:
          for line in fp:
              line = line.strip('\n')
              if line.startswith('n'):
                  n = int(line.split(' ')[-1])
                  nmod.append(n)
              elif line.startswith('c'):
                  c = int(line.split(' ')[-1])
                  cipher.append(c)
              else:
                  continue
      return cipher, nmod
  
  
  def is_coprime(n_lst):
      """判断是否两两互素"""
      l_n = len(n_lst)
      for a in range(l_n):
          for b in range(l_n):
              if gcd(n_lst[a], n_lst[b]) == 1:
                  print(a, b)
  
  
  def subsets(lst):
      """生成集合的所有子集"""
      sub_lsts = [[]]
      for sub in lst:
          sub_lsts += [sub_lst + [sub] for sub_lst in sub_lsts]
      return sub_lsts
  
  
  def judge_5(lsts):
      """挑选长度为5的列表"""
      sub_5 = []
      for lst in lsts:
          if len(lst) == 4:
              sub_5.append(lst)
      return sub_5
  
  
  if __name__ == "__main__":
      t1 = time.time()
      e = 5
      filename = "output4.txt"
      cipher_lst, nmod_lst = file_proc(filename)
      # 从文件读取c/n列表
      cipher_lst = judge_5(subsets(cipher_lst))
      nmod_lst = judge_5(subsets(nmod_lst))
      # 生成子集->挑出长度5的
      lth = len(cipher_lst)
      msg = ""
      for i in range(lth):
          xe = crt(cipher_lst[i], nmod_lst[i])
          res = gmpy2.iroot(xe, e)
          if res[1]:
              msg = n2s(int(res[0])).decode("utf-8")
              print(msg)
      t2 = time.time()
      print(t2 - t1)
  #     aitmc{Chicken_soup_is_tasty_CRT_is_tasty_for_you_too}
  # Ahahahaha, here is the chicken soup!! Hahaha A~*sigh*.The dish is all here, why don't you eat? Lao Feng, everyone is afraid to eat it!Someone said that that someone had poisoned the chicken soup. WTF?Captain Wang. You are such a joker. aitmc{Chicken_soup_is_tasty_CRT_is_tasty_for_you_too}. Not salty and not light. The taste is really good!