关于python:爬虫知识爬虫常见加密解密算法

本文总结了在爬虫中常见的各种加密算法、编码算法的原理、在 JavaScript 中和 Python 中的根本实现办法，遇到 JS 加密的时候能够疾速还原加密过程，有的网站在加密的过程中可能还通过了其余解决，然而大抵的办法是一样的。

常见加密算法：

对称加密（加密解密密钥雷同）：DES、3DES、AES、RC4、Rabbit
非对称加密（辨别公钥和私钥）：RSA、DSA、ECC
音讯摘要算法 / 签名算法：MD5、SHA、HMAC、PBKDF2

常见编码算法：Base64

Crypto-JS 反对 MD5、SHA、RIPEMD-160、HMAC、PBKDF2、AES、DES、3DES（Triple DES）、Rabbit、RC4 等，不反对 RSA、ECC，是利用比拟广的加密模块，应用命令 npm install crypto-js 装置。

参考资料：

Crypto-JS 文档：https://cryptojs.gitbook.io/d…
Crypto-JS Github：https://github.com/brix/crypt…

Node-RSA 对 RSA 算法提供了反对，应用命令 npm install node-rsa 装置。

参考资料：Node-RSA Github：https://github.com/rzcoder/no…

参考资料：JSEncrypt 对 RSA 算法提供了更加全面的反对，应用命令 npm install jsencrypt 装置。

JSEncrypt 文档：http://travistidwell.com/jsen…
JSEncrypt Github：https://github.com/travist/js…

在 Python 中有很多算法是通过第三方库 Cryptodome 或者 Crypto 来实现的，Cryptodome 简直是 Crypto 的替代品，Crypto 曾经进行更新好多年了，有很多未知谬误，所以 不倡议装置 Crypto！

Cryptodome 反对简直所有支流加密算法，包含 MD5、SHA、BLAKE2b、BLAKE2s、HMAC、PBKDF2、AES、DES、3DES（Triple DES）、ECC、RSA、RC4 等。

Cryptodome 应用命令 pip install pycryptodome 进行装置，Crypto 应用命令 pip install pycrypto 进行装置。

参考资料：

Crypto 库：https://www.dlitz.net/softwar…
Cryptodome 库：https://www.pycryptodome.org/…

Python 的规范库 hashlib 提供了常见的摘要算法，如 MD5，SHA、BLAKE2b、BLAKE2s 等。

参考资料：

hashlib 库：https://docs.python.org/3/lib…
廖雪峰 hashlib：https://www.liaoxuefeng.com/w…

Python 的规范库 hmac 对 HMAC 算法提供了反对。

参考资料：

hmac 库：https://docs.python.org/3/lib…
廖雪峰 hmac：https://www.liaoxuefeng.com/w…

Python 的第三方库 pyDes 对 DES 算法提供了反对。应用命令 pip install pydes 进行装置。

参考资料：pyDes 库：https://github.com/twhiteman/…

Python 的第三方库 rsa 对 RSA 算法提供了反对。应用命令 pip install rsa 进行装置。

参考资料：rsa 库：https://stuvel.eu/python-rsa-…

在一些对称和非对称加密算法中，常常会用到以下三个参数：初始向量 iv、加密模式 mode、填充形式 padding，先介绍一下这三个参数的含意和作用：

在密码学中，初始向量（initialization vector，缩写为 iv），又称初始变数（starting variable，缩写为 sv），与密钥联合应用，作为加密数据的伎俩，它是一个固定长度的值，iv 的长度取决于加密办法，通常与应用的加密密钥或明码块的长度相当，个别在应用过程中会要求它是随机数或拟随机数，应用随机数产生的初始向量能力达到语义平安，让攻击者难以对原文统一且应用同一把密钥生成的密文进行破解。

参考资料：维基百科：https://en.wikipedia.org/wiki…

目前风行的加密和数字认证算法，都是采纳块加密形式，就是将须要加密的明文分成固定大小的数据块，而后对其执行明码算法，失去密文。数据块的大小通常采纳跟密钥一样的长度。加密模式在加密算法的根底上倒退进去，同时也能够独立于加密算法而存在，加密模式定义了怎么通过反复利用加密算法将大于一个数据块大小的明文转化为密文，形容了加密每一数据块的过程。目前利用较多的加密模式有以下几种：

