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")1.2.3.4.5.6.7.8.

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)1.2.3.4.5.6.7.8.9.

单向加密

单向加密是一种只能对数据进行加密，而不能进行解密的方法，也叫做散列函数或哈希函数
。单向加密的目的香港云服务器是保证数据的完整性，即数据在传输或存储过程中没有被篡改或损坏。单向加密可以用来生成数据的摘要或签名，用于验证数据的来源和内容 。单向加密有一个重要的特性
，就是相同的输入会产生相同的输出
，而不同的输入会产生不同的服务器租用输出。常见的单向加密算法有  ：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()1.2.3.4.5.6.7.8.9. 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()1.2.3.4.5.6.7.8.9.10.11. 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()1.2.3.4.5.6.7.8.9.10.11.12.

对称加密

对称加密是一种使用相同的密钥来进行数据加密和解密的方法，也叫做私钥加密或共享密钥加密 。对称加密的优点是速度快 
，适合加密大量的数据。对称加密的缺点是需要双方事先约定好并保管好密钥，否则会导致数据泄露或丢失。对称加密有两种模式 ：分组密码和流密码
。分组密码是把明文分成固定长度的块，然后对每个块进行加密或解密
，生成相同长度的密文或明文。流密码是把明文分成单个字节 ，然后对每个字节进行加密或解密，生成单个字节的密文或明文。常见的对称加密算法有 ：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)1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.

输出结果 ：

复制加密后：blhiuFNLSqBUMMDbWxUBBw== 解密后：4534 进程已结束,退出代码01.2.3.4. 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转为str1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.

测试数据 ：

复制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)1.2.3.4.5.6.7.8.

执行结果：

复制加密后：b6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2 解密后
 ：TestingPlayer
：测试玩家勇哥1.2. 非对称加密

非对称加密也叫做公钥加密，是一种使用不同的两个密钥来进行数据加密和解密的方法。这两个密钥分别叫做公钥和私钥，它们之间有数学上的关联，但不能相互推导
。公钥是公开的，可以用来给数据进行加密或验证签名；私钥是保密的，可以用来给数据进行解密或生成签名。非对称加密的优点是安全性高
，不需要双方事先约定好并传输秘钥。非对称加密的缺点是速度慢 ，适合加密少量的数据
。常见的非对称加密算法有
：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())1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.

输出结果
：

复制私钥: <cryptography.hazmat.backends.openssl.rsa._RSAPrivateKey object at 0x7f9a6a0f4d90> 公钥: <cryptography.hazmat.backends.openssl.rsa._RSAPublicKey object at 0x7f9a6a0f4d60> 密文: 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!1.2.3.4. 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 con1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.