BUAA^AITMCLAB&RSA大作业

RSA实现

• 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)$$

• RSA密码体系实现

  • RSA公/私钥的生成

    1. 生成大素数p/q：

       def get_prime(len_bit):
           """
           随机获取一个二进制位长len_bit的整数
           """
           prm = (randint(2 ** (len_bit - 1), 2 ** len_bit) + 1) | 1
           # 利用或运算保证prm是一个奇数
           while not isPrime(prm):
               prm += 2
           return prm
       

       或运算：

       $$\begin{gathered} 特性：有1得1，全0才0 \\ 0|0=0;0|1=1; \\ 1|0=0;1|1=1 \\ 应用：某位赋值1 \end{gathered}$$

    2. Miller_rabin素性检验（判断质数）

       • 数学原理（费马小定理和二次探测）

         费马小定理：
         $$\begin{gathered} 设p是一个素数，那么\forall a\in \mathbb{Z} \\ 有a^p\equiv a(modp) \end{gathered}$$
         二次探测定理：
         $$\begin{gathered} 如果p是一个素数,0<x<p,则方程x^2\equiv 1(modp)的解为: \\ x\equiv \pm 1(modp) \\ 反之，如果方程的解不是x\equiv \pm 1(modp)，那么p不是素数 \end{gathered}$$
         Miller-rabin witness:
         $$\begin{gathered} 设n是一个奇数，则n-1=2^{k}q,其中q是奇数，取满足gcd(a,n)=1的a \\ 如下条件满足,则称a是n的Miller-Rabinwitness： \\ 1.a^q\not\equiv 1(modn) \\ 2.a^{2^{i}q}\not\equiv -1(modn)i=0,1,...,k-1 \end{gathered}$$

       def isPrime(n):
           """
           miller-rabin检验，返回是否是质数
           """
           if n == 2 or n == 3:
               return True
           if not n & 1:
               return False
           m, q = n - 1, 0
           while not m & 1:
               m >>= 1
               q += 1
           rd, seed1, seed2 = 20011224, 998244353, 20217371
           for i in range(0, 30):
               rd = rd * seed1 + seed2
               if rd < 0:
                   rd = -rd
               a = rd % (n - 1) + 1
               tmp = fast_power(a, m, n)
               for j in range(0, q):
                   ans = tmp ** 2 % n
                   if ans == 1:
                       if tmp != 1 and tmp != n - 1:
                           return False
                       break
                   tmp = ans
               if ans != 1:
                   return False
           return True
       

    3. 快速（模）幂运算：

       def fast_power(base, power, n=0):
           """
           快速(模)幂运算
           n的默认值为0：快速幂运算
           n>0:快速模幂运算
           """
           if power <= 0:
               raise ValueError("power must be postive")
           result = 1
           if n == 0:
               while power > 0:
                   if power & 1:
                       result *= base
                   power >>= 1
                   base *= base
           else:
               while power > 0:
                   if power & 1:
                       result = result * base % n
                   power >>= 1
                   base = base ** 2 % n
           return result
       

    4. 生成（n, e, d, p, q）并进行公钥和私钥的保存

       • 综合实现：

       def get_key(len_bit):
           """
           生成RSA公私钥
           params: len_bit:p/q的二进制基础长度,
           return: (n, e), (n, d), (p, q)
           """
           p = get_prime(len_bit + 1)
           q = get_prime(len_bit + 3)
           # 保证p/q不是很接近
           n = p * q
           phi = (p - 1) * (q - 1)
           e = get_prime(16)
           while gcd(e, phi) > 1:
               e = get_prime(16)
           d = invmod(e, phi)
           with open("public_key.txt", "w") as f:
               f.write(f"n = {n}\n")
               f.write(f"e = {e}\n")
           with open("private_key.txt", "w") as f:
               f.write(f"n = {n}\n")
               f.write(f"d = {d}\n")
           return (n, e), (n, d), (p, q)
       

       • 逆元实现：

         扩展欧式算法：

         def Egcd(a, b):
             """
             扩展欧拉算法:au+bv=g
             params: a, b
             return: x = (g, u, v)
             """
             x = [a, 1, 0]
             y = [b, 0, 1]
             while y[0] != 0:
                 q = x[0] // y[0]
                 for i in range(0, 3):
                     x[i] = x[i] - q * y[i]
                 tmp = x[:]
                 x = y[:]
                 y = tmp[:]
             return x
         

         逆元判断：

         def invmod(a, n):
             """
             求a mod n 的逆元
             """
             if n < 2:
                 raise ValueError("n must be bigger than 1")
             g, x, y = Egcd(a, n)
             if g != 1:
                 raise ValueError("no invmod")
             else:
                 return x % n
         

  • RSA加密算法：

    def rsa_encrypt(m, public_key):
        """
        RSA加密函数
        params:公钥publickey = (n, e)    明文m(整数形式)
        return：密文c
        """
        n, e = public_key[0], public_key[1]
        if m < 0:
            raise ValueError("msg is negative")
        elif m > n:
            raise ValueError("msg is too long")
        else:
            c = fast_power(m, e, n)
            return c
    

  • RSA解密算法：

    • 基础实现：

    def rsa_decrypt(c, private_key):
        """
        RSA解密函数
        params:私钥private_key = (n, d)     密文c(整数)
        return:明文m
        """
        n, d = private_key[0], private_key[1]
        if c < 0:
            raise ValueError("cpr is negative")
        elif c > n:
            raise ValueError("cpr is too long")
        else:
            m = fast_power(c, d, n)
            return m
    

    • CRT加速实现：

      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}$$
      代码实现：

      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 = invmod(mi, ni)
              result += (ci * mi * di) % m
          return result % m
      

      CRT加速解密计算：

    def rsa_decrypt_crt(c, d, prime_pair):
        """
        CRT加速解密计算(已知p、q)
        """
        p, q = prime_pair[0], prime_pair[1]
        c_lst = [fast_power(c, d % (p - 1), p), fast_power(c, d % (q - 1), q)]
        n_lst = [p, q]
        return crt(c_lst, n_lst)
    

  • RSA签名算法：

    基本原理：

    $$\begin{gathered} 对明文m使用hash得到信息摘要digest,之后对信息摘要使用私钥进行加密得到签名 \\ s\equiv diges{t}^d(modn) \end{gathered}$$

    信息摘要digest生成：

    import hashlib
    dgst = s2n(hashlib.sha256(msg).digest())
    

    签名代码实现：

    def rsa_sign(digest, private_key):
        """
        RSA签名生成函数:对信息摘要使用私钥加密生成签名
        return:签名signature
        """
        signature = rsa_encrypt(digest, private_key)
        with open("signature.txt", "w") as f:
            f.write(f"sgn = {signature}")
        return signature
    

  • RSA验证算法：

    基本原理：

    $$\begin{gathered} 对签名使用公钥进行解密与信息摘要进行比对，如果一致则验证通过 \\ dgst\equiv s^e(modn) \end{gathered}$$

    验证代码实现：

    def rsa_verify(digest, signature, public_key):
        """
        RSA签名验证函数：使用公钥对签名验证
        return:验证是否成功(bool)
        """
        if digest == rsa_decrypt(signature, public_key):
            return True
        else:
            return False
    

  • RSA公钥与私钥的文件读取：

    • 公钥读取：

      def get_pubkey(pubfile="public_key.txt"):
          """
          公钥文件读取
          params:默认公钥文件名"public_key.txt"
          return:公钥(n,e)
          """
          with open(pubfile, "r") as f:
              for line in f:
                  if line.startswith('n'):
                      n = line.split(' ')[-1]
                  if line.startswith('e'):
                      e = line.split(' ')[-1]
          return n, e
      

    • 私钥读取：

      def get_privkey(privfile="private_key.txt"):
          """
          私钥文件读取
          params:默认私钥文件名:"private_key.txt"
          return:私钥(n,d)
          """
          with open(privfile, "r") as f:
              for line in f:
                  if line.startswith('n'):
                      n = line.split(' ')[-1]
                  if line.startswith('d'):
                      d = line.split(' ')[-1]
          return n, d
      

