簡(jiǎn)介

本文總結(jié)了在爬蟲(chóng)中常見(jiàn)的各種加密算法势决、編碼算法的原理阻塑、在 JavaScript 中和 Python 中的基本實(shí)現(xiàn)方法，遇到 JS 加密的時(shí)候可以快速還原加密過(guò)程果复，有的網(wǎng)站在加密的過(guò)程中可能還經(jīng)過(guò)了其他處理陈莽，但是大致的方法是一樣的。

常見(jiàn)加密算法：

1. 對(duì)稱加密（加密解密密鑰相同）：DES虽抄、3DES走搁、AES、RC4迈窟、Rabbit
2. 非對(duì)稱加密（區(qū)分公鑰和私鑰）：RSA私植、DSA、ECC
3. 消息摘要算法/簽名算法：MD5车酣、SHA兵琳、HMAC、PBKDF2

常見(jiàn)編碼算法：Base64

JavaScript 加密解密模塊

Crypto-JS

Crypto-JS 支持 MD5骇径、SHA躯肌、RIPEMD-160、HMAC破衔、PBKDF2清女、AES、DES晰筛、3DES（Triple DES）嫡丙、Rabbit、RC4 等读第，不支持 RSA曙博、ECC，是應(yīng)用比較廣的加密模塊怜瞒，使用命令 npm install crypto-js 安裝父泳。

參考資料：

• Crypto-JS 文檔：https://cryptojs.gitbook.io/docs/

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

Node-RSA

Node-RSA 對(duì) RSA 算法提供了支持般哼，使用命令 npm install node-rsa 安裝。

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

JSEncrypt

參考資料：JSEncrypt 對(duì) RSA 算法提供了更加全面的支持惠窄，使用命令 npm install jsencrypt 安裝蒸眠。

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

Python 加密解密庫(kù)

Cryptodome & Crypto

在 Python 中有很多算法是通過(guò)第三方庫(kù) Cryptodome 或者 Crypto 來(lái)實(shí)現(xiàn)的，Cryptodome 幾乎是 Crypto 的替代品杆融，Crypto 已經(jīng)停止更新好多年了楞卡，有很多未知錯(cuò)誤，所以不建議安裝 Crypto 脾歇！

Cryptodome 支持幾乎所有主流加密算法蒋腮，包括 MD5、SHA藕各、BLAKE2b池摧、BLAKE2s、HMAC座韵、PBKDF2险绘、AES、DES誉碴、3DES（Triple DES）宦棺、ECC、RSA黔帕、RC4 等代咸。

Cryptodome 使用命令 pip install pycryptodome 進(jìn)行安裝，Crypto 使用命令 pip install pycrypto 進(jìn)行安裝成黄。

參考資料：

• Crypto 庫(kù)：https://www.dlitz.net/software/pycrypto/

• Cryptodome 庫(kù)：https://www.pycryptodome.org/en/latest/

Hashlib

Python 的標(biāo)準(zhǔn)庫(kù) hashlib 提供了常見(jiàn)的摘要算法呐芥，如 MD5，SHA奋岁、BLAKE2b思瘟、BLAKE2s 等。

參考資料：

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

HMAC

Python 的標(biāo)準(zhǔn)庫(kù) hmac 對(duì) HMAC 算法提供了支持闻伶。

參考資料：

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

pyDes

Python 的第三方庫(kù) pyDes 對(duì) DES 算法提供了支持滨攻。使用命令 pip install pydes 進(jìn)行安裝。

參考資料：pyDes 庫(kù)：https://github.com/twhiteman/pyDes

ESA

Python 的第三方庫(kù) rsa 對(duì) RSA 算法提供了支持蓝翰。使用命令 pip install rsa 進(jìn)行安裝光绕。

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

加密解密基本參數(shù)

在一些對(duì)稱和非對(duì)稱加密算法中，經(jīng)常會(huì)用到以下三個(gè)參數(shù)：初始向量 iv畜份、加密模式 mode诞帐、填充方式 padding，先介紹一下這三個(gè)參數(shù)的含義和作用：

