python加密解密方法

base64加密

import base64
def to_base64(str_to_base64):
	return base64.b64.encode(str_to_base64.eccode('utf-8'))

base64解密

import base64
def get_base64(str_to_base64):     # base64解密
    return base64.b64decode(str_to_base64)

MD5加密(不可逆)

import hashlib

"""
MD5 Message-Digest Algorithm，一种被广泛使用的密码散列函数，可以产生出一个128位(16字节)的散列值(hash value)，
用于确保信息传输完整一致。MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。
update() 方法内传参为二进制数据  所以需要将字符串数据 encode()
作用：加密用户密码；保证数据唯一性（MD5可以保证唯一性）;比较文件是否被篡改等
"""

def get_md5(str):
    hash_md5 = hashlib.md5()
    hash_md5.update(str.encode("utf-8"))
    return hash_md5.hexdigest()

SHA1加密（不可逆）

"""
SHA1的全称是Secure Hash Algorithm(安全哈希算法) 。SHA1基于MD5，加密后的数据长度更长，
它对长度小于264的输入，产生长度为160bit的散列值。比MD5多32位,因此，比MD5更加安全，但SHA1的运算速度就比MD5要慢
"""
def get_sha1(str):
    hash_sha1 = hashlib.sha1()
    hash_sha1.update(str.encode("utf-8"))
    return hash_sha1.hexdigest()

RSA加解密

#! /usr/bin/python3
# -*- coding: utf-8 -*-
# @Time: 2022/2/15 13:22
# @Author: 一碗烈酒
import rsa
import os

"""
rsa 加解密
加密：公钥加密，私钥解密；
签名：私钥签名，公钥验签。
"""


class MyRSA:
    def __init__(self):
        # 生成公钥，私钥
        self.public_key, self.private_key = rsa.newkeys(nbits=512)

    def save_rsa(self, public_key_filename, private_key_filename, save_path):
        """
        保存秘钥文件
        """
        with open(os.path.join(save_path, public_key_filename), "wb") as f:
            f.write(self.public_key.save_pkcs1())
        with open(os.path.join(save_path, private_key_filename), "wb") as f:
            f.write(self.private_key.save_pkcs1())

    def read_rsa_public(self, public_key_filename):
        """
        读取rsa公钥
        :param public_key_filename: rsa 公钥文件地址
        :return: 公钥
        """
        with open(public_key_filename, 'rb') as publickfile:
            pub = publickfile.read()
            pubkey = rsa.PublicKey.load_pkcs1(pub)
        return pubkey

    def read_rsa_private(self, private_key_filename):
        """
        读取rsa私钥
        :param private_key_filename: rsa 私钥文件地址
        :return: 私钥
        """
        with open(private_key_filename, 'rb') as privatefile:
            priv = privatefile.read()
            privkey = rsa.PrivateKey.load_pkcs1(priv)
        return privkey

    def encrypt(self, str, public_key=None):
        """
        使用公钥加密。如果传入了公钥，则使用传入的公钥加密；如果没有传入公钥，则使用初始化创建实例时的公钥加密。
        :param str: 待加密的字符串
        :param public_key: 公钥
        :return: 加密后的数据，bytes
        """
        if public_key:
            rsa.encrypt(message=str.encode("utf-8"), pub_key=public_key)
        return rsa.encrypt(message=str.encode("utf-8"), pub_key=self.public_key)

    def decrypt(self, str, private_key=None):
        """
        使用私钥解密. 如果传入了私钥，则使用传入的私钥解密；如果没有传入私钥，则使用初始化创建实例时的私钥解密。
        :param str: 待解密的数据
        :param private_key: 私钥
        :return: 解密后的数据，str
        """
        if private_key:
            return rsa.decrypt(str, priv_key=private_key).decode("utf-8")
        return rsa.decrypt(str, priv_key=self.private_key).decode("utf-8")

    def sign(self, message, private_key, hash_method="SHA-256"):
        """
        使用私钥进行签名. 默认hash算法为：'sha256'，也可以使用 md5 或其他hash算法
        :param message: 要签名的数据
        :param private_key: 私钥
        :param hash_method: hash算法
        :return: 签名后的数据
        """
        sign_result = rsa.sign(message=message, priv_key=private_key, hash_method=hash_method)
        return sign_result

    def verify(self, message, sign, public_key):
        """
        验签，使用公钥验证签名是否正确。如果正确，则返回签名算法,否则返回验证失败
        :param message: 已加密的数据
        :param sign: 已签名的数据
        :param public_key: 公钥
        :return: 验签正确：返回签名算法；验签错误：返回验证失败 False
        """
        try:
            verify = rsa.verify(message=message, signature=sign, pub_key=public_key)
            return verify
        except rsa.VerificationError:
            return False


