簡介

本文總結了在爬蟲中常見的各種加密算法、編碼算法的原理、在 JavaScript 中和 Python 中的基本實現方法，遇到 JS 加密的時候可以快速還原加密過程，有的網站在加密的過程中可能還經過了其他處理，但是大致的方法是一樣的。

常見加密算法：

1. 對稱加密（加密解密密鑰相同）：DES、3DES、AES、RC4、Rabbit
2. 非對稱加密（區分公鑰和私鑰）：RSA、DSA、ECC
3. 消息摘要算法/簽名算法：MD5、SHA、HMAC、PBKDF2

常見編碼算法：Base64

JavaScript 加密解密模塊

Crypto-JS

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/docs/

• Crypto-JS Github：https://github.com/brix/crypto-js

Node-RSA

Node-RSA 對 RSA 算法提供了支持，使用命令 npm install node-rsa 安裝。

參考資料：Node-RSA Github：https://github.com/rzcoder/node-rsa

JSEncrypt

參考資料：JSEncrypt 對 RSA 算法提供了更加全面的支持，使用命令 npm install jsencrypt 安裝。

• JSEncrypt 文檔：http://travistidwell.com/jsencrypt/
• JSEncrypt Github：https://github.com/travist/jsencrypt

Python 加密解密庫

Cryptodome & Crypto

在 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/software/pycrypto/

• Cryptodome 庫：https://www.pycryptodome.org/en/latest/

Hashlib

Python 的標準庫 hashlib 提供了常見的摘要算法，如 MD5，SHA、BLAKE2b、BLAKE2s 等。

參考資料：

• hashlib 庫：https://docs.python.org/3/library/hashlib.html
• 廖雪峰 hashlib：https://www.liaoxuefeng.com/wiki/1016959663602400/1017686752491744

HMAC

Python 的標準庫 hmac 對 HMAC 算法提供了支持。

參考資料：

• hmac 庫：https://docs.python.org/3/library/hmac.html
• 廖雪峰 hmac：https://www.liaoxuefeng.com/wiki/1016959663602400/1183198304823296

pyDes

Python 的第三方庫 pyDes 對 DES 算法提供了支持。使用命令 pip install pydes 進行安裝。

參考資料：pyDes 庫：https://github.com/twhiteman/pyDes

ESA

Python 的第三方庫 rsa 對 RSA 算法提供了支持。使用命令 pip install rsa 進行安裝。

參考資料：rsa 庫：https://stuvel.eu/python-rsa-doc/

加密解密基本參數

在一些對稱和非對稱加密算法中，經常會用到以下三個參數：初始向量 iv、加密模式 mode、填充方式 padding，先介紹一下這三個參數的含義和作用：

初始向量 iv

在密碼學中，初始向量（initialization vector，縮寫為 iv），又稱初始變數（starting variable，縮寫為 sv），與密鑰結合使用，作為加密數據的手段，它是一個固定長度的值，iv 的長度取決于加密方法，通常與使用的加密密鑰或密碼塊的長度相當，一般在使用過程中會要求它是隨機數或擬隨機數，使用隨機數產生的初始向量才能達到語義安全，讓攻擊者難以對原文一致且使用同一把密鑰生成的密文進行破解。

參考資料：維基百科：https://en.wikipedia.org/wiki/Initialization_vector

加密模式 mode

目前流行的加密和數字認證算法，都是采用塊加密方式，就是將需要加密的明文分成固定大小的數據塊，然后對其執行密碼算法，得到密文。數據塊的大小通常采用跟密鑰一樣的長度。加密模式在加密算法的基礎上發展出來，同時也可以獨立于加密算法而存在，加密模式定義了怎樣通過重復利用加密算法將大于一個數據塊大小的明文轉化為密文，描述了加密每一數據塊的過程。目前利用較多的加密模式有以下幾種：

• 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/Block_cipher_mode_of_operation

填充方式 padding

塊密碼只能對確定長度的數據塊進行處理，而消息的長度通常是可變的。因此部分模式最后一塊數據在加密前需要進行填充。有數種填充方法，其中最簡單的一種是在明文的最后填充空字符以使其長度為塊長度的整數倍。常見填充方式有以下幾種：

• PKCS7：在填充時首先獲取需要填充的字節長度 = 塊長度 - （數據長度 % 塊長度）, 在填充字節序列中所有字節填充為需要填充的字節長度值。

• PKCS5：PKCS5 作為 PKCS7 的子集算法，概念上沒有什么區別，只是在 blockSize 上固定為 8 bytes，即塊大小固定為 8 字節。

• ZeroPadding：在填充時首先獲取需要填充的字節長度 = 塊長度 - （數據長度 % 塊長度）, 在填充字節序列中所有字節填充為 0 。

• ISO10126：在填充時首先獲取需要填充的字節長度 = 塊長度 - （數據長度 % 塊長度），在填充字節序列中最后一個字節填充為需要填充的字節長度值，填充字節中其余字節均填充隨機數值。

• ANSIX923：在填充時首先獲取需要填充的字節長度 = 塊長度 - （數據長度 % 塊長度），在填充字節序列中最后一個字節填充為需要填充的字節長度值，填充字節中其余字節均填充數字零。

參考資料：

• 維基百科：https://en.wikipedia.org/wiki/Padding_(cryptography)
• PKCS7/PKCS5 填充算法：https://segmentfault.com/a/1190000019793040

Base64

簡介：Base64 是一種用 64 個字符來表示任意二進制數據的方法。

參考資料：

