信息计算2019级2班32号王诗琪

王诗琪

RSA加解密和签名
环境：PyCharm3.7.9
1.RSA算法简介
​    RSA加密算法是一种非对称加密算法，加密的秘钥是由公钥和私钥两部分组成秘钥对，公钥用来加密消息，私钥用来对消息进行解密。公钥是公开的，私钥则由用户自己保留。由于公钥是公开的，那么任何人只要获取到公钥，都可以使用公钥来加密发送伪造内容，出于安全性考虑，在发送消息之前我们可以使用RSA来签名。签名使用私钥来进行签名，使用公钥来进行验签。通过签名我们可以确保用户身份的唯一性，从而提高安全性。

2.生成私钥和公钥

1. # 生成public.pem(公钥)和private.pem(私钥)
   
2. def generateKeys():
   
3.     print("1.开始生成私钥和公钥.")
   
4.     # 伪随机数生成器
   
5.     random_generator = Random.new().read
   
6.     # 生成秘钥对实例对象：2048是秘钥的长度
   
7.     rsa = RSA.generate(2048, random_generator)
   
8.     # 获取公钥，保存到文件
   
9.     private_pem = rsa.exportKey()
   
10.     with open('private.pem', 'wb') as f:
    
11.         f.write(private_pem)
    
12.     # 获取私钥，保存到文件
    
13.     public_pem = rsa.publickey().exportKey()
    
14.     with open('public.pem', 'wb') as f:
    
15.         f.write(public_pem)
    
16.     print("2.生成成功.")
    
17.     print("----------------------------------")

复制代码

3.加密与解密

1. # 用公钥加密，然后用私钥解密
   
2. def pubEncryAndprivDecry(content_size):
   
3.     # 公钥加密
   
4.     with open("public.pem") as f:
   
5.         # 读取文件中的公钥
   
6.         key = f.read()
   
7.         rsakey = RSA.importKey(key)
   
8.         # 进行加密
   
9.         cipher = Cipher_pkcs1_v1_5.new(rsakey)
   
10.         cipher_text = base64.b64encode(cipher.encrypt(content_size.encode()))
    
11.         print('3.加密结果：'+cipher_text.decode())
    
12.     with open("encrypted_data", "wb") as f:
    
13.         f.write(cipher_text)
    
14. 
    
15.     # 私钥解密
    
16.     with open("private.pem") as f:
    
17.         key = f.read()
    
18.         prikey = RSA.importKey(key)
    
19.         cipher2 = Cipher_pkcs1_v1_5.new(prikey)
    
20.         with open("encrypted_data") as f:
    
21.             data = f.read()
    
22.             text = cipher2.decrypt(base64.b64decode(data), 'DecryptError')
    
23.             print('4.解密结果：'+text.decode())

复制代码

4.签名和验签

1. # 私钥进行签名，然后用公钥去验证签名
   
2. def privSignAndPubAttesation(content_size):
   
3.     # 私钥签名
   
4.     with open("private.pem") as f:
   
5.         key = f.read()
   
6.         rsakey = RSA.importKey(key)
   
7.         signer = Signature_pkcs1_v1_5.new(rsakey)
   
8.         digest = SHA.new(content_size.encode())
   
9.         sign_data = signer.sign(digest)
   
10.         signature = base64.b64encode(sign_data)
    
11.         print('5.签名结果：'+signature.decode())
    
12. 
    
13.     # 公钥验证
    
14.     with open("public.pem") as f:
    
15.         key = f.read()
    
16.         rsakey = RSA.importKey(key)
    
17.         verifier = Signature_pkcs1_v1_5.new(rsakey)
    
18.         digest = SHA.new(content_size.encode())
    
19.         is_matched = verifier.verify(digest, base64.b64decode(signature))
    
20.         print('6.验签结果：'+str(is_matched))
    

复制代码

5.完整代码

1. import base64
   