• RSA算法基本流程实现：

  • 加密对象类型选择：

    def type_choose(path="message.txt"):
        """
        加密对象类型选择(文件或者非文件)
        """
        choice = int(input("plz select the Encryption Type:\n1. file  2. not file:"))
        if choice == 1:
            path = input("plz input the filename or filepath:\n")
            with open(path, "r") as f:
                message = f.read()
        else:
            message = input("plz input the content to be encrypted:")
        return message.encode("utf-8")
    

  • 主流程：

    if __name__ == "__main__":
        # msg = "£.RSA{ha6a_I_am_lzh_i_want_t0_6ai1an}"
        msg = type_choose()
        dgst = s2n(hashlib.sha256(msg).digest())
        pubkey, privkey, prmpair = get_key(1024)
        sgn = rsa_sign(dgst, privkey)
        cpr = rsa_encrypt(s2n(msg), pubkey)
        print(f"cipher is {cpr}")
        print(f"verification is {rsa_verify(dgst, sgn, pubkey)}")
        t1 = time.time()
        rcvr = n2s(rsa_decrypt(cpr, privkey)).decode("utf-8")
        t2 = time.time()
        print(f"message is recovered: {rcvr},time is {t2-t1:.8f}")
        t1 = time.time()
        rcvr_crt = n2s(rsa_decrypt_crt(cpr, privkey[1], prmpair)).decode("utf-8")
        t2 = time.time()
        print(f"message is recovered by CRT: {rcvr_crt},time is: {t2-t1:.8f}")
    
    

  • 运行截图：

  

