接口数据使用了 RSA 加密和签名？一篇文章带你了解

接口数据使用了RSA加密和签名？一篇文章带你搞定！

1、前言

很多童鞋在工作中，会遇到一些接口使用RSA加密和签名来处理的请求参数，那么遇到这个问题的时候，第一时间当然是找开发要加解密的方法，但是开发给加解密代码，大多数情况都是java,c++，js等语言实现的，加解密的代码虽然有了，但是咱们身为一个测试，使用python做的自动化，并不是什么语言都会，这个时候就会比较尴尬了，看着这一团加解密的代码，自己却不知从何下手，再去找开发给写个python版本的，开发估计不一定搭理你，就算搭理你，开发也未必会python，那么今天咱们就来讲讲如何通过python来实现RSA加解密和签名

2、RSA算法简介：

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

1、加密和签名的区别

加密：

比方现在有两个人A和B，A要给B传递机密的信息，为了避免信息泄露，B事先通过RSA加密算法生成了一对秘钥，并且将公钥事先给到A，私钥则自己保留，A给B传递消息的时候，先使用B给的公钥对消息进行加密，然后再将消息传递给B，B拿到加密后的消息，可以通过私钥对消息进行解密，消息在传递过程中就算被他人获取了也没关系，没有私钥就没办法对消息进行解密。但是这个时候还有一个问题，公钥一般都是公开的，会同时给到多个人，那么如果这个时候还有一个人C，获取到了这个公钥，他通过公钥对消息进行加密，想冒充A来给B发信息，那么B接受到信息之后，能够通过私钥来对消息进行解密，但是无法确认这个信息到底是不是A发的（有可能是别拿的公钥加密发的），为了区分发送者的身份，那么这个时候我们就要用到签名。

签名：

虽然我们通过加密能够确保发送的消息不被泄密，但是却无法区分发送者的身份，A用户为了区分自己的身份，同样也生成了一对秘钥，事先将公钥给到B，发送消息的时候，先用B给的公钥对消息进行加密，然后用A自己的私钥生成签名，最后将加密的消息和签名一起发过去给B，B接收到A发送的数据之后，首先使用A用户的公钥对签名信息进行验签，确认身份信息，如果确认是A用户，然后再使用自己的私钥对加密消息进行解密。 A的消息通过加密和签名处理之后，再发送出去给B，就算被人截获了，也没有关系，没有B的私钥无法对消息进行解密，就算获取A的公钥，想要发送伪造信息，没有A私钥也无法进行签名。同样B给A回复消息的时候，可以通过B的公钥进行加密，然后使用自己的私钥生成签名，A接收到数据化使用同样的方式进行解密验证身份。 这样一来就能够做到万无一失。如下图：

3、python实现RSA加解密和签名加解签

接下来我们就来使用python来实现RSA加密与签名，使用的第三方库是Crypto：

1、生成秘钥对

在这边为了方便演示，咱们先手动生成一个密钥对（项目中的秘钥对由开发来生成，会直接给到咱们）

生成秘钥对的时候，可以指定生成秘钥的长度，一般推荐使用1024bit, 1024bit的rsa公钥，加密数据时，最多只能加密117byte的数据），数据量超过这个数，则需要对数据进行分段加密，但是目前1024bit长度的秘钥已经被证明了不够安全，尽量使用2048bit长度的秘钥。2048bit长度的秘钥，最多245byte长度的数据

计算公式如下：

秘钥长度/8-11 = 最大加密量（单位：byte）

下面生成一对1024bit的秘钥

3. from Crypto import Random

5. from Crypto.PublicKey import RSA

8. # 伪随机数生成器

10. random_gen = Random.new().read

13. # 生成秘钥对实例对象：1024是秘钥的长度

15. rsa = RSA.generate(1024, random_gen)

18. # 获取公钥，保存到文件

20. private_pem = rsa.exportKey()

22. with open('private.pem', 'wb') as f:

24. f.write(private_pem)

27. # 获取私钥保存到文件

29. public_pem = rsa.publickey().exportKey()

31. with open('public.pem', 'wb') as f:

33. f.write(public_pem)

公钥格式：

私钥的格式：

2、加密与解密

1、公钥加密

2. import base64

4. from Crypto.PublicKey import RSA

6. from Crypto.Cipher import PKCS1_v1_5

10. msg = "待加密明文内容"

13. # 读取文件中的公钥

15. key = open('public.pem').read()

17. publickey = RSA.importKey(key)

19. # 进行加密

21. pk = PKCS1_v1_5.new(publickey)

23. encrypt_text = pk.encrypt(msg.encode())

25. # 加密通过base64进行编码

27. result = base64.b64encode(encrypt_text)

29. print(result)

2、私钥解密

2. import base64

4. from Crypto.PublicKey import RSA

6. from Crypto.Cipher import PKCS1_v1_5

