https学习笔记二----基础密码学知识和python pycrypto库的介绍使用

 

        在更详细的学习HTTPS之前，我也觉得很有必要学习下HTTPS经常用到的加密编码技术的背景知识。密码学是对报文进行编解码的机制和技巧。可以用来加密数据，比如数据加密常用的AES/ECB/PKCS5Padding加密，也可以用来防止报文的篡改，使用RSA2048withSHA256签名验证，使用MD5签名等。如果这些不清楚，即使学习简单能做一个HTTPS的服务器和客户端，实际项目上遇见这类问题还是束手无策，下面介绍下数字加密的一些常用的术语。

一、密码学基础概念

      1、密码 ： 对文本进行编码，使偷窥者无法识别的算法。是一套编码方案，一种特殊的报文编码和相应的解码方式的结合体。

           加密之前的原始报文称为明文，使用密码之后的报文叫密文。一个简单的例子：

                  

 

            这个例子是著名的三字符循环移位密码rot3，在字母中循环移位3个字符。

                       

 

      2、密钥 ： 改变密码行为的数字化参数。

          rot3这种密码是比较简单的算法，用笔和纸都能解码出来，十分的不安全，于是出现了密钥。比如rot3算法转换使用密钥的算法就是“循环移位N字符”密码。N就是密钥，N值不通，即使是同一个算法，编码                   出来的报文也是不一样的。

                 

     3、 数字密码：一段明文P，一个编码函数E，一个数字密钥e，经过密码E，能产生密文C。密文C通过解密函数D和解密密钥d，可以将明文P解码出来

           

                       

              对称密钥加密系统：编码和解码使用相同密钥的算法。e=d。

              在对称密钥加密技术中，发送端和接收端共享相同的密钥进行通信。比较流行的对称加密算法包括：DES，RC4,RC2。密钥值的数量取决于密钥的位数。比如使用使用8位的密钥就可能有256个可能的密钥                  值，如果一个算法使用8位的密钥，那这个加密算法是很容易被破解的，对于对称密钥的加密技术，128位的密钥被认为是非常强大的了。需要10的19次方年才能破解（之前貌似有新闻说已破解，未仔细究）。

       

                    使用对称密钥有一个缺点：发送方和接收方在相互对话前，需要建立一个共享的保密的密钥值。比如服务器X跟客户端A交互，服务器X需要保存XA密钥在服务器，与客户端B交互，需要保存XB密钥。每一对              通信实体都需要自己的私钥。如果有N个节点，每个节点都要和其他的N-1节点进行通话，那对管理密钥，简直是异常噩梦。

                             

 

 

      4、非对称密钥加密系统： 编码和解码使用不同密钥的算法。

             使用对称密钥的密码，密钥都是非公开的，只有这一对通话实体才知道彼此选择的密钥，但是对于非对称密钥，给所有的客户端的密钥都是一样的，是公开的。而解码的密钥是私有的，只有服务器知道，只有服       务器端才能解密。这样服务器X只需要将其ex密钥公布于众，任何人想要给X发信息，使用同一个密钥即可。但是只有服务器X使用私有密钥才能正确的解密报文。比较流行的有RSA。

                           

     5、 数字签名：用来延期报文未被伪造篡改的校验和。私钥签名，公钥验签。

                  数字签名通常是用非对称公开密钥技术产生的。以节点A给节点B发送报文，附加签名为例：

            A、节点A从报文中选取定长的数据，在定长的摘要。

            B、节点A对摘要应用了一个“签名”函数，这个函数将用户的私钥密钥做为参数，只有节点A才知道这个私钥。

            C、一旦计算出签名，节点A就将其附加在报文的末尾，将报文和签名发送给B。

            D、B接收到报文后，需要确定报文确实是节点A发送过来的且没有篡改，使用公开的密钥的反函数。拆包后的摘要与A不一致，则说明报文在传输过程中被篡改了。

                     

 

      6、数字证书：由一个可信的组织验证和签发的识别信息。一般用于证明服务器是可信任的服务器。跟数字签名完全不是一个概念。

              数字证书中包含了由某个受信任组织担保的用户或者公司的相关信息。比如我们的身份证和护照，是由政府这个权威机构在特殊的纸上签发且盖章登记的，很难伪造，可信度很高。数字证书的所有信息都是由一个官方的“证书颁发机构”以数字方式签发的，一般包含以下内容：

      

           任何人都可以创建一个数字证书，但并不是所有人都能获取受人尊敬的签发权，证书颁发机构CA常见的有谷歌等，一般情况下，获取一个权威机构签发的证书的费用是相当昂贵的，所以可以使用某类工具（openssl），自己注册CA组织，创建数字证书。现在大部分的证书都以X.509 V3作为一准标准格式，将证书信息规范到一些可解析的字段信息中，大致如下所示。

                            

                             

          HTTPS协议建立一个安全的事务后，现在的浏览器会子的那个的获取所连接服务器的数字证书。如果服务器端没有证书，安全连接就会失败（但是客户端可以设置是否要校验证书的合法性）。浏览器在收到证书后需要对签名颁发机构进行检查。

          如果这个机构是很有名的权威公共签名机构，浏览器可能早已知道其公钥，接下来浏览器就需要验证签名的正确性，使用公钥和解密方法，拆包获取摘要信息，如果摘要信息与证书中的摘要信息一致，则证书的完整性得到了确定。

         如果浏览器对机构一无所知，浏览器无法确定是否需要信任这个组织的签名颁发的证书，通常浏览器会向用户显示一个对话框，让用户自行选择是否信任。

          

 