• RSA参数选择与安全性（思考题）

  1. 模数N：

     • p与q的差距要大

       $$\begin{gathered} 否则当p和q很接近的时候，在已知N得情况下，不妨假设p>q \\ 由{\left(\frac{p+q}{2}\right)}^2=N+{\left(\frac{p-q}{2}\right)}^2 \\ 当左边可开放时，可求出p-q进而求得p/q \end{gathered}$$

     • $gcd(p-1,q-1)$最大公因子应该较小

       原因是我们可以使用满足$de\equiv 1(mod\frac{(p-1)(q-1)}{g})$的较小的d来加快计算，其中$g=gcd(p-1,q-1)$越大，求解得到的d越小越不安全。

     • p与q应该是满足以下条件的强素数：

       • $\exists 大素数p_1,p_2,s.t.p_1|p-1,p_2|p+1$

       • $\exists 四个大素数r_1,r_2,s_1,s_2,s.t.r1|p_1-1,r_2|p_1+1,s_1|p_2-1,s_2|p_2+1$

  2. 加密指数e：

     • 基础条件：$gcd(e,\varphi (n))=1$

     • e不能太小：预防低加密指数（广播）攻击(Lab3)，一般可取16位大小的素数（$65537=2^{16}+1$）

  3. 解密指数d：

     • 一般要求$d>\frac{\sqrt[4]{N}}{3}$,否则当我们使用一个较小的d去确定e时，低解密指数攻击(wiener-attcak)(level 3)可以轻而易举的复原d（p/q）

  4. 其他：如共模攻击（使用同一个模数进行加密）、私钥泄漏分解N（已知$<n,e,d，求p、q$）

     • 详见level1/2等题解

---

• 心得体会

  • 完成大作业（或者说包括Lab&Quiz）我想对我来说最重要的就是能够把理论具像化实现，理论基础固然重要，但我觉得应用也是不可或缺的一部分。

  • 个人是喜欢敲一写代码去实现一些功能算法的，这也是合理利用信息技术的一个方面。但更重要的是，在实操过程中能够更全面更有效（虽然有时候搞半天进度缓慢，比如Lab3）的去学习新知识、去应用理论

  • 当然还有探索深层理论的困难与渴望，⬇️图是Lab3的wp结语（doge[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 当然我也深知自己知识的理论和实践水平远远不够（呜呜期中怎么办～我是小垃圾），所以我一定会逼迫自己更熟练的掌握旧知识，更广泛的去学习新知识（包括但不限于学业知识）

  • 一点建议：是不是能把LAB&QUIZ这些加一点正式的学分（或许选修？或许其他奖励方式？）呢，我觉得这对于像我一样热爱信安数基的同学，既能够在把理论与实践结合的过程中获取自我乐趣，又能够对学业成绩有所帮助！

​