2. from Crypto import Random
   
3. from Crypto.Hash import SHA
   
4. from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
   
5. from Crypto.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5
   
6. from Crypto.PublicKey import RSA
   
7. 
   
8. 
   
9. # 生成public.pem(公钥)和private.pem(私钥)
   
10. def generateKeys():
    
11.     print("1.开始生成私钥和公钥.")
    
12.     # 伪随机数生成器
    
13.     random_generator = Random.new().read
    
14.     # 生成秘钥对实例对象：2048是秘钥的长度
    
15.     rsa = RSA.generate(2048, random_generator)
    
16.     # 获取公钥，保存到文件
    
17.     private_pem = rsa.exportKey()
    
18.     with open('private.pem', 'wb') as f:
    
19.         f.write(private_pem)
    
20.     # 获取私钥，保存到文件
    
21.     public_pem = rsa.publickey().exportKey()
    
22.     with open('public.pem', 'wb') as f:
    
23.         f.write(public_pem)
    
24.     print("2.生成成功.")
    
25.     print("----------------------------------")
    
26. 
    
27. 
    
28. # 用公钥加密，然后用私钥解密
    
29. def pubEncryAndprivDecry(content_size):
    
30.     # 公钥加密
    
31.     with open("public.pem") as f:
    
32.         # 读取文件中的公钥
    
33.         key = f.read()
    
34.         rsakey = RSA.importKey(key)
    
35.         # 进行加密
    
36.         cipher = Cipher_pkcs1_v1_5.new(rsakey)
    
37.         cipher_text = base64.b64encode(cipher.encrypt(content_size.encode()))
    
38.         print('3.加密结果：'+cipher_text.decode())
    
39.     with open("encrypted_data", "wb") as f:
    
40.         f.write(cipher_text)
    
41. 
    
42.     # 私钥解密
    
43.     with open("private.pem") as f:
    
44.         key = f.read()
    
45.         prikey = RSA.importKey(key)
    
46.         cipher2 = Cipher_pkcs1_v1_5.new(prikey)
    
47. 
    
48.         with open("encrypted_data") as f:
    
49.             data = f.read()
    
50.             text = cipher2.decrypt(base64.b64decode(data), 'DecryptError')
    
51.             print('4.解密结果：'+text.decode())
    
52. 
    
53. 
    
54. # 私钥进行签名，然后用公钥去验证签名
    
55. def privSignAndPubAttesation(content_size):
    
56.     # 私钥签名
    
57.     with open("private.pem") as f:
    
58.         key = f.read()
    
59.         rsakey = RSA.importKey(key)
    
60.         signer = Signature_pkcs1_v1_5.new(rsakey)
    
61.         digest = SHA.new(content_size.encode())
    
62.         sign_data = signer.sign(digest)
    
63.         signature = base64.b64encode(sign_data)
    
64.         print('5.签名结果：'+signature.decode())
    
65. 
    
66.     # 公钥验证
    
67.     with open("public.pem") as f:
    
68.         key = f.read()
    
69.         rsakey = RSA.importKey(key)
    
70.         verifier = Signature_pkcs1_v1_5.new(rsakey)
    
71.         digest = SHA.new(content_size.encode())
    
72.         is_matched = verifier.verify(digest, base64.b64decode(signature))
    
73.         print('6.验签结果：'+str(is_matched))
    
74. 
    
75. 
    
76. def main(content_size):
    
77.     # 生成公钥、私钥
    
78.     generateKeys()
    
79.     # 1. 加密和解密
    
80.     pubEncryAndprivDecry(content_size)
    
81.     # 2. 签名和验签
    
82.     privSignAndPubAttesation(content_size)
    
83.     return 0
    
84. 
    
85. if __name__ == '__main__':
    
86.     print('请输入要加密的内容:')
    
87.     content_size = input()
    
88.     main(content_size)

复制代码

6.运行结果

王诗琪