二、python的密码学模块pycrypto的简单学习

      1、pycryto 库简介：

             官网的手册的链接：http://pythonhosted.org/pycrypto/

             pycryto模块不是Python的内置模块，pycrypto模块是一个实现了各种算法和协议的加密模块的结合，提供了各种加密方式对应的多种加密算法的实现，包括 单向加密、对称加密以及公钥加密和随机数操作。hashlib和hmac虽然是Python的内置模块，但是它们只提供了单向加密相关算法的实现，如果要使用对称加密算法（如, DES，AES等）或者公钥加密算法我们通常都是使用pycryto这个第三方模块来实现。存在以下几个子包：

            

           pycryto能实现大致3种类型的数据加密（单向加密、对称加密 和非对称加密），产生随机数，生成密钥对，数字签名。

          A、单向加密，Crypto.Hash其中中包含MD5、SHA1、SHA256等，这些算法又称为“哈希算法”或“散列算法”或“数据摘要算法”。Python内置的hashlib和hmac也可以实现。

          B、对称加密，Crypto.Cipher，如常见的DES等。

          C、非对称加密，Crypto.Cipher ，如常见的AES加密等。

          D、随机数操作，Crypto.Random，也可以使用Python内置的random模块和secrets模块产生。

          E、生成密钥对，Crypto.PublicKey，支持生成RSA算法的密钥对生成。

          F、数字签名与验签，可能需要使用到Crypto.PublicKey，Crypto.Hash，Crypto.Signature。

     2、安装

          pycryto不是Python的内置模块，所以在使用它之前需要通过Python模块管理工具(如pip)来安装，通过使用命令安装：pip install pycryto。pycrypto模块是用C语言实现的，Python模块管理工具在安装它时需要使用C/C++编译工具对它的代码进行编译。这一点需要注意下，可能安装的时候会报错。

     3、实例

     A.  使用SHA256算法获取一段数据的摘要信息

from Crypto.Hash import SHA256

hash = SHA256.new()
hash.update('Hello, World!')
digest = hash.hexdigest()
print(digest)

   B、AES/ECB/PKCS5Padding加密。

         这是AES加密一般需要知道的格式，ECB是AES支持的模式，PKCS5Padding是填充方法。如果对AES算法不清楚，肯定就不明白模式，填充是什么意思，建议可以看下https://www.cnblogs.com/OneFri/p/5924605.html 这篇博客，在了解大致算法原理后，才能充分学习这个库。

from Crypto.Cipher import AES

# 加密与解密所使用的密钥，长度必须是16的倍数
AESkey = 'PLKQ017MD5AESKEY'
# 要加密的明文数据，长度必须是16的倍数，可能不足，就需要填充
plain_data = "Hello, World!"

def encrypt(self,obj,data):
    bs = AES.block_size
    pad = lambda s: s + (bs - len(s) % bs) * chr(bs - len(s) % bs)
    encrypt_msg = obj.encrypt(pad(data))
    return  b2a_hex(encrypt_msg)