初始向量 iv

在密碼學(xué)中爆雹，初始向量（initialization vector停蕉，縮寫(xiě)為 iv）愕鼓，又稱初始變數(shù)（starting variable，縮寫(xiě)為 sv）谷徙，與密鑰結(jié)合使用拒啰，作為加密數(shù)據(jù)的手段驯绎，它是一個(gè)固定長(zhǎng)度的值完慧，iv 的長(zhǎng)度取決于加密方法，通常與使用的加密密鑰或密碼塊的長(zhǎng)度相當(dāng)剩失，一般在使用過(guò)程中會(huì)要求它是隨機(jī)數(shù)或擬隨機(jī)數(shù)屈尼，使用隨機(jī)數(shù)產(chǎn)生的初始向量才能達(dá)到語(yǔ)義安全，讓攻擊者難以對(duì)原文一致且使用同一把密鑰生成的密文進(jìn)行破解拴孤。

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

加密模式 mode

目前流行的加密和數(shù)字認(rèn)證算法脾歧，都是采用塊加密方式，就是將需要加密的明文分成固定大小的數(shù)據(jù)塊演熟，然后對(duì)其執(zhí)行密碼算法鞭执，得到密文。數(shù)據(jù)塊的大小通常采用跟密鑰一樣的長(zhǎng)度芒粹。加密模式在加密算法的基礎(chǔ)上發(fā)展出來(lái)兄纺，同時(shí)也可以獨(dú)立于加密算法而存在，加密模式定義了怎樣通過(guò)重復(fù)利用加密算法將大于一個(gè)數(shù)據(jù)塊大小的明文轉(zhuǎn)化為密文化漆，描述了加密每一數(shù)據(jù)塊的過(guò)程估脆。目前利用較多的加密模式有以下幾種：

• ECB：Electronic Code Book（電子碼本模式），是一種基礎(chǔ)的加密方式座云，密文被分割成分組長(zhǎng)度相等的塊（不足補(bǔ)齊）疙赠，然后單獨(dú)一個(gè)個(gè)加密，一個(gè)個(gè)輸出組成密文朦拖。

• CBC：Cipher Block Chaining（密碼塊鏈接模式）圃阳，是一種循環(huán)模式，前一個(gè)分組的密文和當(dāng)前分組的明文異或操作后再加密璧帝，這樣做的目的是增強(qiáng)破解難度捍岳。

• PCBC：Propagating Cipher Block Chaining（填充密碼塊鏈接模式），也稱為明文密碼塊鏈接模式（Plaintext Cipher Block Chaining）裸弦，是一種可以使密文中的微小更改在解密時(shí)導(dǎo)致明文大部分錯(cuò)誤的模式祟同，并在加密的時(shí)候也具有同樣的特性。

• CFB：Cipher Feedback（密碼反饋模式）理疙，可以將塊密碼變?yōu)樽酝降牧髅艽a晕城，類似于 CBC，CFB 的解密過(guò)程幾乎就是顛倒的 CBC 的加密過(guò)程窖贤。

• OFB：Output Feedback（輸出反饋模式）砖顷，可以將塊密碼變成同步的流密碼贰锁，它產(chǎn)生密鑰流的塊，然后將其與明文塊進(jìn)行異或滤蝠，得到密文豌熄。與其它流密碼一樣，密文中一個(gè)位的翻轉(zhuǎn)會(huì)使明文中同樣位置的位也產(chǎn)生翻轉(zhuǎn)物咳。

• CTR：Counter mode（計(jì)數(shù)器模式）锣险，也被稱為 ICM 模式（Integer Counter Mode，整數(shù)計(jì)數(shù)模式）和 SIC 模式（Segmented Integer Counter）览闰，在 CTR 模式中芯肤，有一個(gè)自增的算子，這個(gè)算子用密鑰加密之后的輸出和明文異或的結(jié)果得到密文压鉴，相當(dāng)于一次一密崖咨。這種加密方式簡(jiǎn)單快速，安全可靠油吭，而且可以并行加密击蹲，但是在計(jì)算器不能維持很長(zhǎng)的情況下，密鑰只能使用一次婉宰。

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

