Python与JavaScript关于AES加解密和RSA加解密

Python与JavaScript关于AES加解密和RSA加解密

在线生成公钥私钥对，RSA公私钥生成
AESjs文件
RSAjs文件
JSEncrypt文件

JavaScript

function generateRandomString(length) {
	let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~";
	let values = new Uint32Array(length);
	window.crypto.getRandomValues(values);
	let str = '';
	for (let i = 0; i < length; i++) {
		str += charset[values[i] % charset.length];
	}
	return str;
}
function AESEncrypt(data, key) {
	key = CryptoJS.enc.Utf8.parse(key)
	data = CryptoJS.enc.Utf8.parse(data)
	const encrypted = CryptoJS.AES.encrypt(data, key, {
		iv: key,
		mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
	});
	return CryptoJS.enc.Base64.stringify(encrypted.ciphertext);
}
function AESDecrypt(data, key) {
	key = CryptoJS.enc.Utf8.parse(key)
    data = CryptoJS.enc.Base64.parse(data)
    data = CryptoJS.enc.Base64.stringify(data)
	const decrypted = CryptoJS.AES.decrypt(data, key, {
		iv: key,
		mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
	});
	return CryptoJS.enc.Utf8.stringify(decrypted).toString();
}
function RSAEncrypt(data, key) {
	key = key.replace("-----BEGIN PUBLIC KEY-----", "");
	key = key.replace("-----END PUBLIC KEY-----", "");
	key = key.replace(/\n/g, "");
	key = key.trim();
	const encrypt = new JSEncrypt();
	encrypt.setPublicKey(key);
	return encrypt.encrypt(data);
}
function RSADecrypt(data, key) {
	key = key.replace("-----BEGIN PRIVATE KEY-----", "");
	key = key.replace("-----END PRIVATE KEY-----", "");
	key = key.replace(/\n/g, "");
	key = key.trim();
	const decrypt = new JSEncrypt();
	decrypt.setPrivateKey(key);
	return decrypt.decrypt(data);
}
function RSASign(data, key) {
	const sign = new JSEncrypt();
	sign.setPrivateKey(key);
	return sign.sign(data, CryptoJS.SHA256, "sha256");
}
function RSAVerify(data, signature, key) {
	const verify = new JSEncrypt();
	verify.setPublicKey(key);
	return verify.verify(data, signature, CryptoJS.SHA256);
}

Python

import base64
import random
import string

from Crypto.Cipher import AES, PKCS1_v1_5 as Cipher_pkcs1_v1_5
from Crypto.Hash import SHA256
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5


def generate_random_str(random_length=16, digits_str=True, ascii_str=True, punctuation_str=False):
    """
    生成一个指定长度的随机字符串，其中
    string.digits=0123456789
    string.ascii_letters=abcdefghigklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
    string.punctuation=!"#$%&'()*+,-./:;<=>?@[]^_`{|}~
    :param random_length: 生成的字符串长度，默认16位
    :param digits_str: 是否存在数字
    :param ascii_str: 是否存在大小写字母
    :param punctuation_str: 是否存在标点符号
    :return: 一串字符串
    """
    char = ''
    if digits_str:
        char += string.digits
    if ascii_str:
        char += string.ascii_letters
    if punctuation_str:
        char += string.punctuation
    str_list = [random.choice(char) for _ in range(random_length)]
    random_str = ''.join(str_list)
    return random_str


RSA_PublicKey = """-----BEGIN PUBLIC KEY-----...-----END PUBLIC KEY-----"""
RSA_PrivateKey = """-----BEGIN PRIVATE KEY-----...-----END PRIVATE KEY-----"""

class AESCipher:
    def __init__(self, key):
        self.key = key
        # 这里直接用key充当iv
        self.iv = key

	def encrypt(self, raw):
        """
        加密方法
        :param raw: 需要加密的密文 str
        :return: base64编码的密文 str
        """
        cipher = AES.new(self.key.encode('utf-8'), AES.MODE_CBC, self.iv.encode('utf-8'))
        return base64.b64encode(cipher.encrypt(self._pad(raw.encode()))).decode()

    def decrypt(self, enc):
        """
        解密方法
        :param enc: base64编码的密文 str
        :return: 解密后的明文 str
        """
        cipher = AES.new(self.key.encode('utf-8'), AES.MODE_CBC, self.iv.encode('utf-8'))
        return self._unpad(cipher.decrypt(base64.b64decode(enc))).decode()

    @staticmethod
    def _pad(s):
        return s + (16 - len(s) % 16) * chr(16 - len(s) % 16).encode()

    @staticmethod
    def _unpad(s):
        return s[0:-ord(s[len(s) - 1:])]


class RSACipher:
    """
    RSA加密、解密、签名、验签工具类
    """
    @staticmethod
    def encrypt(key, raw):
        """
        加密方法
        :param key: 公钥
        :param raw: 需要加密的明文 bytes
        :return: base64编码的密文 bytes
        """
        rsa_key = RSA.importKey(key)
        cipher = Cipher_pkcs1_v1_5.new(rsa_key)
        cipher_text = base64.b64encode(cipher.encrypt(raw.encode()))
        return cipher_text.decode()

    @staticmethod
    def decrypt(key, enc):
        """
        解密方法
        :param key: 私钥
        :param enc: base64编码的密文 bytes
        :return: 解密后的明文 bytes
        """
        decodeStr = base64.b64decode(enc)  # cipher_text是上面rsa加密的内容
        rsa_key = RSA.importKey(key)
        private_key = Cipher_pkcs1_v1_5.new(rsa_key)
        encry_text = private_key.decrypt(decodeStr, b'rsa')
        return encry_text.decode('utf8')

    @staticmethod
    def sign(key, text):
        """
        签名方法
        :param key: 私钥
        :param text: 需要签名的文本 bytes
        :return: base64编码的签名信息 bytes
        """
        private_key = RSA.importKey(key)
        hash_value = SHA256.new(text.encode())
        signer = PKCS1_v1_5.new(private_key)
        signature = signer.sign(hash_value)
        return base64.b64encode(signature).decode()

    @staticmethod
    def verify(key, text, signature):
        """
        验签方法
        :param key: 公钥
        :param text: 需要验签的文本 bytes
        :param signature: base64编码的签名信息 bytes
        :return: 验签结果 bool
        """
        public_key = RSA.importKey(key)
        hash_value = SHA256.new(text.encode())
        verifier = PKCS1_v1_5.new(public_key)
        return verifier.verify(hash_value, base64.b64decode(signature))