if __name__ == "__main__":
    r = MyRSA()
    r.save_rsa("rsa_pub.pem", "rsa_priv.pem", "./")
    result = r.encrypt("nishiwode")
    print(result)
    sign_str = r.sign(result, r.private_key)
    print(sign_str)
    sign_end = r.verify(result, sign_str, r.read_rsa_private(private_key_filename="./rsa_priv.pem"))
    print(sign_end)
    if sign_end:
        end = r.decrypt(result)
        print(end)

AES加解密

# -*- encoding: utf-8 -*-
# CreateTime: 2022/2/20 20:00
# Author: @一碗烈酒

from Crypto import Random
from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex

"""
pip install pycryptodome
AES加密方式有五种：ECB, CBC, CTR, CFB, OFB
CBC加密需要一个十六位的key(密钥)和一个十六位iv(偏移量)  常用
ECB加密不需要iv
cryptor不能写在主函数中同时给加密函数与解密函数使用，所以加密和解密都要重新创建对象
"""


class MyAES:
    def __init__(self, key, mode=AES.MODE_CBC, iv=Random.new().read(AES.block_size)):
        """
        key 秘钥必须是16（AES-128）,24, 32
        iv 长度等于AES块大小的不可重复的秘钥向量
        本类内实现了 ECB, CBC 两种加密模式，默认为 AES.MODE_CBC 加密模式
        """
        self.key, self.mode, self.iv = key.encode(), mode, iv

    def __add_to_16(self, text):
        """ 如果string不足16位则用空格补齐16位 """
        if len(text.encode()) % 16:
            add = 16 - (len(text.encode()) % 16)
        else:
            add = 0
        text += ("\0" * add)
        return text.encode()

    def encode_aes(self, text):
        """ 使用 AES 加密字符串 """
        # 初始化 AES 对象, cryptor不能写在主函数中同时给加密函数与解密函数使用，所以加密和解密都要重新创建对象
        if self.mode == AES.MODE_ECB:
            cryptos = AES.new(key=self.key, mode=self.mode)
        elif self.mode == AES.MODE_CBC:
            cryptos = AES.new(key=self.key, mode=self.mode, iv=self.iv)
        cipher_text = cryptos.encrypt(self.__add_to_16(text))
        # 由于AES加密后的字符串不一定是ascii字符集，所以转为16进制字符串
        return b2a_hex(cipher_text)

    def decode_aes(self, text):
        """ aes 解密 并去掉补足的空格"""
        # 初始化 AES 对象, cryptor不能写在主函数中同时给加密函数与解密函数使用，所以加密和解密都要重新创建对象
        if self.mode == AES.MODE_ECB:
            cryptos = AES.new(key=self.key, mode=self.mode)
        elif self.mode == AES.MODE_CBC:
            cryptos = AES.new(key=self.key, mode=self.mode, iv=self.iv)
        plain_text = cryptos.decrypt(a2b_hex(text))
        return bytes.decode(plain_text).rstrip("\0")


if __name__ == '__main__':
    a = MyAES(key="this is a 16 key", mode=AES.MODE_CBC)
    # a = MyAES(key="this is a 16 key", mode=AES.MODE_ECB)
    result = a.encode_aes("nishiwode")
    print(result)
    r = a.decode_aes(result)
    print(r)