# 数据加密
obj = AES.new(AESkey, AES.MODE_ECB)
cipher_data = obj .encrypt(obj,plain_data)
print('cipher data：', cipher_data)

     C、使用RSA算法生成密钥对

from Crypto import Random
from Crypto.PublicKey import RSA

# 获取一个伪随机数生成器
random_generator = Random.new().read
# 获取一个rsa算法对应的密钥对生成器实例
rsa = RSA.generate(1024, random_generator)

# 生成私钥并保存
private_pem = rsa.exportKey()
with open('rsa.key', 'w') as f:
    f.write(private_pem)

# 生成公钥并保存
public_pem = rsa.publickey().exportKey()
with open('rsa.pub', 'w') as f:
    f.write(public_pem)

私钥：

-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQCo7vV5xSzEdQeFq9n5MIWgIuLTBHuutZlFv+Ed8fIk3yC4So/d
y1f64iuYFcDeNU7eVGqTSkHmAl4AihDXoaH6hxohrcX0bCg0j+VoQMe2zID7MzcE
d50FhJbuG6JsWtYzLUYs7/cQ3urZYwB4PEVa0WxQj2aXUMsxp6vl1CgB4QIDAQAB
AoGAS/I5y4e4S43tVsvej6efu1FTtdhDHlUn1fKgawz1dlwVYqSqruSW5gQ94v6M
mZlPnqZGz3bHz3bq+cUYM0jH/5Tygz4a+dosziRCUbjMsFePbJ4nvGC/1hwQweCm
+7sxog4sw91FrOfAg/iCcoeho0DghDolH9+zzwRYPIWUyUECQQDFGe+qccGwL9cU
v+GmZxtF8GkRL7YrXI7cvnZhnZZ7TANjxlYukLGEpiFGIDd0Aky1QhkK18L8DTO4
+iGXTpgJAkEA22o03/1IqeRBofbkkDmndArHNUnmv5pyVFaLKPoVgA4A1YsvqxUL
DK6RwFGONUMknBWY59EDKCUdIf3CsVIhGQJAJKDMRB19xBMv4iBCe9z/WYDy1YnL
TcWWmvkeIMfbVjBrFNif3WlwQ9lnp5OHGpzuymRtKPGtv49ohECfi3HEmQJAPI+n
AoAdk07+Up8b3TccoinrbCj2uMH/dongpTHJx2uWDVr6kEUhpKF2d1fLYaYjr7VC
XBHTxjvgO6aYG2to2QJBAIzDugOSTeQFpidCoewfa0XX4guF+WRf8wzyBC/XE6TY
3cIY05sjbpfiVwW/Cb8Z2ia8EgBTGN8HSIFOUQ2jRl4=
-----END RSA PRIVATE KEY-----

公钥：

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCo7vV5xSzEdQeFq9n5MIWgIuLT
BHuutZlFv+Ed8fIk3yC4So/dy1f64iuYFcDeNU7eVGqTSkHmAl4AihDXoaH6hxoh
rcX0bCg0j+VoQMe2zID7MzcEd50FhJbuG6JsWtYzLUYs7/cQ3urZYwB4PEVa0WxQ
j2aXUMsxp6vl1CgB4QIDAQAB
-----END PUBLIC KEY-----

         D、RSA2048withSHA256。数据先做SHA256摘要，再做RSA签名。具体签名的一些基础理论知识可以参考这章节签名的笔记。

#!/usr/bin/env python2.7
#coding:utf-8

import cgi, base64
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA256
import base64
import hashlib