填充方式 padding

塊密碼只能對(duì)確定長(zhǎng)度的數(shù)據(jù)塊進(jìn)行處理歌豺，而消息的長(zhǎng)度通常是可變的。因此部分模式最后一塊數(shù)據(jù)在加密前需要進(jìn)行填充芍阎。有數(shù)種填充方法世曾，其中最簡(jiǎn)單的一種是在明文的最后填充空字符以使其長(zhǎng)度為塊長(zhǎng)度的整數(shù)倍。常見(jiàn)填充方式有以下幾種：

• PKCS7：在填充時(shí)首先獲取需要填充的字節(jié)長(zhǎng)度 = 塊長(zhǎng)度 - （數(shù)據(jù)長(zhǎng)度 % 塊長(zhǎng)度）, 在填充字節(jié)序列中所有字節(jié)填充為需要填充的字節(jié)長(zhǎng)度值谴咸。

• PKCS5：PKCS5 作為 PKCS7 的子集算法轮听，概念上沒(méi)有什么區(qū)別，只是在 blockSize 上固定為 8 bytes岭佳，即塊大小固定為 8 字節(jié)血巍。

• ZeroPadding：在填充時(shí)首先獲取需要填充的字節(jié)長(zhǎng)度 = 塊長(zhǎng)度 - （數(shù)據(jù)長(zhǎng)度 % 塊長(zhǎng)度）, 在填充字節(jié)序列中所有字節(jié)填充為 0 。

• ISO10126：在填充時(shí)首先獲取需要填充的字節(jié)長(zhǎng)度 = 塊長(zhǎng)度 - （數(shù)據(jù)長(zhǎng)度 % 塊長(zhǎng)度）珊随，在填充字節(jié)序列中最后一個(gè)字節(jié)填充為需要填充的字節(jié)長(zhǎng)度值述寡，填充字節(jié)中其余字節(jié)均填充隨機(jī)數(shù)值。

• ANSIX923：在填充時(shí)首先獲取需要填充的字節(jié)長(zhǎng)度 = 塊長(zhǎng)度 - （數(shù)據(jù)長(zhǎng)度 % 塊長(zhǎng)度）叶洞，在填充字節(jié)序列中最后一個(gè)字節(jié)填充為需要填充的字節(jié)長(zhǎng)度值鲫凶，填充字節(jié)中其余字節(jié)均填充數(shù)字零。

參考資料：

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

Base64

簡(jiǎn)介：Base64 是一種用 64 個(gè)字符來(lái)表示任意二進(jìn)制數(shù)據(jù)的方法衩辟。

參考資料：

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

JavaScript 實(shí)現(xiàn)

// 引用 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 實(shí)現(xiàn)

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

簡(jiǎn)介：全稱 MD5 消息摘要算法（英文名稱：MD5 Message-Digest Algorithm）螟炫，又稱哈希算法、散列算法艺晴，由美國(guó)密碼學(xué)家羅納德·李維斯特（Ronald Linn Rivest）設(shè)計(jì)昼钻，于 1992 年作為 RFC 1321 被公布掸屡，用以取代 MD4 算法。摘要算法是單向加密的然评，也就是說(shuō)明文通過(guò)摘要算法加密之后仅财，是不能解密的。摘要算法的第二個(gè)特點(diǎn)密文是固定長(zhǎng)度的碗淌，它通過(guò)一個(gè)函數(shù)盏求，把任意長(zhǎng)度的數(shù)據(jù)轉(zhuǎn)換為一個(gè)長(zhǎng)度固定的數(shù)據(jù)串（通常用16進(jìn)制的字符串表示）。之所以叫摘要算法贯莺，它的算法就是提取明文重要的特征风喇。所以宁改，兩個(gè)不同的明文缕探，使用了摘要算法之后，有可能他們的密文是一樣的还蹲，不過(guò)這個(gè)概率非常的低爹耗。

