Python数据加密：抄起来，坏人都瞎了眼

时尚娱乐2023-10-04 08:02:52高三出国留学需要如何准备语言考试(留学语言考试备考技巧)

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python

Python数据加密：抄起来，坏人都瞎了眼

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python

Python数据加密：抄起来，坏人都瞎了眼

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python

Python数据加密：抄起来，坏人都瞎了眼

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python

Python数据加密：抄起来，坏人都瞎了眼

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python

Python数据加密：抄起来，坏人都瞎了眼

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python

Python数据加密：抄起来，坏人都瞎了眼

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python

Python数据加密：抄起来，坏人都瞎了眼

Python数据加密：抄起来，数据歹徒都瞎了眼

故故者：视察玩家勇哥 拓荒 数据泰平 数据加密有多种设施，加密勇哥能力有限，抄起澳门上网导航就先容三种常见的歹徒都瞎数据加密设施：对称加密、非对称加密和单向加密。数据

数据加密是加密一种维持音问泰平的身手，它能够把明文（原始的抄起数据）退换成密文（不行读的数据），从而预防未经授权的歹徒都瞎职工造访或编削数据。

加密简介

数据加密有多种设施，数据勇哥能力有限，加密就先容三种常见的抄起数据加密设施：对称加密、非对称加密和单向加密。歹徒都瞎

编码与解码

常所说的数据加密花式，都是加密澳门上网导航对二进制编码的花色进行加密的。Python 中进行加密时，抄起要确保独霸的是 Bytes，否则就会报错。将字符串和 Bytes 相互退换能够骗捏 encode()和 decode()设施。

  • encode()：str 目目的设施，用于将字符串退换为二进制数据（即 bytes），也称为“编码”。
  • decode()：bytes 目目的设施，用于将二进制数据退换为字符串，也称为“解码”。
  • 在配阁阁解码采纳的字符编码时，须要与编码时采纳的字符编码雷同。骗捏 decode()设施时，雷同不会编削原字符串。

1.decode() | encode()案例：

def data_encode(st):    """编码 """    return st.encode("utf-8")def bs64_data_decode(st):    """解码"""    return st.decode("utf8")

Base64 加/解密：base64 加密解密较量常见的就是图片责罚。

2.base64 案例：

"""base64音问转图片与图片转base64"""def base64_to_img(byte_str, file_path):    imgdata = base64.b64decode(byte_str)    with open(file_path, 'wb') as f:        f.write(imgdata)def base64_to_str(byte_str):    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

单向加密

单向加密是一种只能对数据进行加密，而不行进行解密的设施，也叫做散列函数或哈希函数。单向加密的目的是担保数据的齐备性，即数据在传输或存储进程中莫得被篡改或败坏。单向加密能够用来生成数据的纲领或签字，用于验证数据的源泉和本色。单向加密有一个首要的特质，就是雷同的输入会生长雷同的输出，而迥异的输入会生长迥异的输出。常见的单向加密算法有：MD5、SHA 系列等。

1.MD5 加密示例：

def md5(st: str) -> str:    """    Args:        st:待加密字符串    Returns: 返回MD5 加密后的字符串    """    md = hashlib.md5()  # 设立MD5目的    md.update(st.encode(encoding="utf-8"))    return md.hexdigest()

2.sha1 加密示例：

SHA1 基于 MD5，加密后的数据长度更长，它对长度小于 264 的输入，生长长度为 160bit 的散列值。比 MD5 多 32 位,所以，比 MD5 额外泰平，但 SHA1 的运算速率就比 MD5 要慢。

def sha1_secret_str(st):    """    骗捏sha1加密算法，返回str加密后的字符串    Args:        st:    Returns:    """    sha = hashlib.sha1(st.encode("utf-8"))    return sha.hexdigest()

3.sha256 加密示例:

据说是比特币挖矿就骗捏到。

SHA256是SHA-2下细分出的一种算法。

SHA-2，称谓来自于泰平散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种记号散列函数算法范例（哈希算法），由美国国度泰平局研发，属于SHA算法之一，是SHA-1的后继者。

SHA-2下又可再分为六个迥异的算法范例，蕴涵了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。这些变体除了生成纲领的长度 、轮回运转的次数等极少软弱迥异外，

算法的根蒂结构是雷同的。马虎顺手长度的音问，SHA256都邑生长一个256bit长的哈希值，称故故音问纲领。这个纲领额外因而个长度为32个字节的数组，通常用一个长度为64的十六进制字符串来露出。

def sha256_single(st):    """    sha256加密    Args:        st: 加密字符串    Returns:加密结果退换为16进制字符串，并大写    """    sha_obj = hashlib.sha256()    sha_obj.update(st.encode("utf-8"))    return sha_obj.hexdigest().upper()

对称加密

对称加密是一种骗捏雷同的密钥来进行数据加密迁就密的设施，也叫做私钥加密或分享密钥加密。对称加密的廉价是速率快，适当加密豪爽的数据。对称加密的错误是须要双方事前约定好并顾念记挂管好密钥，否则会招致数据露出或销耗。对称加密有两种模式：分组记号和流记号。分组记号是把明文分红固定长度的块，而后对每个块进行加密或解密，生成雷同长度的密文或明文。流记号是把明文分红单个字节，而后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有：DES、AES、Blowfish 等。

1.AES（高级加密范例）：

AES 惟有一个密钥，这个密钥既用来加密，也用于解密，AES 加密花式有五种：ECB, CBC, CTR, CFB, OFB。

从泰平性角度选举 CBC 加密设施，本文先容了 CBC,ECB 两种加密设施的 python 落成。