#私钥文件
priKey = '''-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQDKoeRzRVf8WoRSDYYqUzThpYCr90jfdFwTSXHJ526K8C6TEwdT
UA+CFPQPRUg9jrYgFcown+J2myzO8BRLynD+XHb9ilLb49Mqk2CvDt/yK32lgHv3
QVx14Dpb6h8isjncSF965fxBxlHGbvPwnHkJ9etRIYdYV3QpYohFszH3wQIDAQAB
AoGAFhKqkw/ztK6biWClw8iKkyX3LURjsMu5F/TBK3BFb2cYe7bv7lhjSBVGPL+c
TfBU0IvvGXrhLXBb4jLu0w67Xhggwwfc86vlZ8eLcrmYVat7N6amiBmYsw20GViU
UFmePbo1G2BXqMA43JxqbIQwOLZ03zdw6GHj6EVlx369IAECQQD4K2R3K8ah50Yz
LhF7zbYPIPGbHw+crP13THiYIYkHKJWsQDr8SXoNQ96TQsInTXUAmF2gzs/AwdQg
gjIJ/dmBAkEA0QarqdWXZYbse1XIrQgBYTdVH9fNyLs1e1sBmNxlo4QMm/Le5a5L
XenorEjnpjw5YpEJFDS4ijUI3dSzylC+QQJARqcD6TGbUUioobWB4L9GD7SPVFxZ
c3+EgcxRoO4bNuCFDA8VO/InP1ONMFuXLt1MbCj0ru1yFCyamc63NEUDAQJBALt7
PjGgsKCRuj6NnOcGDSbDWIitKZhnwfqYkAApfsiBQkYGO0LLaDIeAWG2KoCB9/6e
lAQZnYPpOcCubWyDq4ECQQCrRDf0gVjPtipnPPS/sGN8m1Ds4znDDChhRlw74MI5
FydvHFumChPe1Dj2I/BWeG1gA4ymXV1tE9phskV3XZfq
-----END RSA PRIVATE KEY-----'''

#公钥文件
pubKey = '''-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDKoeRzRVf8WoRSDYYqUzThpYCr
90jfdFwTSXHJ526K8C6TEwdTUA+CFPQPRUg9jrYgFcown+J2myzO8BRLynD+XHb9
ilLb49Mqk2CvDt/yK32lgHv3QVx14Dpb6h8isjncSF965fxBxlHGbvPwnHkJ9etR
IYdYV3QpYohFszH3wQIDAQAB
-----END PUBLIC KEY-----'''

def sign(data):
    key = RSA.importKey(priKey)
    h = SHA256.new(data)
    signer = PKCS1_v1_5.new(key)
    signature = signer.sign(h)
    return base64.b64encode(signature)

raw_data ='test1'
sign_data = sign(raw_data)
print "sign_data: ", sign_data

 

三、URL编码 

   A、背景：为什么需要进行URL编码

      URL使用的是ASCII字符集，通过因特网进行发送数据,URL只能使用英文字母、阿拉伯数字和某些标点符号，不能使用其他文字和符号。

      eg：在Http协议中参数的传输是"key=value"这种键值对形式的，如果要传多个参数就需要用“&”符号对键值对进行分割。针对“name1=value1&name2=value2”，如果需要传输，转义成ASCII码后为： 6E616D6531 3D 76616C756531 26 6E616D6532 3D 76616C756532。

           在服务器收到这段数据后，怎么解析呢? 读到3D这字节后，服务端就知道签名字符串表示一个key，读到26时，说明从刚才3D到26子节之间的是上一个key的value，那如果value的值包含&怎么办呢？比如传输的是name1=va&lu=e1&name2=value2。name1 = va&lu；name2 = value2。如果还按照之前的方法解析就会成为3个key，与需要不符合。

           在这种情况下，就需要对特殊字符进行URL转义。

  B: URL转义关键的官方文档

　          不安全字符：还有一些字符，当他们直接放在Url中的时候，可能会引起解析程序的歧义。这些字符被视为不安全字符，常见的有：

    · 空格：Url在传输的过程，或者用户在排版的过程，或者文本处理程序在处理Url的过程，都有可能引入无关紧要的空格，或者将那些有意义的空格给去掉。

    · 引号以及<>：引号和尖括号通常用于在普通文本中起到分隔Url的作用

    · #：通常用于表示书签或者锚点

    · %：百分号本身用作对不安全字符进行编码时使用的特殊字符，因此本身需要编码

    · {}|\^[]`~：某一些网关或者传输代理会篡改这些字符

ASCII Control characters： These characters are not printable.Characters: Includes the ISO-8859-1 (ISO-Latin) character ranges 00-1F hex (0-31 decimal) and 7F (127 decimal.)

  Non-ASCII characters： These are by definition not legal in URLs since they are not in the ASCII set.Characters: Includes the entire "top half" of the ISO-Latin set 80-FF hex (128-255 decimal.)

  Reserved characters：

URLs use some characters for special use in defining their syntax. When these characters are not used in their special role inside a URL, they need to be encoded.Characters: $ & + ; / : , = ? @"Unsafe characters"Why: Some characters present the possibility of being misunderstood within URLs for various reasons. These characters should also always be encoded.Characters:< > # % { } | \ ~ ^ [ ] `