參考資料：

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

JavaScript 實(shí)現(xiàn)

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

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

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

Python 實(shí)現(xiàn)

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

簡(jiǎn)介：英文名稱：Password-Based Key Derivation Function 2，PBKDF2 是 RSA 實(shí)驗(yàn)室的公鑰加密標(biāo)準(zhǔn)（PKCS）系列的一部分谜喊，2017 年發(fā)布的 RFC 8018 （PKCS #5 v2.1）推薦使用 PBKDF2 進(jìn)行密碼散列潭兽。PBKDF2 將偽隨機(jī)函數(shù)（例如 HMAC），把明文和一個(gè)鹽值（salt）作為輸入?yún)?shù)斗遏，然后進(jìn)行重復(fù)運(yùn)算山卦，并最終產(chǎn)生密鑰，如果重復(fù)的次數(shù)足夠大诵次，破解的成本就會(huì)變得很高账蓉。

參考資料：

• RFC 8018：https://datatracker.ietf.org/doc/rfc8018/
• PBKDF2 維基百科：https://en.wikipedia.org/wiki/PBKDF2

JavaScript 實(shí)現(xiàn)

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

function pbkdf2Encrypt() {
    var text = "I love Python!"
    var salt = "43215678"
    // key 長(zhǎng)度 128，10 次重復(fù)運(yùn)算
    var encryptedData = CryptoJS.PBKDF2(text, salt, {keySize: 128/32,iterations: 10});
    return encryptedData.toString()
}

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

Python 實(shí)現(xiàn)

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

簡(jiǎn)介：全稱安全哈希算法（英文名稱：Secure Hash Algorithm）逾一，由美國(guó)國(guó)家安全局（NSA）所設(shè)計(jì)铸本，主要適用于數(shù)字簽名標(biāo)準(zhǔn)（Digital Signature Standard DSS）里面定義的數(shù)字簽名算法（Digital Signature Algorithm DSA），SHA 通常指 SHA 家族的五個(gè)算法遵堵，分別是 SHA-1箱玷、SHA-224、SHA-256陌宿、SHA-384锡足、SHA-512，后四者有時(shí)并稱為 SHA-2壳坪，SHA 是比 MD5 更安全一點(diǎn)的摘要算法舶得，MD5 的密文是 32 位，而 SHA-1 是 40 位，版本越強(qiáng)外恕，密文越長(zhǎng)，代價(jià)是速度越慢幔崖。

參考資料：

• RFC 3174：https://datatracker.ietf.org/doc/rfc3174/
• SHA 維基百科：https://en.wikipedia.org/wiki/Secure_Hash_Algorithms

JavaScript 實(shí)現(xiàn)

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

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

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

Python 實(shí)現(xiàn)

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

簡(jiǎn)介：全稱散列消息認(rèn)證碼珠插、密鑰相關(guān)的哈希運(yùn)算消息認(rèn)證碼（英文名稱：Hash-based Message Authentication Code 或者 Keyed-hash Message Authentication Code）惧磺，于 1996 年提出，1997 年作為 RFC 2104 被公布捻撑，HMAC 加密算法是一種安全的基于加密 Hash 函數(shù)和共享密鑰的消息認(rèn)證協(xié)議磨隘，它要求通信雙方共享密鑰 key、約定算法顾患、對(duì)報(bào)文進(jìn)行 Hash 運(yùn)算番捂，形成固定長(zhǎng)度的認(rèn)證碼。通信雙方通過(guò)認(rèn)證碼的校驗(yàn)來(lái)確定報(bào)文的合法性江解。

參考資料：

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

JavaScript 實(shí)現(xiàn)

// 引用 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 實(shí)現(xiàn)

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