ECB：Electronic Code Book（电子码本模式），是一种根底的加密形式，密文被宰割成分组长度相等的块（有余补齐），而后独自一个个加密，一个个输入组成密文。
CBC：Cipher Block Chaining（明码块链接模式），是一种循环模式，前一个分组的密文和以后分组的明文异或操作后再加密，这样做的目标是加强破解难度。
PCBC：Propagating Cipher Block Chaining（填充明码块链接模式），也称为明文明码块链接模式（Plaintext Cipher Block Chaining），是一种能够使密文中的渺小更改在解密时导致明文大部分谬误的模式，并在加密的时候也具备同样的个性。
CFB：Cipher Feedback（明码反馈模式），能够将块明码变为自同步的流明码，相似于 CBC，CFB 的解密过程简直就是颠倒的 CBC 的加密过程。
OFB：Output Feedback（输入反馈模式），能够将块明码变成同步的流明码，它产生密钥流的块，而后将其与明文块进行异或，失去密文。与其它流明码一样，密文中一个位的翻转会使明文中同样地位的位也产生翻转。
CTR：Counter mode（计数器模式），也被称为 ICM 模式（Integer Counter Mode，整数计数模式）和 SIC 模式（Segmented Integer Counter），在 CTR 模式中，有一个自增的算子，这个算子用密钥加密之后的输入和明文异或的后果失去密文，相当于一次一密。这种加密形式简略疾速，安全可靠，而且能够并行加密，然而在计算器不能维持很长的状况下，密钥只能应用一次。

参考资料：维基百科：https://en.wikipedia.org/wiki…

块明码只能对确定长度的数据块进行解决，而音讯的长度通常是可变的。因而局部模式最初一块数据在加密前须要进行填充。有数种填充办法，其中最简略的一种是在明文的最初填充空字符以使其长度为块长度的整数倍。常见填充形式有以下几种：

PKCS7：在填充时首先获取须要填充的字节长度 = 块长度 –（数据长度 % 块长度）, 在填充字节序列中所有字节填充为须要填充的字节长度值。
PKCS5：PKCS5 作为 PKCS7 的子集算法，概念上没有什么区别，只是在 blockSize 上固定为 8 bytes，即块大小固定为 8 字节。
ZeroPadding：在填充时首先获取须要填充的字节长度 = 块长度 –（数据长度 % 块长度）, 在填充字节序列中所有字节填充为 0。
ISO10126：在填充时首先获取须要填充的字节长度 = 块长度 –（数据长度 % 块长度），在填充字节序列中最初一个字节填充为须要填充的字节长度值，填充字节中其余字节均填充随机数值。
ANSIX923：在填充时首先获取须要填充的字节长度 = 块长度 –（数据长度 % 块长度），在填充字节序列中最初一个字节填充为须要填充的字节长度值，填充字节中其余字节均填充数字零。

参考资料：

维基百科：https://en.wikipedia.org/wiki…
PKCS7/PKCS5 填充算法：https://segmentfault.com/a/11…

简介：Base64 是一种用 64 个字符来示意任意二进制数据的办法。

参考资料：

Base64 百度百科：https://baike.baidu.com/item/…
Base64 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function base64Encode() {var srcs = CryptoJS.enc.Utf8.parse(text);
    var encodeData = CryptoJS.enc.Base64.stringify(srcs);
    return encodeData
}

function base64Decode() {var srcs = CryptoJS.enc.Base64.parse(encodeData);
    var decodeData = srcs.toString(CryptoJS.enc.Utf8);
    return decodeData
}

var text = "I love Python!"

var encodeData = base64Encode()
var decodeData = base64Decode()

console.log("Base64 编码:", encodeData)
console.log("Base64 解码:", decodeData)

// Base64 编码:  SSBsb3ZlIFB5dGhvbiE=
// Base64 解码:  I love Python!

import base64


def base64_encode(text):
    encode_data = base64.b64encode(text.encode())
    return encode_data


def base64_decode(encode_data):
    decode_data = base64.b64decode(encode_data)
    return decode_data


if __name__ == '__main__':
    text = 'I love Python!'
    encode_data = base64_encode(text)
    decode_data = base64_decode(encode_data)
    print('Base64 编码：', encode_data)
    print('Base64 解码：', decode_data)

# Base64 编码：b'SSBsb3ZlIFB5dGhvbiE='
# Base64 解码：b'I love Python!'