C: python常见的url转义库：urllib的quote和urlencode。

     1.urllib.urlencode(query, doseq=0)

     接受参数形式为dict类型：[(key1, value1), (key2, value2),...] 和 {'key1': 'value1', 'key2': 'value2',...}

     返回的是形如'key2=value2&key1=value1'字符串。

#!/usr/bin/env python
#coding=UTF-8
import urllib

if __name__ =="__main__":   
    print  urllib.urlencode([(1, 'a+b+c'), (2, 'a=b=c')], doseq=0)  

       打印：1=a%2Bb%2Bc&2=a%3Db%3Dc

        2、urllib.quote(s, safe='/')

       接受参数s为字符串，safe是指定某字符不被urlencode，默认为'/'，如指定'+'、'/'不需转换，传 '+/' 和 '+ /' 均可。另外此方法会将“空格”转换为“%20”

#!/usr/bin/env python
#coding=UTF-8
import urllib


if __name__ =="__main__":
    print urllib.quote("a+b+c", safe='')
    print urllib.quote("a=b=c", safe='')
 

       打印：a%2Bb%2Bc

                  a%3Db%3Dc

     3、使用心得

     基本实现功能一致，一种针对字符串，比如签名后的字符串做URL编码的时，肯定使用quote函数更合适。而对一个dict做RUL编码使用urlencode更方便

    

四、AES加密

1、AES加密模式简介

     AES加密模式主要分四种模式(ECB、CBC、CFB、OFB)，其中最常见的就是ECB和CBC模式，下面主要介绍这2种模式：

    A:  ECB模式。(KEY)

        是最简单也最不安全的模式，直接把原始要加密的数据按照定长分组，然后每一个分组用同样的Key执行加密，如下图所示：

     

   这个模式的优点是：简单；有利于并行计算；缺点:不能隐藏明文的模式；可能对明文进行主动攻击；一个经典的例子，攻击者可以无需AES密钥就对加密数据进行攻击。来看个经典的例子，假设银行账号A向账户B转账的信息是通过下面的格式存储的：

账户A: uJb17CO3LSj+SFPSTSRpUg==
账户B: 3HFW8zvoG9f4kB80B+6hrg==
转账金额: T48Km+rTBItaZim/kRvgww==

   对于这组加密的数据，出于ECB模式的特性，任意改变这三行的顺序，都不会影响解密结果，因为它们的加密解密过程是完全独立的。攻击者只要尝试把数据的前两行换位，这个转账的顺序就变成了账户B向账户A转账，从而达成了在不知道AES密钥的情况下攻击原始数据。因此，除非是为了向既有系统兼容，现如今ECB这种工作模式已经不被使用了。

B: CBC模式（KEY+IV）

    既然ECB这种直接分组映射的方式不安全，该怎么办呢？一个思路就是让下一个分组的加密和上一个分组的加密相关，有了这种关联性，移动了加密结果之后，就无法成功解密了。把这个思路具体到CBC上，就是这样的：

 

 

 

 

 

 

 

 

 

 

 

 

 

      也就是说，第i+1个分组要加密的数据，要先和第i个分组的加密结果异或。这样一来，我们就要为第一个分组的加密创建一个和分组长度相同的随机向量来参与异或（对于AES来说，就是个16字节的数组），这个随机向量，叫做Initial Vector，也叫做IV。

      优点：不容易主动攻击,安全性好于ECB,适合传输长度长的报文,是SSL、IPSec的标准。缺点：1.不利于并行计算；2.误差传递；3.需要初始化向量IV  

2、AES填充方式简介

    AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。在每组加密数据超过块大小的数据，就需要涉及填充。

    填充的方式分2种，分别是：zero padding，PKCS #5 padding和PKCS #7 padding，就是常见的填充0和填充字符。不足16位的加密字符需要填充满16位，以zero padding，这种方法最简单，在欠缺的位置都填充0就行了。

其次，是PKCS #7 padding。它的工作方式是这样的：