簡(jiǎn)介：全稱數(shù)據(jù)加密標(biāo)準(zhǔn)（英文名稱：Data Encryption Standard）设预，加密與解密使用同一密鑰，屬于對(duì)稱加密算法犁河，1977 年被美國(guó)聯(lián)邦政府的國(guó)家標(biāo)準(zhǔn)局確定為聯(lián)邦資料處理標(biāo)準(zhǔn)（FIPS）鳖枕，DES 是一個(gè)分組加密算法，使用 56 位的密鑰（一般認(rèn)為密鑰是 64 位桨螺，但是密鑰的每個(gè)第 8 位設(shè)置為奇偶校驗(yàn)位宾符，所以實(shí)際上有效位只有 56 位），由于 56 位密鑰長(zhǎng)度相對(duì)較短灭翔，所以 DES 是不安全的魏烫，現(xiàn)在基本上已被更高級(jí)的加密標(biāo)準(zhǔn) 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 實(shí)現(xiàn)

// 引用 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!"       // 待加密對(duì)象
var desKey = "6f726c64f2c2057"    // 密鑰
var desIv = "0123456789ABCDEF"    // 初始向量

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

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

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

Python 實(shí)現(xiàn)

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!'   # 加密對(duì)象
    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

簡(jiǎn)介：全稱三重?cái)?shù)據(jù)加密算法（英文名稱：Triple Data Encryption Standard、 Triple Data Encryption Algorithm碧囊、TDES树灶、TDEA），是對(duì)稱加密算法中的一種糯而。70 年代初由 IBM 研發(fā)天通，后 1977 年被美國(guó)國(guó)家標(biāo)準(zhǔn)局采納為數(shù)據(jù)加密標(biāo)準(zhǔn)，它相當(dāng)于是對(duì)每個(gè)數(shù)據(jù)塊應(yīng)用三次 DES 加密算法熄驼。由于計(jì)算機(jī)運(yùn)算能力的增強(qiáng)像寒，原版 DES 密碼的密鑰長(zhǎng)度變得容易被暴力破解诺祸；3DES 即是設(shè)計(jì)用來(lái)提供一種相對(duì)簡(jiǎn)單的方法祭芦，即通過(guò)增加 DES 的密鑰長(zhǎng)度來(lái)避免破解筷笨，所以嚴(yán)格來(lái)說(shuō) 3DES 不是設(shè)計(jì)一種全新的塊密碼算法实束。

• 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 實(shí)現(xiàn)

// 引用 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!"       // 待加密對(duì)象
var desKey = "6f726c64f2c2057c"    // 密鑰
var desIv = "0123456789ABCDEF"    // 偏移量

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

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

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

Python 實(shí)現(xiàn)

from Cryptodome.Cipher import DES3
from Cryptodome import Random


# 需要補(bǔ)位宣蔚，str不是16的倍數(shù)那就補(bǔ)足為16的倍數(shù)
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!'     # 加密對(duì)象
    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

簡(jiǎn)介：全稱高級(jí)加密標(biāo)準(zhǔn)（英文名稱：Advanced Encryption Standard）亩冬，在密碼學(xué)中又稱 Rijndael 加密法硼身，由美國(guó)國(guó)家標(biāo)準(zhǔn)與技術(shù)研究院 （NIST）于 2001 年發(fā)布佳遂，并在 2002 年成為有效的標(biāo)準(zhǔn)丑罪，是美國(guó)聯(lián)邦政府采用的一種區(qū)塊加密標(biāo)準(zhǔn)吩屹。這個(gè)標(biāo)準(zhǔn)用來(lái)替代原先的 DES，已經(jīng)被多方分析且廣為全世界所使用免绿，它本身只有一個(gè)密鑰嘲驾，即用來(lái)實(shí)現(xiàn)加密厌衙，也用于解密婶希。

• 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 實(shí)現(xiàn)

// 引用 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!"       // 待加密對(duì)象
var aesKey = "6f726c64f2c2057c"   // 密鑰羹蚣，16 倍數(shù)
var aesIv = "0123456789ABCDEF"    // 偏移量，16 倍數(shù)

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

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

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