CBC 和 ECB 模式的迥异就是：

  • CBC 加密须要一个十六位的 key(密钥)和一个十六位 iv(偏移量)
  • ECB 加密不须要 iv，只须要 key(密钥)
class DoAES: """ AES 加密 """ def __init__(self, key):  self.key = key  # 将密钥退换为字符型数据  self.mode = AES.MODE_ECB  # 独霸模式采纳ECB def encrypt(self, text):  """加密函数"""  file_aes = AES.new(self.key, self.mode)  # 设立AES加密目的  text = text.encode('utf-8')  # 明文必须编码成字节约数据，即数据规范为bytes  while len(text) % 16 != 0:  # 对字节型数据进行长度肯定   text += b'\x00'  # 要是字节型数据长度不是16倍整数就进行补充  en_text = file_aes.encrypt(text)  # 明文进行加密，返回加密后的字节约数据  return str(base64.b64encode(en_text), encoding='utf-8')  # 将加密后赢得的字节约数据进行base64编码并再退换为unicode规范 def decrypt(self, text):  """解密函数"""  file_aes = AES.new(self.key, self.mode)  text = bytes(text, encoding='utf-8')  # 将密文退换为bytes，此时的密文还是由basen64编码过的  text = base64.b64decode(text)  # 对密文再进行base64解码  de_text = file_aes.decrypt(text)  # 密文进行解密，返回明文的bytes  return str(de_text, encoding='utf-8').strip()  # 将解密后赢得的bytes型数据退换为str型，并去除结束的调处if __name__ == '__main__': # key = os.urandom(16)   #随即生长n个字节的字符串，能够行径随机加密key骗捏 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 随即生长n个字节的字符串，能够行径随机加密key骗捏 text = '4534'  # 须要加密的本色 aes_test = DoAES(key.encode('utf-8')) cipher_text = aes_test.encrypt(text) init_text = aes_test.decrypt(cipher_text) print('加密后：' + cipher_text) print('解密后：' + init_text)

输出结果：

加密后：blhiuFNLSqBUMMDbWxUBBw==解密后：4534进程已遣散,退出代码0

2.DES 示例：

class Des:    def __init__(self, text):        self.text = text  # 原始字符串        self.KEY = '2l4LoWcz'  # 这个key是固定问拓荒，        # self.KEY  = os.urandom(8)  # 随即生长n个字节的字符串，能够行径随机加密key骗捏    def des_encrypt(self):        """DES 加密        Returns:加密后字符串，16进制        """        secret_key = self.KEY  # 记号        iv = secret_key  # 偏移        # secret_key:加密密钥，CBC:加密模式，iv:偏移, padmode:调处        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        # 返回为字节        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)        # 返回为16进制        return binascii.b2a_hex(secret_bytes)    def des_decrypt(self):        """        DES 解密        Returns:解密后的字符串        """        secret_key = self.KEY        iv = secret_key        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)        return bytes.decode(decrypt_str)  # bytes.decode() 将bit转为str

视察数据：

if __name__ == '__main__':    text = 'TestingPlayer：视察玩家勇哥'  # 须要加密的本色    d_encrypt = Des(text)    cipher_text = d_encrypt.des_encrypt()    d_decrypt = Des(cipher_text)    init_text = d_decrypt.des_decrypt()    print('加密后：', cipher_text)    print('解密后：', init_text)

践诺结果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'解密后：TestingPlayer：视察玩家勇哥

非对称加密

非对称加密也叫做公钥加密，是一种骗捏迥异的两个密钥来进行数据加密迁就密的设施。这两个密钥阔别叫做公钥和私钥，它们之间罕见学上的联系，但不行相互推导。公钥是公户口的，能够用来给数据进行加密或验证签字；私钥是隐藏的，能够用来给数据进行解密或生成签字。非对称加密的廉价是泰平性高，不须要双方事前约定好并传输秘钥。非对称加密的错误是速率慢，适当加密少量的数据。常见的非对称加密算法有：RSA、DSA、ECC 等。

1.RSA（罗纳德·李维斯特·沙米尔·阿迪曼）：

# 导入cryptography库华厦rsa模块from cryptography.hazmat.primitives.asymmetric import rsa# 生成一对公钥和私钥，长度为2048位private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)public_key = private_key.public_key()print("私钥:", private_key)print("公钥:", public_key)# 界说一个明翰墨符串plaintext = "Hello, world!"# 骗捏公钥对明文进行加密，赢得一个字节串规范的密文ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("密文:", ciphertext)# 骗捏私钥对密文进行解密，赢得一个字节串规范的明文decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))print("解密后的明文:", decrypted.decode())

输出结果：

私钥: 公钥: 密文: b'\x8b\x9e\x1e\x1b\x8f\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\x8b\x9d\x1e\x8b\x9c\x9f\x1f\xb3\xe2\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xe3\xc5\xd2\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xf7\xf6\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xb4\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0'解密后的明文: Hello, world!

2.RAS 封装：

class Rsa: def __init__(self, st: str):  self.st = st # rsa加密 def rsa_encrypt(self):  # 生成公钥、私钥  (pubkey, privkey) = rsa.newkeys(1024)  print("公钥: ", pubkey)  print("私钥: ", privkey)  # 明文编码花色  content = self.st.encode('utf-8')  # 公钥加密  crypto = rsa.encrypt(content, pubkey)  # # 闲居加密的密文会以base64编码的花式输出  b_res = base64.b64encode(crypto).decode()  return b_res, privkey # rsa解密 def rsa_decrypt(self, pk):  # 私钥解密  st = base64.b64decode(self.st.encode())  content = rsa.decrypt(st, pk)  con = content.decode('utf-8')  return con
责任编辑：赵宁宁 源泉： 视察玩家勇哥 数据加密Python