小福利，常见加密算法

常见加密算法：

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)