• Base64 百度百科：https://baike.baidu.com/item/base64/8545775
• Base64 維基百科：https://en.wikipedia.org/wiki/Base64

JavaScript 實現

// 引用 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!

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 消息摘要算法（英文名稱：MD5 Message-Digest Algorithm），又稱哈希算法、散列算法，由美國密碼學家羅納德·李維斯特（Ronald Linn Rivest）設計，于 1992 年作為 RFC 1321 被公布，用以取代 MD4 算法。摘要算法是單向加密的，也就是說明文通過摘要算法加密之后，是不能解密的。摘要算法的第二個特點密文是固定長度的，它通過一個函數，把任意長度的數據轉換為一個長度固定的數據串（通常用16進制的字符串表示）。之所以叫摘要算法，它的算法就是提取明文重要的特征。所以，兩個不同的明文，使用了摘要算法之后，有可能他們的密文是一樣的，不過這個概率非常的低。

參考資料：

• RFC 1321：https://datatracker.ietf.org/doc/rfc1321/
• MD5 維基百科：https://en.wikipedia.org/wiki/MD5

JavaScript 實現

// 引用 crypto-js 加密模塊
var CryptoJS = require('crypto-js')

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

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

Python 實現

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

PBKDF2

簡介：英文名稱：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/doc/rfc8018/
• PBKDF2 維基百科：https://en.wikipedia.org/wiki/PBKDF2

JavaScript 實現

// 引用 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

Python 實現

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'

SHA

簡介：全稱安全哈希算法（英文名稱：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/doc/rfc3174/
• SHA 維基百科：https://en.wikipedia.org/wiki/Secure_Hash_Algorithms

JavaScript 實現

// 引用 crypto-js 加密模塊
var CryptoJS = require('crypto-js')

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

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

Python 實現

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

HMAC

簡介：全稱散列消息認證碼、密鑰相關的哈希運算消息認證碼（英文名稱：Hash-based Message Authentication Code 或者 Keyed-hash Message Authentication Code），于 1996 年提出，1997 年作為 RFC 2104 被公布，HMAC 加密算法是一種安全的基于加密 Hash 函數和共享密鑰的消息認證協議，它要求通信雙方共享密鑰 key、約定算法、對報文進行 Hash 運算，形成固定長度的認證碼。通信雙方通過認證碼的校驗來確定報文的合法性。

參考資料：

• RFC 2104：https://datatracker.ietf.org/doc/rfc2104/
• HMAC 維基百科：https://en.wikipedia.org/wiki/HMAC

JavaScript 實現

// 引用 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())

Python 實現

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

DES

簡介：全稱數據加密標準（英文名稱：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/doc/rfc4772/
• DES 維基百科：https://en.wikipedia.org/wiki/Data_Encryption_Standard

JavaScript 實現

// 引用 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!

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!'

3DES

簡介：全稱三重數據加密算法（英文名稱：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/doc/rfc1851/
• 3DES 維基百科：https://en.wikipedia.org/wiki/Triple_DES

JavaScript 實現

// 引用 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!

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!'

AES

簡介：全稱高級加密標準（英文名稱：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/doc/rfc3268/
• AES 維基百科：https://en.wikipedia.org/wiki/Advanced_Encryption_Standard

JavaScript 實現

// 引用 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!

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!

RC4

簡介：英文名稱：Rivest Cipher 4，也稱為 ARC4 或 ARCFOUR，是一種流加密算法，密鑰長度可變。它加解密使用相同的密鑰，因此也屬于對稱加密算法。RC4 是有線等效加密（WEP）中采用的加密算法，也曾經是 TLS 可采用的算法之一，該算法的速度可以達到 DES 加密的 10 倍左右，且具有很高級別的非線性，雖然它在軟件方面的簡單性和速度非常出色，但在 RC4 中發現了多個漏洞，它特別容易受到攻擊，RC4 作為一種老舊的驗證和加密算法易于受到黑客攻擊，現在逐漸不推薦使用了。

參考資料：

• RFC 7465：https://datatracker.ietf.org/doc/rfc7465/
• RC4 維基百科：https://en.wikipedia.org/wiki/RC4

JavaScript 實現

// 引用 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!

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

簡介：Rabbit 加密算法是一個高性能的流密碼加密方式，2003 年首次被提出，它從 128 位密鑰和 64 位初始向量（iv）創建一個密鑰流。

參考資料：

• RFC 4503：https://datatracker.ietf.org/doc/rfc4503/
• Rabbit 維基百科：https://en.wikipedia.org/wiki/Rabbit_(cipher)

JavaScript 實現

// 引用 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!

Python 實現

目前沒有找到有第三方庫可以直接實現 Rabbit 算法，在 Python 中實現可以參考：https://asecuritysite.com/encryption/rabbit2

RSA

簡介：英文名稱：Rivest-Shamir-Adleman，是 1977 年由羅納德·李維斯特（Ron Rivest）、阿迪·薩莫爾（Adi Shamir）和倫納德·阿德曼（Leonard Adleman）一起提出的，RSA 就是他們三人姓氏開頭字母拼在一起組成的，RSA 加密算法是一種非對稱加密算法。在公開密鑰加密和電子商業中RSA被廣泛使用。它被普遍認為是目前比較優秀的公鑰方案之一。RSA是第一個能同時用于加密和數字簽名的算法，它能夠抵抗到目前為止已知的所有密碼攻擊。

參考資料：

• RSA 維基百科：https://en.wikipedia.org/wiki/RSA_(cryptosystem)

JavaScript 實現

// 引用 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!
*/

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)