那么刚好是16的整数倍，还需要填充么？答案是正好16倍数的原文需要填充16位的，仍然需要填充一个完整块的长度！为什么呢？因为加密前要填充，解密后要去掉填充，如果没有填充，解密后最后一个字节恰好是 0x01，那么不方便判断这个 0x01 是实际的数据还是之前填充的数据。以PKCS #7 padding为例。如果是zero padding，就需要填充16个0.

3、AES使用场景常见

    1、AES/CBC/ZEROPadding。 关注key,iv,padding函数是否正确。

# \0 填充

  def padding_0(self,text):
        '''
        :param text:  加密字符串
        :return:  ，以\0填充，返回填充后的字符串
        '''
        pad = lambda s: s + (self.BS - len(s) % self.BS) * '\0'
        text = pad(text)
        return text

# 字符串填充
    def padding_chr(self,text):
        '''
        :param text: 加密字符串
        :return:  以字符串填充，返回填充后的字符串
        '''
        pad = lambda s: s + (self.BS - len(s) % self.BS) * chr(self.BS - len(s) % self.BS);  # chr() 这个数字对应的字符
        text = pad(text)
        return  text

 有些情况下，IV比较简单，是一个固定值，iv = 0000000000000000。

key_vec = hashlib.md5(key + '_' + salt).hexdigest()
aes_test = AES.new(key_vec, '0000000000000000', mode=AES.MODE_CBC)

有些情况下IV跟key，和其他入参是绑定在一起的，不同的参数对应不同的iv。如下需要，key和iv由入参key 和spid决定。key = genAesKey[0:16]，iv=genAesKey[16:]

genAesKey = Misc.get_md5( key + '_' + spid)
aes_text = AES.new(genAesKey[0:16], genAesKey[16:], mode=AES.MODE_CBC)

整个代码片段如下:

class AesClass():
    def __init__(self,key,iv,padding_flag=0,ret_enc_flag=0,mode=AES.MODE_CBC):
        '''

        :param key:  机密KEY
        :param iv:  向量
        :param padding_flag:   填充方法
        :param ret_enc_flag: 返回加密方式
        :param mode:    AES加密方式
        :return:
        '''
        self.key = key
        # 默认CBC，其他模式 ECB，CFB,OFB
        self.mode=mode
        self.iv=iv
        self.BS = AES.block_size  #16
        self.padding_flag=padding_flag
        self.ret_enc_flag=ret_enc_flag
        self.unpad = lambda s: s[0:-ord(s[-1])]

#   \0  填充方式
    def padding_0(self,text):
        '''
        :param text:  加密字符串
        :return:  ，以\0填充，返回填充后的字符串
        '''
        pad = lambda s: s + (self.BS - len(s) % self.BS) * '\0'
        text = pad(text)
        return text

# 字符串填充
    def padding_chr(self,text):
        '''
        :param text: 加密字符串
        :return:  以字符串填充，返回填充后的字符串
        '''
        pad = lambda s: s + (self.BS - len(s) % self.BS) * chr(self.BS - len(s) % self.BS);  # chr() 这个数字对应的字符
        text = pad(text)
        return  text

    # 加密
    def encrypt(self,text):
        '''

        :param text: 需加密的字符串
        :return:  加密后的字符串
        '''
        cryptor = AES.new(self.key,self.mode,self.iv)
        if self.padding_flag==0:
            txt = self.padding_0(text)
        else:
            txt=self.padding_chr(text)
        ciphertext = cryptor.encrypt(txt)
        if self.ret_enc_flag==0:
            return b2a_hex(ciphertext)
        else:
            return base64.b64encode(ciphertext)

# 解密后，去掉补足的空格用strip() 去掉
    def decrypt(self, text):
        '''

        :param text:  需要加密的字符串
        :return:  解密后的字符串
        '''
        cryptor = AES.new(self.key, self.mode, self.iv)
        if self.ret_enc_flag==0:
            # text=text.upper()
            plain_text = cryptor.decrypt(a2b_hex(text))
        else:
            plain_text = cryptor.decrypt(base64.b64decode(text))
        if self.padding_flag==0:
            return plain_text.rstrip('\0')
        else:
            unpad = lambda s: s[0:-ord(s[-1])];
            return unpad(plain_text.rstrip('\0'))