椭圆加密算法(ECC加密)

1.原理
首先要知道什么是椭圆曲线:一条椭圆曲线就是一组被y^2=x^3+ax+b定义的且满足4a^3+27b^2≠0的点集.
椭圆曲线乘法很简单,除法却很难.其具体来说就是,给定k和G,那么便很容易计算 K=kG (K和G都是椭圆曲线EP(a,b)上的点,k小于点G的阶n).反之知道K和G,我们很难算出k,这就是一个ECC可以利用的难题.其中G被称为基点.
获得公私钥对方式:
1.随机选择一条椭圆曲线EP(a,b),并随机取其中一点G作为基点.
2.随机生成一个k和椭圆曲线EP(a,b)一起编码生成私钥.
3.计算K=kG ,和椭圆曲线EP(a,b)以及基点G一起编码生成公钥.
加密方式:
公钥有K,G和EP(a,b),设要加密的消息为符号message,加密过程:
1.解码m=decodem(message) ,由于无论什么样的文本在计算机中都是以字节串的形式保存的,而字节实际又是二进制数,所以可以认为message可以转换为一个二进制数,设其符号为m.
2.加密前我们需要将m编码到EP(a,b)上的一点M=Embeding(m,EP(a,b)),同时产生一个随机整数r.
3.加密需要使用两个公式:
  C1=M+rK
  C2=rG
4.将C1和C2编码为完整密文C=encodec(C1,C2).
解密方式:
有私钥k和EP(a,b),获得到密文C,要获取到明文.
1.C1,C2=decodec(C)解码密文为两段.
2.M=C1−kC2即C1−kC2=M+rK−k(rG)=M+rK−r(kG)=M获取信息在椭圆曲线上的对应点.
3.m=Searching(M,EP(a,b))通过嵌入找到椭圆曲线上对应点的信息.
4.message=encodem(m)编码信息为明文.
签名方式:
有私钥k和EP(a,b).
1.产生一个随机整数r,并使用明文嵌入的方式获得其在EP(a,b)上的点,记为R(x,y).x,y是R点的横纵坐标.
2.计算消息message和R点横纵坐标x和y的消息摘要,记为h(message,x,y).
3.计算签名 s=r−h(message,x,y)∗k 获得到签名信息s.
验签方式:
有公钥K,G和EP(a,b),同时要验的是h(message,x,y)和s.
1.计算 R^=s∗G+h(message,x,y)∗K获得点R(x^,y^)的坐标.
2.计算h(s,x^,y^),如果h(s,x^,y^)==h(message,x,y)则验签通过,否则验签不通过.

2.代码

1. def get_inverse(mu, p):
   
2.     """
   
3.     获取y的负元
   
4.     """
   
5.     for i in range(1, p):
   
6.         if (i * mu) % p == 1:
   
7.             return i
   
8.     return -1
   
9. 
   
10. 
    
11. def get_gcd(zi, mu):
    
12.     """
    
13.     获取最大公约数
    
14.     """
    
15.     if mu:
    
16.         return get_gcd(mu, zi % mu)
    
17.     else:
    
18.         return zi
    
19. 
    
20. 
    
21. def get_np(x1, y1, x2, y2, a, p):
    
22.     """
    
23.     获取n*p，每次+p，直到求解阶数np=-p
    
24.     """
    
25.     flag = 1  # 定义符号位（+/-）
    
26.     # 如果 p=q  k=(3x2+a)/2y1mod p
    
27.     if x1 == x2 and y1 == y2:
    
28.         zi = 3 * (x1 ** 2) + a  # 计算分子      【求导】
    
29.         mu = 2 * y1  # 计算分母
    
30.     # 若P≠Q，则k=(y2-y1)/(x2-x1) mod p
    
31.     else:
    
32.         zi = y2 - y1
    
33.         mu = x2 - x1
    
34.         if zi * mu < 0:
    