简介：全称 MD5 音讯摘要算法（英文名称：MD5 Message-Digest Algorithm），又称哈希算法、散列算法，由美国明码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于 1992 年作为 RFC 1321 被颁布，用以取代 MD4 算法。摘要算法是单向加密的，也就是说明文通过摘要算法加密之后，是不能解密的。摘要算法的第二个特点密文是固定长度的，它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用 16 进制的字符串示意）。之所以叫摘要算法，它的算法就是提取明文重要的特色。所以，两个不同的明文，应用了摘要算法之后，有可能他们的密文是一样的，不过这个概率十分的低。

参考资料：

RFC 1321：https://datatracker.ietf.org/…
MD5 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function MD5Test() {
    var text = "I love python!"
    return CryptoJS.MD5(text).toString()}

console.log(MD5Test())  // 21169ee3acd4a24e1fcb4322cfd9a2b8

import hashlib


def md5_test1():
    md5 = hashlib.new('md5', 'I love python!'.encode('utf-8'))
    print(md5.hexdigest())


def md5_test2():
    md5 = hashlib.md5()
    md5.update('I love'.encode('utf-8'))
    md5.update('python!'.encode('utf-8'))
    print(md5.hexdigest())


if __name__ == '__main__':
    md5_test1()  # 21169ee3acd4a24e1fcb4322cfd9a2b8
    md5_test2()  # 21169ee3acd4a24e1fcb4322cfd9a2b8

简介：英文名称：Password-Based Key Derivation Function 2，PBKDF2 是 RSA 实验室的公钥加密规范（PKCS）系列的一部分，2017 年公布的 RFC 8018（PKCS #5 v2.1）举荐应用 PBKDF2 进行明码散列。PBKDF2 将伪随机函数（例如 HMAC），把明文和一个盐值（salt）作为输出参数，而后进行反复运算，并最终产生密钥，如果反复的次数足够大，破解的老本就会变得很高。

参考资料：

RFC 8018：https://datatracker.ietf.org/…
PBKDF2 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function pbkdf2Encrypt() {
    var text = "I love Python!"
    var salt = "43215678"
    // key 长度 128，10 次反复运算
    var encryptedData = CryptoJS.PBKDF2(text, salt, {keySize: 128/32,iterations: 10});
    return encryptedData.toString()}

console.log(pbkdf2Encrypt())  // 7fee6e8350cfe96314c76aaa6e853a50

import binascii
from Cryptodome.Hash import SHA1
from Cryptodome.Protocol.KDF import PBKDF2


text = 'I love Python!'
salt = b'43215678'
result = PBKDF2(text,  salt, count=10, hmac_hash_module=SHA1)
result = binascii.hexlify(result)
print(result)
# b'7fee6e8350cfe96314c76aaa6e853a50'

简介：全称平安哈希算法（英文名称：Secure Hash Algorithm），由美国国家安全局（NSA）所设计，次要实用于数字签名规范（Digital Signature Standard DSS）外面定义的数字签名算法（Digital Signature Algorithm DSA），SHA 通常指 SHA 家族的五个算法，别离是 SHA-1、SHA-224、SHA-256、SHA-384、SHA-512，后四者有时并称为 SHA-2，SHA 是比 MD5 更平安一点的摘要算法，MD5 的密文是 32 位，而 SHA-1 是 40 位，版本越强，密文越长，代价是速度越慢。

参考资料：

RFC 3174：https://datatracker.ietf.org/…
SHA 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function SHA1Encrypt() {
    var text = "I love python!"
    return CryptoJS.SHA1(text).toString();}

console.log(SHA1Encrypt())  // 23c02b203bd2e2ca19da911f1d270a06d86719fb

import hashlib


def sha1_test1():
    sha1 = hashlib.new('sha1', 'I love python!'.encode('utf-8'))
    print(sha1.hexdigest())


def sha1_test2():
    sha1 = hashlib.sha1()
    sha1.update('I love python!'.encode('utf-8'))
    print(sha1.hexdigest())


if __name__ == '__main__':
    sha1_test1()  # 23c02b203bd2e2ca19da911f1d270a06d86719fb
    sha1_test2()  # 23c02b203bd2e2ca19da911f1d270a06d86719fb

简介：全称散列音讯认证码、密钥相干的哈希运算音讯认证码（英文名称：Hash-based Message Authentication Code 或者 Keyed-hash Message Authentication Code），于 1996 年提出，1997 年作为 RFC 2104 被颁布，HMAC 加密算法是一种平安的基于加密 Hash 函数和共享密钥的音讯认证协定，它要求通信单方共享密钥 key、约定算法、对报文进行 Hash 运算，造成固定长度的认证码。通信单方通过认证码的校验来确定报文的合法性。

