Python数据加密

加密简介

数据加密有多种方法，勇哥能力有限，就介绍三种常见的数据加密方法：对称加密、非对称加密和单向加密。

编码与解码

常所说的加密方式，都是对二进制编码的格式进行加密的。Python/ target=_blank class=infotextkey>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())

输出结果：

私钥: <cryptography.hazmat.backends.openssl.rsa._RSAPrivateKey object at 0x7f9a6a0f4d90>
公钥: <cryptography.hazmat.backends.openssl.rsa._RSAPublicKey object at 0x7f9a6a0f4d60>
密文: b'x8bx9ex1ex1bx8fx9dx1ex8bx9cx9fx1fx8bx9dx1ex8bx9cx9fx1fx8bx9dx1ex8bx9cx9fx1fx8bx9dx1ex8bx9cx9fx1fxb3xe2xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0'
解密后的明文: 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