35.             flag = 0  # 符号0为-（负数）
    
36.             zi = abs(zi)
    
37.             mu = abs(mu)
    
38.     # 将分子和分母化为最简
    
39.     gcd_value = get_gcd(zi, mu)  # 最大公約數
    
40.     zi = zi // gcd_value  # 整除
    
41.     mu = mu // gcd_value
    
42.     # 求分母的逆元  逆元： ∀a ∈G ，ョb∈G 使得 ab = ba = e
    
43.     # P(x,y)的负元是 (x,-y mod p)= (x,p-y) ，有P+(-P)= O∞
    
44.     inverse_value = get_inverse(mu, p)
    
45.     k = (zi * inverse_value)
    
46.     if flag == 0:  # 斜率负数 flag==0
    
47.         k = -k
    
48.     k = k % p
    
49.     # 计算x3,y3 P+Q
    
50.     """
    
51.         x3≡k2-x1-x2(mod p)
    
52.         y3≡k(x1-x3)-y1(mod p)
    
53.     """
    
54.     x3 = (k ** 2 - x1 - x2) % p
    
55.     y3 = (k * (x1 - x3) - y1) % p
    
56.     return x3, y3
    
57. 
    
58. 
    
59. def get_rank(x0, y0, a, b, p):
    
60.     """
    
61.     获取椭圆曲线的阶
    
62.     """
    
63.     x1 = x0  # -p的x坐标
    
64.     y1 = (-1 * y0) % p  # -p的y坐标
    
65.     tempX = x0
    
66.     tempY = y0
    
67.     n = 1
    
68.     while True:
    
69.         n += 1
    
70.         # 求p+q的和，得到n*p，直到求出阶
    
71.         p_x, p_y = get_np(tempX, tempY, x0, y0, a, p)
    
72.         # 如果 == -p,那么阶数+1，返回
    
73.         if p_x == x1 and p_y == y1:
    
74.             return n + 1
    
75.         tempX = p_x
    
76.         tempY = p_y
    
77. 
    
78. 
    
79. def get_param(x0, a, b, p):
    
80.     """
    
81.     计算p与-p
    
82.     """
    
83.     y0 = -1
    
84.     for i in range(p):
    
85.         # 满足取模约束条件，椭圆曲线Ep(a,b)，p为质数，x,y∈[0,p-1]
    
86.         if i ** 2 % p == (x0 ** 3 + a * x0 + b) % p:
    
87.             y0 = i
    
88.             break
    
89.     # 如果y0没有，返回false
    
90.     if y0 == -1:
    
91.         return False
    
92.     # 计算-y（负数取模）
    
93.     x1 = x0
    
94.     y1 = (-1 * y0) % p
    
95.     return x0, y0, x1, y1
    
96. 
    
97. 
    
98. def get_graph(a, b, p):
    
99.     """
    
100.     输出椭圆曲线散点图
     
101.     """
     
102.     x_y = []
     
103.     # 初始化二维数组
     
104.     for i in range(p):
     
105.         x_y.append(['-' for i in range(p)])
     
106.     for i in range(p):
     
107.         val = get_param(i, a, b, p)  # 椭圆曲线上的点
     
108.         if val:
     
109.             x0, y0, x1, y1 = val
     
110.             x_y[x0][y0] = 1
     
111.             x_y[x1][y1] = 1
     
112.     print("椭圆曲线的散列图为：")
     
113.     for i in range(p):  # i= 0-> p-1
     
114.         temp = p - 1 - i  # 倒序
     
115.         # 格式化输出1/2位数，y坐标轴
     
116.         if temp >= 10:
     
117.             print(temp, end=" ")
     
118.         else:
     
119.             print(temp, end="  ")
     
120.         # 输出具体坐标的值，一行
     
121.         for j in range(p):
     
122.             print(x_y[j][temp], end="  ")
     
123.         print("")  # 换行
     