参考资料：

RFC 2104：https://datatracker.ietf.org/…
HMAC 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function HMACEncrypt() {
    var text = "I love python!"
    var key = "secret"
    return CryptoJS.HmacMD5(text, key).toString();
    // return CryptoJS.HmacSHA1(text, key).toString();
    // return CryptoJS.HmacSHA256(text, key).toString();}

console.log(HMACEncrypt())

import hmac


def hmac_test1():
    message = b'I love python!'
    key = b'secret'
    md5 = hmac.new(key, message, digestmod='MD5')
    print(md5.hexdigest())


def hmac_test2():
    key = 'secret'.encode('utf8')
    sha1 = hmac.new(key, digestmod='sha1')
    sha1.update('I love'.encode('utf8'))
    sha1.update('Python!'.encode('utf8'))
    print(sha1.hexdigest())


if __name__ == '__main__':
    hmac_test1()  # 9c503a1f852edcc3526ea56976c38edf
    hmac_test2()  # 2d8449a4292d4bbeed99ce9ea570880d6e19b61a

简介：全称数据加密规范（英文名称：Data Encryption Standard），加密与解密应用同一密钥，属于对称加密算法，1977 年被美国联邦政府的国家标准局确定为联邦材料解决规范（FIPS），DES 是一个分组加密算法，应用 56 位的密钥（个别认为密钥是 64 位，然而密钥的每个第 8 位设置为奇偶校验位，所以实际上无效位只有 56 位），因为 56 位密钥长度绝对较短，所以 DES 是不平安的，当初基本上已被更高级的加密规范 AES 取代。

mode 反对：CBC，CFB，CTR，CTRGladman，ECB，OFB 等。
padding 反对：ZeroPadding，NoPadding，AnsiX923，Iso10126，Iso97971，Pkcs7 等。

参考资料：

RFC 4772：https://datatracker.ietf.org/…
DES 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function desEncrypt() {var key = CryptoJS.enc.Utf8.parse(desKey),
        iv = CryptoJS.enc.Utf8.parse(desIv),
        srcs = CryptoJS.enc.Utf8.parse(text),
        // CBC 加密模式，Pkcs7 填充形式
        encrypted = CryptoJS.DES.encrypt(srcs, key, {
            iv: iv,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        });
    return encrypted.toString();}

function desDecrypt() {var key = CryptoJS.enc.Utf8.parse(desKey),
        iv = CryptoJS.enc.Utf8.parse(desIv),
        srcs = encryptedData,
        // CBC 加密模式，Pkcs7 填充形式
        decrypted = CryptoJS.DES.decrypt(srcs, key, {
            iv: iv,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        });
    return decrypted.toString(CryptoJS.enc.Utf8);
}

var text = "I love Python!"       // 待加密对象
var desKey = "6f726c64f2c2057"    // 密钥
var desIv = "0123456789ABCDEF"    // 初始向量

var encryptedData = desEncrypt()
var decryptedData = desDecrypt()

console.log("加密字符串:", encryptedData)
console.log("解密字符串:", decryptedData)

// 加密字符串:  +ndbEkWNw2QAfIYQtwC14w==
// 解密字符串:  I love Python!

import binascii
# 加密模式 CBC，填充形式 PAD_PKCS5
from pyDes import des, CBC, PAD_PKCS5


def des_encrypt(key, text, iv):
    k = des(key, CBC, iv, pad=None, padmode=PAD_PKCS5)
    en = k.encrypt(text, padmode=PAD_PKCS5)
    return binascii.b2a_hex(en)


def des_decrypt(key, text, iv):
    k = des(key, CBC, iv, pad=None, padmode=PAD_PKCS5)
    de = k.decrypt(binascii.a2b_hex(text), padmode=PAD_PKCS5)
    return de


if __name__ == '__main__':
    secret_key = '12345678'   # 密钥
    text = 'I love Python!'   # 加密对象
    iv = secret_key           # 偏移量
    secret_str = des_encrypt(secret_key, text, iv)
    print('加密字符串：', secret_str)
    clear_str = des_decrypt(secret_key, secret_str, iv)
    print('解密字符串：', clear_str)


# 加密字符串：b'302d3abf2421169239f829b38a9545f1'
# 解密字符串：b'I love Python!'

简介：全称三重数据加密算法（英文名称：Triple Data Encryption Standard、Triple Data Encryption Algorithm、TDES、TDEA），是对称加密算法中的一种。70 年代初由 IBM 研发，后 1977 年被美国国家标准局驳回为数据加密规范，它相当于是对每个数据块利用三次 DES 加密算法。因为计算机运算能力的加强，原版 DES 明码的密钥长度变得容易被暴力破解；3DES 即是设计用来提供一种绝对简略的办法，即通过减少 DES 的密钥长度来防止破解，所以严格来说 3DES 不是设计一种全新的块明码算法。

mode 反对：CBC，CFB，CTR，CTRGladman，ECB，OFB 等。
padding 反对：ZeroPadding，NoPadding，AnsiX923，Iso10126，Iso97971，Pkcs7 等。

参考资料：

RFC 1851：https://datatracker.ietf.org/…
3DES 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function tripleDesEncrypt() {var key = CryptoJS.enc.Utf8.parse(desKey),
        iv = CryptoJS.enc.Utf8.parse(desIv),
        srcs = CryptoJS.enc.Utf8.parse(text),
        // ECB 加密形式，Iso10126 填充形式
        encrypted = CryptoJS.TripleDES.encrypt(srcs, key, {
            iv: iv,
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Iso10126
        });
    return encrypted.toString();}

function tripleDesDecrypt() {var key = CryptoJS.enc.Utf8.parse(desKey),
        iv = CryptoJS.enc.Utf8.parse(desIv),
        srcs = encryptedData,
        // ECB 加密形式，Iso10126 填充形式
        decrypted = CryptoJS.TripleDES.decrypt(srcs, key, {
            iv: iv,
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Iso10126
        });
    return decrypted.toString(CryptoJS.enc.Utf8);
}

var text = "I love Python!"       // 待加密对象
var desKey = "6f726c64f2c2057c"    // 密钥
var desIv = "0123456789ABCDEF"    // 偏移量

var encryptedData = tripleDesEncrypt()
var decryptedData = tripleDesDecrypt()

console.log("加密字符串:", encryptedData)
console.log("解密字符串:", decryptedData)

// 加密字符串:  3J0NX7x6GbewjjhoW2HKqg==
// 解密字符串:  I love Python!

from Cryptodome.Cipher import DES3
from Cryptodome import Random


# 须要补位，str 不是 16 的倍数那就补足为 16 的倍数
def add_to_16(value):
    while len(value) % 16 != 0:
        value += '\0'
    return str.encode(value)


def des_encrypt(key, text, iv):
    # 加密模式 OFB
    cipher_encrypt = DES3.new(add_to_16(key), DES3.MODE_OFB, iv)
    encrypted_text = cipher_encrypt.encrypt(text.encode("utf-8"))
    return encrypted_text


def des_decrypt(key, text, iv):
    # 加密模式 OFB
    cipher_decrypt = DES3.new(add_to_16(key), DES3.MODE_OFB, iv)
    decrypted_text = cipher_decrypt.decrypt(text)
    return decrypted_text


if __name__ == '__main__':
    key = '12345678'            # 密钥，16 位
    text = 'I love Python!'     # 加密对象
    iv = Random.new().read(DES3.block_size)  # DES3.block_size == 8
    secret_str = des_encrypt(key, text, iv)
    print('加密字符串：', secret_str)
    clear_str = des_decrypt(key, secret_str, iv)
    print('解密字符串：', clear_str)


# 加密字符串：b'\xa5\x8a\xd4R\x99\x16j\xba?vg\xf2\xb6\xa9'
# 解密字符串：b'I love Python!'

简介：全称高级加密规范（英文名称：Advanced Encryption Standard），在密码学中又称 Rijndael 加密法，由美国国家标准与技术研究院（NIST）于 2001 年公布，并在 2002 年成为无效的规范，是美国联邦政府采纳的一种区块加密规范。这个规范用来代替原先的 DES，曾经被多方剖析且广为全世界所应用，它自身只有一个密钥，即用来实现加密，也用于解密。

mode 反对：CBC，CFB，CTR，CTRGladman，ECB，OFB 等。
padding 反对：ZeroPadding，NoPadding，AnsiX923，Iso10126，Iso97971，Pkcs7 等。

参考资料：

RFC 3268：https://datatracker.ietf.org/…
AES 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function tripleAesEncrypt() {var key = CryptoJS.enc.Utf8.parse(aesKey),
        iv = CryptoJS.enc.Utf8.parse(aesIv),
        srcs = CryptoJS.enc.Utf8.parse(text),
        // CBC 加密形式，Pkcs7 填充形式
        encrypted = CryptoJS.AES.encrypt(srcs, key, {
            iv: iv,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        });
    return encrypted.toString();}

function tripleAesDecrypt() {var key = CryptoJS.enc.Utf8.parse(aesKey),
        iv = CryptoJS.enc.Utf8.parse(aesIv),
        srcs = encryptedData,
        // CBC 加密形式，Pkcs7 填充形式
        decrypted = CryptoJS.AES.decrypt(srcs, key, {
            iv: iv,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        });
    return decrypted.toString(CryptoJS.enc.Utf8);
}

var text = "I love Python!"       // 待加密对象
var aesKey = "6f726c64f2c2057c"   // 密钥，16 倍数
var aesIv = "0123456789ABCDEF"    // 偏移量，16 倍数

var encryptedData = tripleAesEncrypt()
var decryptedData = tripleAesDecrypt()

console.log("加密字符串:", encryptedData)
console.log("解密字符串:", decryptedData)

// 加密字符串:  dZL7TLJR786VGvuUvqYGoQ==
// 解密字符串:  I love Python!

import base64
from Cryptodome.Cipher import AES


# 须要补位，str 不是 16 的倍数那就补足为 16 的倍数
def add_to_16(value):
    while len(value) % 16 != 0:
        value += '\0'
    return str.encode(value)


# 加密办法
def aes_encrypt(key, t, iv):
    aes = AES.new(add_to_16(key), AES.MODE_CBC, add_to_16(iv))  # 初始化加密器
    encrypt_aes = aes.encrypt(add_to_16(t))                    # 先进行 aes 加密
    encrypted_text = str(base64.encodebytes(encrypt_aes), encoding='utf-8')  # 执行加密并转码返回 bytes
    return encrypted_text


# 解密办法
def aes_decrypt(key, t, iv):
    aes = AES.new(add_to_16(key), AES.MODE_CBC, add_to_16(iv))         # 初始化加密器
    base64_decrypted = base64.decodebytes(t.encode(encoding='utf-8'))  # 优先逆向解密 base64 成 bytes
    decrypted_text = str(aes.decrypt(base64_decrypted), encoding='utf-8').replace('\0', '')  # 执行解密密并转码返回 str
    return decrypted_text


if __name__ == '__main__':
    secret_key = '12345678'   # 密钥
    text = 'I love Python!'   # 加密对象
    iv = secret_key           # 初始向量
    encrypted_str = aes_encrypt(secret_key, text, iv)
    print('加密字符串：', encrypted_str)
    decrypted_str = aes_decrypt(secret_key, encrypted_str, iv)
    print('解密字符串：', decrypted_str)


# 加密字符串：lAVKvkQh+GtdNpoKf4/mHA==
# 解密字符串：I love Python!

简介：英文名称：Rivest Cipher 4，也称为 ARC4 或 ARCFOUR，是一种流加密算法，密钥长度可变。它加解密应用雷同的密钥，因而也属于对称加密算法。RC4 是有线等效加密（WEP）中采纳的加密算法，也已经是 TLS 可采纳的算法之一，该算法的速度能够达到 DES 加密的 10 倍左右，且具备很高级别的非线性，尽管它在软件方面的简略性和速度十分杰出，但在 RC4 中发现了多个破绽，它特地容易受到攻打，RC4 作为一种老旧的验证和加密算法易于受到黑客攻击，当初逐步不举荐应用了。

参考资料：

RFC 7465：https://datatracker.ietf.org/…
RC4 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function RC4Encrypt() {return CryptoJS.RC4.encrypt(text, key).toString();}

function RC4Decrypt(){return CryptoJS.RC4.decrypt(encryptedData, key).toString(CryptoJS.enc.Utf8);
}

var text = "I love Python!"
var key = "6f726c64f2c2057c"

var encryptedData = RC4Encrypt()
var decryptedData = RC4Decrypt()

console.log("加密字符串:", encryptedData)
console.log("解密字符串:", decryptedData)

// 加密字符串:  U2FsdGVkX18hMm9WWdoEQGPolnXzlg9ryArdGNwv
// 解密字符串:  I love Python!

import base64
from Cryptodome.Cipher import ARC4


def rc4_encrypt(key, t):
    enc = ARC4.new(key.encode('utf8'))
    res = enc.encrypt(t.encode('utf-8'))
    res = base64.b64encode(res)
    return res


def rc4_decrypt(key, t):
    data = base64.b64decode(t)
    enc = ARC4.new(key.encode('utf8'))
    res = enc.decrypt(data)
    return res


if __name__ == "__main__":
    secret_key = '12345678'   # 密钥
    text = 'I love Python!'   # 加密对象
    encrypted_str = rc4_encrypt(secret_key, text)
    print('加密字符串：', encrypted_str)
    decrypted_str = rc4_decrypt(secret_key, encrypted_str)
    print('解密字符串：', decrypted_str)


# 加密字符串：b'8tNVu3/U/veJR2KgyBw='
# 解密字符串：b'I love Python!'

简介：Rabbit 加密算法是一个高性能的流明码加密形式，2003 年首次被提出，它从 128 位密钥和 64 位初始向量（iv）创立一个密钥流。

参考资料：

RFC 4503：https://datatracker.ietf.org/…
Rabbit 维基百科：https://en.wikipedia.org/wiki…

// 援用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function rabbitEncrypt() {return CryptoJS.Rabbit.encrypt(text, key).toString();}

function rabbitDecrypt() {return CryptoJS.Rabbit.decrypt(encryptedData, key).toString(CryptoJS.enc.Utf8);
}

var text = "I love Python!"
var key = "6f726c64f2c2057"

var encryptedData = rabbitEncrypt()
var decryptedData = rabbitDecrypt()

console.log("加密字符串:", encryptedData)
console.log("解密字符串:", decryptedData)

// 加密字符串:  U2FsdGVkX1+ZVCHRXlhmG5Xw87YPWMNIBlbukuh8
// 解密字符串:  I love Python!

目前没有找到有第三方库能够间接实现 Rabbit 算法，在 Python 中实现能够参考：https://asecuritysite.com/enc…

简介：英文名称：Rivest-Shamir-Adleman，是 1977 年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的，RSA 就是他们三人姓氏结尾字母拼在一起组成的，RSA 加密算法是一种非对称加密算法。在公开密钥加密和电子商业中 RSA 被宽泛应用。它被普遍认为是目前比拟优良的公钥计划之一。RSA 是第一个能同时用于加密和数字签名的算法，它可能抵制到目前为止已知的所有明码攻打。

参考资料：

RSA 维基百科：https://en.wikipedia.org/wiki…

// 援用 node-rsa 加密模块
var NodeRSA = require('node-rsa');

function rsaEncrypt() {pubKey = new NodeRSA(publicKey,'pkcs8-public');
    var encryptedData = pubKey.encrypt(text, 'base64');
    return encryptedData
}

function rsaDecrypt() {priKey = new NodeRSA(privatekey,'pkcs8-private');
    var decryptedData = priKey.decrypt(encryptedData, 'utf8');
    return decryptedData
}

var key = new NodeRSA({b: 512});                    // 生成 512 位秘钥
var publicKey = key.exportKey('pkcs8-public');    // 导出公钥
var privatekey = key.exportKey('pkcs8-private');  // 导出私钥
var text = "I love Python!"

var encryptedData = rsaEncrypt()
var decryptedData = rsaDecrypt()

console.log("公钥:\n", publicKey)
console.log("私钥:\n", privatekey)
console.log("加密字符串:", encryptedData)
console.log("解密字符串:", decryptedData)

/*
公钥:
 -----BEGIN PUBLIC KEY-----
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAOV1BwTJSVce/QjJAro5fXG9WzOpal09
Qtv1yuXKE81vZSNTHxW6dICwPT/kjCfC3bA5Qs6wnYBANuwD6wlAS0UCAwEAAQ==
-----END PUBLIC KEY-----
私钥:
 -----BEGIN PRIVATE KEY-----
MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEA5XUHBMlJVx79CMkC
ujl9cb1bM6lqXT1C2/XK5coTzW9lI1MfFbp0gLA9P+SMJ8LdsDlCzrCdgEA27APr
CUBLRQIDAQABAkAiXwJbJC+5PioXG80tyhjRZdT4iyMkrl2Kh2oKO9f1iLaBXLya
D0HW82wFh+cUy8GcMl9jse8DE8wd1TdORmHhAiEA/rwmWjXHVgDqcH/fqk8Ufku0
fXvs56h5QDoh1so5vokCIQDmmL3JDW6Y7RuK2qwFbHBZtYPRFRVdn5X1oqU2FOSX
3QIhAOVTjVN5RtNuT6Cn/jvcpZ5tmTe+8TA8w6vGqeAsfn/BAiBvKKIUEQ2HWoU0
YkUaODPQiteIKomqIAvB5S2O7HNlYQIgWMuLUxGZbbcAmIX+YmRXuET97S7OWv+z
WHVfb/rbXtI=
-----END PRIVATE KEY-----
加密字符串:  hHXTF1K3w55Wd6OSjVYtqxceJ5VhlySNUahel9pwKD92Ef7wIT7DYPuJRKiqz5tuHtUqujbmbZBSL0qDE/EA+A==
解密字符串:  I love Python!
*/

模块：rsa：

import rsa


def rsa_encrypt(pu_key, t):
    # 公钥加密
    rsa = rsa.encrypt(t.encode("utf-8"), pu_key)
    return rsa


def rsa_decrypt(pr_key, t):
    # 私钥解密
    rsa = rsa.decrypt(t, pr_key).decode("utf-8")
    return rsa


if __name__ == "__main__":
    public_key, private_key = rsa.newkeys(512)   # 生成公钥、私钥
    print('公钥：', public_key)
    print('私钥：', private_key)
    text = 'I love Python!'  # 加密对象
    encrypted_str = rsa_encrypt(public_key, text)
    print('加密字符串：', encrypted_str)
    decrypted_str = rsa_decrypt(private_key, encrypted_str)
    print('解密字符串：', decrypted_str)

'''
公钥：PublicKey(7636479066127060956100056267701318377455704072072698049978592945665550579944731953431504993757594103617537700972424661030900303472123028864161050235168613, 65537)
私钥：PrivateKey(7636479066127060956100056267701318377455704072072698049978592945665550579944731953431504993757594103617537700972424661030900303472123028864161050235168613, 65537, 3850457767980968449796700480128630632818465005441846698224554128042451115530564586537997896922067523638756079019054611200173122138274839877369624069360253, 4713180694194659323798858305046043997526301456820208338158979730140812744181638767, 1620238976946735819854194349514460863335347861649166352709029254680140139)
加密字符串：b"\x1aaeps\xa0c}\xb6\xcf\xa3\xb0\xbb\xedA\x7f}\x03\xdc\xd5\x1c\x9b\xdb\xda\xf9q\x80[=\xf5\x91\r\xd0'f\xce\x1f\x01\xef\xa5\xdb3\x96\t0qIxF\xbd\x11\xd6\xb25\xc5\xe1pM\xb4M\xc2\xd4\x03\xa6"解密字符串：I love Python!'''

模块 Cryptodome：

import base64
from Cryptodome.PublicKey import RSA
from Cryptodome.Cipher import PKCS1_v1_5


data = "cKK8B2rWwfwWeXhz"
public_key = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAM1xhOWaThSMpfxFsjV5YaWOFHt+6RvS+zH2Pa47VVr8PkZYnRaaKKy2MYBuEh7mZfM/R1dUXTgu0gp6VTNeNQkCAwEAAQ=="
rsa_key = RSA.import_key(base64.b64decode(public_key))  # 导入读取到的公钥
cipher = PKCS1_v1_5.new(rsa_key)                        # 生成对象
cipher_text = base64.b64encode(cipher.encrypt(data.encode(encoding="utf-8")))
print(cipher_text)

关于python:爬虫知识爬虫常见加密解密算法

简介

JavaScript 加密解密模块

Crypto-JS

Node-RSA

JSEncrypt

Python 加密解密库

Cryptodome & Crypto

Hashlib

HMAC

pyDes

ESA

加密解密基本参数

初始向量 iv

加密模式 mode

填充形式 padding

Base64

JavaScript 实现

Python 实现

MD5

JavaScript 实现

Python 实现

PBKDF2

JavaScript 实现

Python 实现

SHA

JavaScript 实现

Python 实现

HMAC

JavaScript 实现

Python 实现

DES

JavaScript 实现

Python 实现

3DES

JavaScript 实现

Python 实现

AES

JavaScript 实现

Python 实现

RC4

JavaScript 实现

Python 实现

Rabbit

JavaScript 实现

Python 实现

RSA

JavaScript 实现

Python 实现

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）