Python 實(shí)現(xiàn)

import base64
from Cryptodome.Cipher import AES


# 需要補(bǔ)位徒蟆，str不是16的倍數(shù)那就補(bǔ)足為16的倍數(shù)
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))                    # 先進(jìn)行 aes 加密
    encrypted_text = str(base64.encodebytes(encrypt_aes), encoding='utf-8')  # 執(zhí)行加密并轉(zhuǎn)碼返回 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'))  # 優(yōu)先逆向解密 base64 成 bytes
    decrypted_text = str(aes.decrypt(base64_decrypted), encoding='utf-8').replace('\0', '')  # 執(zhí)行解密密并轉(zhuǎn)碼返回str
    return decrypted_text


if __name__ == '__main__':
    secret_key = '12345678'   # 密鑰
    text = 'I love Python!'   # 加密對(duì)象
    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

簡(jiǎn)介：英文名稱：Rivest Cipher 4，也稱為 ARC4 或 ARCFOUR闹蒜，是一種流加密算法绷落，密鑰長(zhǎng)度可變嘱函。它加解密使用相同的密鑰，因此也屬于對(duì)稱加密算法疏唾。RC4 是有線等效加密（WEP）中采用的加密算法槐脏，也曾經(jīng)是 TLS 可采用的算法之一顿天，該算法的速度可以達(dá)到 DES 加密的 10 倍左右蔑担，且具有很高級(jí)別的非線性啤握，雖然它在軟件方面的簡(jiǎn)單性和速度非常出色排抬，但在 RC4 中發(fā)現(xiàn)了多個(gè)漏洞蹲蒲，它特別容易受到攻擊，RC4 作為一種老舊的驗(yàn)證和加密算法易于受到黑客攻擊缘薛，現(xiàn)在逐漸不推薦使用了掩宜。

參考資料：

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

JavaScript 實(shí)現(xiàn)

// 引用 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 實(shí)現(xiàn)

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!'   # 加密對(duì)象
    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

簡(jiǎn)介：Rabbit 加密算法是一個(gè)高性能的流密碼加密方式辽旋，2003 年首次被提出檐迟，它從 128 位密鑰和 64 位初始向量（iv）創(chuàng)建一個(gè)密鑰流追迟。

參考資料：

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

JavaScript 實(shí)現(xiàn)

// 引用 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 實(shí)現(xiàn)

目前沒(méi)有找到有第三方庫(kù)可以直接實(shí)現(xiàn) Rabbit 算法敦间，在 Python 中實(shí)現(xiàn)可以參考：https://asecuritysite.com/encryption/rabbit2

RSA

簡(jiǎn)介：英文名稱：Rivest-Shamir-Adleman廓块，是 1977 年由羅納德·李維斯特（Ron Rivest）带猴、阿迪·薩莫爾（Adi Shamir）和倫納德·阿德曼（Leonard Adleman）一起提出的拴清，RSA 就是他們?nèi)诵帐祥_(kāi)頭字母拼在一起組成的，RSA 加密算法是一種非對(duì)稱加密算法娄周。在公開(kāi)密鑰加密和電子商業(yè)中RSA被廣泛使用昆咽。它被普遍認(rèn)為是目前比較優(yōu)秀的公鑰方案之一。RSA是第一個(gè)能同時(shí)用于加密和數(shù)字簽名的算法窟哺，它能夠抵抗到目前為止已知的所有密碼攻擊技肩。

參考資料：

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

JavaScript 實(shí)現(xiàn)

// 引用 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');    //導(dǎo)出公鑰
var privatekey = key.exportKey('pkcs8-private');  //導(dǎo)出私鑰
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 實(shí)現(xiàn)

模塊：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!'  # 加密對(duì)象
    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))  # 導(dǎo)入讀取到的公鑰
cipher = PKCS1_v1_5.new(rsa_key)                        # 生成對(duì)象
cipher_text = base64.b64encode(cipher.encrypt(data.encode(encoding="utf-8")))
print(cipher_text)