124.     # 输出 x 坐标轴
     
125.     print("   ", end="")
     
126.     for i in range(p):
     
127.         if i >= 10:
     
128.             print(i, end=" ")
     
129.         else:
     
130.             print(i, end="  ")
     
131.     print('\n')
     
132. 
     
133. 
     
134. def get_ng(G_x, G_y, key, a, p):
     
135.     """
     
136.     计算nG
     
137.     """
     
138.     temp_x = G_x
     
139.     temp_y = G_y
     
140.     while key != 1:
     
141.         temp_x, temp_y = get_np(temp_x, temp_y, G_x, G_y, a, p)
     
142.         key -= 1
     
143.     return temp_x, temp_y
     
144. 
     
145. 
     
146. def ecc_main():
     
147.     while True:
     
148.         a = int(input("请输入椭圆曲线参数a(a>0)的值："))
     
149.         b = int(input("请输入椭圆曲线参数b(b>0)的值："))
     
150.         p = int(input("请输入椭圆曲线参数p(p为素数)的值："))  # 用作模运算
     
151.         # 条件满足判断
     
152.         if (4 * (a ** 3) + 27 * (b ** 2)) % p == 0:
     
153.             print("您输入的参数有误，请重新输入！！！\n")
     
154.         else:
     
155.             break
     
156.     # 输出椭圆曲线散点图
     
157.     get_graph(a, b, p)
     
158.     # 选点作为G点
     
159.     print("user1：在如上坐标系中选一个值为G的坐标")
     
160.     G_x = int(input("user1：请输入选取的x坐标值："))
     
161.     G_y = int(input("user1：请输入选取的y坐标值："))
     
162.     # 获取椭圆曲线的阶
     
163.     n = get_rank(G_x, G_y, a, b, p)
     
164.     # user1生成私钥，小key
     
165.     key = int(input("user1：请输入私钥小key（<{}）：".format(n)))
     
166.     # user1生成公钥，大KEY
     
167.     KEY_x, kEY_y = get_ng(G_x, G_y, key, a, p)
     
168. 
     
169.     # user2阶段
     
170.     # user2拿到user1的公钥KEY，Ep(a,b)阶n，加密需要加密的明文数据
     
171.     # 加密准备
     
172.     k = int(input("user2：请输入一个整数k（<{}）用于求kG和kQ：".format(n)))
     
173.     k_G_x, k_G_y = get_ng(G_x, G_y, k, a, p)  # kG
     
174.     k_Q_x, k_Q_y = get_ng(KEY_x, kEY_y, k, a, p)  # kQ
     
175.     # 加密
     
176.     plain_text = input("user2：请输入需要加密的字符串:")
     
177.     plain_text = plain_text.strip()
     
178.     # plain_text = int(input("user1：请输入需要加密的密文："))
     
179.     c = []
     
180.     print("密文为：", end="")
     
181.     for char in plain_text:
     
182.         intchar = ord(char)
     
183.         cipher_text = intchar * k_Q_x
     
184.         c.append([k_G_x, k_G_y, cipher_text])
     
185.         print("({},{}),{}".format(k_G_x, k_G_y, cipher_text), end="-")
     
186. 
     
187.     # user1阶段
     
188.     # 拿到user2加密的数据进行解密
     
189.     # 知道 k_G_x,k_G_y，key情况下，求解k_Q_x,k_Q_y是容易的，然后plain_text = cipher_text/k_Q_x
     
190.     print("\nuser1解密得到明文：", end="")
     
191.     for charArr in c:
     
192.         decrypto_text_x, decrypto_text_y = get_ng(charArr[0], charArr[1], key, a, p)
     
193.         print(chr(charArr[2] // decrypto_text_x), end="")
     
194. 
     
195. 
     
196. if __name__ == "__main__":
     
197.     print("*************ECC椭圆曲线加密*************")
     
198.     ecc_main()

复制代码

3.运行结果