8. # 密文

10. msg='bAlnUNEJeDLnWikQs1ejwqPTo4qZ7RWxgFwoO4Bfg3C7EY+1HN5UvJYJ2h6047K6vNjG+TiIxc0udTR7a12MivSA+DwoGjwFIb25u3zc+M8KTCaCT5GdSumDOto2tsKYaVDKCPZpdwYdzYwlVijr6cPcchQTlD1yfKk2khhNchU='

13. # base64解码

15. msg = base64.b64decode(msg)

17. # 获取私钥

19. privatekey = open('private.pem').read()

21. rsakey = RSA.importKey(privatekey)

23. # 进行解密

25. cipher = PKCS1_v1_5.new(rsakey)

27. text = cipher.decrypt(msg, 'DecryptError')

29. # 解密出来的是字节码格式，decodee转换为字符串

31. print(text.decode())

3、分段加密和解密

上面生成秘钥的时候提到过在我们加密的时候，如果数据长度超过了当前秘钥的所能处理最大长度，则需要进行分段加密，

分段加密：通俗易懂的讲就是把原来一长串的数据，分割成多段，每段的大小控制在秘钥的最大加密数量之内，加密完了之后再把数据进行拼接。

分段解密：经过分段加密的数据，在进行解密的时候我们也要将它进行分成多段，然后解密之后再进行拼接就能得到原来的数据内容。

分段加密和解密的代码如下：

2. import base64

4. from Crypto.PublicKey import RSA

6. from Crypto.Cipher import PKCS1_v1_5

11. def cipher(msg):

13. """

15. 公钥加密

17. :param msg: 要加密内容

19. :return: 加密之后的密文

21. """

23. # 获取公钥

25. key = open('public.pem').read()

27. publickey = RSA.importKey(key)

29. # 分段加密

31. pk = PKCS1_v1_5.new(publickey)

33. encrypt_text = []

35. for i in range(0,len(msg),100):

37. cont = msg[i:i+100]

39. encrypt_text.append(pk.encrypt(cont.encode()))

41. # 加密完进行拼接

43. cipher_text = b''.join(encrypt_text)

45. # base64进行编码

47. result = base64.b64encode(cipher_text)

49. return result.decode()

53. def decrypt(msg):

55. """

57. 私钥进行解密

59. :param msg: 密文：字符串类型

61. :return: 解密之后的内容

63. """

65. # base64解码

67. msg = base64.b64decode(msg)

69. # 获取私钥

71. privatekey = open('private.pem').read()

73. rsakey = RSA.importKey(privatekey)

75. cipher = PKCS1_v1_5.new(rsakey)

77. # 进行解密

79. text = []

81. for i in range(0,len(msg),128):

83. cont = msg[i:i+128]

85. text.append(cipher.decrypt(cont,1))

87. text = b''.join(text)

89. return text.decode()

3、签名和验签

1、私钥签名

2. from Crypto.Hash import SHA

4. from Crypto.Signature import PKCS1_v1_5 as Sig_pk

6. from Crypto.PublicKey import RSA

8. import base64

11. # 待签名内容

13. name = "musen"

15. # 获取私钥

17. key = open('private.pem', 'r').read()

19. rsakey = RSA.importKey(key)

21. # 根据sha算法处理签名内容 (此处的hash算法不一定是sha,看开发)

23. data = SHA.new(name.encode())

25. # 私钥进行签名

27. sig_pk = Sig_pk.new(rsakey)

29. sign = sig_pk.sign(data)

31. # 将签名后的内容，转换为base64编码

33. result = base64.b64encode(sign)

35. # 签名结果转换成字符串

37. data = result.decode()

39. print(data)

2、公钥验签

2. from Crypto.Hash import SHA

4. from Crypto.Signature import PKCS1_v1_5 as Sig_pk

6. from Crypto.PublicKey import RSA

8. import base64

12. # 签名之前的内容

14. name = "musen"

17. # 签名数据

19. data="X3Gg+wd7UDh4X8ra+PGCyZFUrG+6jDeQt6ajMA0EjwoDwxlddLzYoS4dtjQ2q5WCcRhxcp8fjEyoPXBmJE9rMKDjEIeE/VO0sskbJiO65fU8hgcqdWdgbVqRryhOw+Kih+I6RIeNRYnOB8GkGD8Qca+n9JlOELcxLRdLo3vx6dw="

21. # base64解码

23. data = base64.b64decode(data)

25. # 获取公钥

27. key = open('public.pem').read()

29. rsakey = RSA.importKey(key)

31. # 将签名之前的内容进行hash处理

33. sha_name = SHA.new(name.encode())

35. # 验证签名

37. signer = Sig_pk.new(rsakey)

39. result = signer.verify(sha_name, data)

41. # 验证通过返回True 不通过返回False

43. print(result)