nodejs之 crypto-js模块，浏览器端加解密算法库
一、简介
CryptoJS是一个JavaScript加密算法库，用于实现各种加密算法和哈希函数。它提供了一种简单而强大的方式来执行加密操作，包括对称加密算法、非对称加密算法和哈希函数等。
CryptoJS支持的主要功能包括：
1.对称加密：CryptoJS提供了常见的对称加密算法，如AES（Advanced Encryption Standard）和DES（Data Encryption Standard）。这些算法使用相同的密钥进行加密和解密操作，适用于保护数据的机密性。
2.非对称加密：CryptoJS支持非对称加密算法，如RSA（Rivest-Shamir-Adleman）。非对称加密使用一对密钥，包括公钥和私钥，用于加密和解密数据。公钥用于加密数据，私钥用于解密数据，从而实现数据的机密性和身份认证。
3.哈希函数：CryptoJS提供了多种哈希函数，包括MD5、SHA-1、SHA-256等。哈希函数将任意长度的数据转换为固定长度的哈希值，用于数据完整性校验、密码存储和数字签名等应用。
4.加密模式：CryptoJS支持多种加密模式，如ECB（Electronic Codebook）、CBC（Cipher Block Chaining）和CTR（Counter）。这些模式定义了数据块如何被加密和连接在一起，以提供更强的安全性和数据保护。
CryptoJS易于使用，可以在浏览器环境和Node.js环境中使用。它提供了简洁的API，使开发人员能够轻松地执行加密和解密操作。使用CryptoJS，您可以在JavaScript中实现安全的数据传输、数据存储和身份验证等功能。
二、安装依赖
npm install crypto-js
三、加解密方法
- CryptoJS.AES 加解密，对称密钥加密算法
- CryptoJS.AES.encrypt(message, key, options)：使用AES算法对密文进行加密
- CryptoJS.AES.decrypt(ciphertext, key, options)：使用AES算法对密文进行解密，返回值需使用toString()转为字符串
‘’’
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：AES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：AES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
const cryptoJS = require('crypto-js')
const message = "Hello, World!";
const key = "ThisIsTheSecretKey";
const options = {
iv: cryptoJS.enc.Hex.parse('0000000000000000'), // 初始化向量为全零，初始化向量用于增加密码算法的安全性。16 字节的字节数组或WordArray 对象
mode: cryptoJS.mode.ECB, // 加密模式，默认为 ECB
padding: cryptoJS.pad.Pkcs7, // 加密模式，默认为 ECB
};
const encrypted = cryptoJS.AES.encrypt(message, key, options);// 进行 AES 加密
const ciphertext = encrypted.toString(); // 获取加密后的密文
console.log('加密密文：',ciphertext);
const decrypted = cryptoJS.AES.decrypt(ciphertext, key, options)
console.log('解密明文',decrypted.toString(cryptoJS.enc.Utf8))
- Crypto.DES加解密，对称密钥加密算法
- Crypto.DES.encrypt(message, key, options)：使用DES算法对密文进行加密
- Crypto.DES.decrypt(ciphertext, key, options)：使用DES算法对密文进行解密，返回值需使用toString()转为字符串
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const options = {
iv: cryptoJS.enc.Hex.parse('0000000000000000'), // 初始化向量为全零，初始化向量用于增加密码算法的安全性。16 字节的字节数组或WordArray 对象
mode: cryptoJS.mode.ECB, // 加密模式，默认为 ECB
padding: cryptoJS.pad.Pkcs7, // 加密模式，默认为 ECB
};
const encrypted = cryptoJS.DES.encrypt(message, key, options);
const ciphertext = encrypted.toString();
console.log('加密密文：', ciphertext);
const decrypted = cryptoJS.DES.decrypt(ciphertext, key, options);
console.log('解密明文：', decrypted.toString(cryptoJS.enc.Utf8))
- Crypto.TripleDES加解密，对称密钥加密算法，它是对经典的 DES（Data Encryption Standard）算法的改进和扩展。
- Crypto.TripleDES.encrypt(message, key, options)：使用TripleDES算法对密文进行加密
- Crypto.TripleDES.decrypt(ciphertext, key, options)：使用TripleDES算法对密文进行解密，返回值需使用toString()转为字符串
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const options = {
iv: cryptoJS.enc.Hex.parse('0000000000000000'), // 初始化向量为全零，初始化向量用于增加密码算法的安全性。16 字节的字节数组或WordArray 对象
mode: cryptoJS.mode.ECB, // 加密模式，默认为 ECB
padding: cryptoJS.pad.Pkcs7, // 加密模式，默认为 ECB
};
const encrypted = cryptoJS.TripleDES.encrypt(message, key, options);
const ciphertext = encrypted.toString();
console.log('加密密文：', ciphertext);
const decrypted = cryptoJS.TripleDES.decrypt(ciphertext, key, options);
console.log('解密明文：', decrypted.toString(cryptoJS.enc.Utf8))
- Crypto.Blowfish加解密，对称密钥加密算法，是一种分组密码，可以对固定长度的数据块进行加密和解密操作
- Crypto.Blowfish.encrypt(message, key,options)：使用Blowfish算法对密文进行加密
- Crypto.Blowfish.decrypt(ciphertext, key, options)：使用Blowfish算法对密文进行解密，返回值需使用toString()转为字符串
‘’’
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const options = {
iv: cryptoJS.enc.Hex.parse('0000000000000000'), // 初始化向量为全零，初始化向量用于增加密码算法的安全性。16 字节的字节数组或WordArray 对象
mode: cryptoJS.mode.ECB, // 加密模式，默认为 ECB
padding: cryptoJS.pad.Pkcs7, // 加密模式，默认为 ECB
};
const encrypted = cryptoJS.Blowfish.encrypt(message, key, options);
const ciphertext = encrypted.toString();
console.log('加密密文：', ciphertext);
const decrypted = cryptoJS.Blowfish.decrypt(ciphertext, key, options);
console.log('解密明文：', decrypted.toString(cryptoJS.enc.Utf8))
- Crypto.RC4加解密，流密码算法
- Crypto.RC4.encrypt(message, key,options)：使用RC4算法对密文进行加密
- Crypto.RC4.decrypt(ciphertext, key, options)：使用RC4算法对密文进行解密，返回值需使用toString()转为字符串
‘’’
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const options = {
iv: cryptoJS.enc.Hex.parse('0000000000000000'), // 初始化向量为全零，初始化向量用于增加密码算法的安全性。16 字节的字节数组或WordArray 对象
mode: cryptoJS.mode.ECB, // 加密模式，默认为 ECB
padding: cryptoJS.pad.Pkcs7, // 加密模式，默认为 ECB
};
const encrypted = cryptoJS.RC4.encrypt(message, key, options);
const ciphertext = encrypted.toString();
console.log('加密密文：', ciphertext);
const decrypted = cryptoJS.RC4.decrypt(ciphertext, key, options);
console.log('解密明文：', decrypted.toString(cryptoJS.enc.Utf8))
- Crypto.RC4Drop加解密，流密码算法，RC4 算法的一种改进
- Crypto.RC4Drop.encrypt(message, key,options)：使用RC4Drop算法对密文进行加密
- Crypto.RC4Drop.decrypt(ciphertext, key, options)：使用RC4Drop算法对密文进行解密，返回值需使用toString()转为字符串
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const options = {
iv: cryptoJS.enc.Hex.parse('0000000000000000'), // 初始化向量为全零，初始化向量用于增加密码算法的安全性。16 字节的字节数组或WordArray 对象
mode: cryptoJS.mode.ECB, // 加密模式，默认为 ECB
padding: cryptoJS.pad.Pkcs7, // 加密模式，默认为 ECB
};
const encrypted = cryptoJS.RC4Drop.encrypt(message, key, options);
const ciphertext = encrypted.toString();
console.log('加密密文：', ciphertext);
const decrypted = cryptoJS.RC4Drop.decrypt(ciphertext, key, options);
console.log('解密明文：', decrypted.toString(cryptoJS.enc.Utf8))
- Crypto.Rabbit加解密，流密码算法，用于加密和解密数据流
- Crypto.Rabbit.encrypt(message, key,options)：使用Rabbit算法对密文进行加密
- Crypto.Rabbit.decrypt(ciphertext, key, options)：使用Rabbit算法对密文进行解密，返回值需使用toString()转为字符串
‘’’
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const options = {
iv: cryptoJS.enc.Hex.parse('0000000000000000'), // 初始化向量为全零，初始化向量用于增加密码算法的安全性。16 字节的字节数组或WordArray 对象
mode: cryptoJS.mode.ECB, // 加密模式，默认为 ECB
padding: cryptoJS.pad.Pkcs7, // 加密模式，默认为 ECB
};
const encrypted = cryptoJS.Rabbit.encrypt(message, key, options);
const ciphertext = encrypted.toString();
console.log('加密密文：', ciphertext);
const decrypted = cryptoJS.Rabbit.decrypt(ciphertext, key, options);
console.log('解密明文：', decrypted.toString(cryptoJS.enc.Utf8))
- Crypto.RabbitLegacy加解密，流密码算法，Rabbit算法的一个变种
- Crypto.RabbitLegacy.encrypt(message, key,options)：使用RabbitLegacy算法对密文进行加密
- Crypto.RabbitLegacy.decrypt(ciphertext, key, options)：使用RRabbitLegacy算法对密文进行解密，返回值需使用toString()转为字符串
‘’’
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
ciphertext：DES加密密文
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
options（可选）：加密选项，如加密模式、填充方式等。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const options = {
iv: cryptoJS.enc.Hex.parse('0000000000000000'), // 初始化向量为全零，初始化向量用于增加密码算法的安全性。16 字节的字节数组或WordArray 对象
mode: cryptoJS.mode.ECB, // 加密模式，默认为 ECB
padding: cryptoJS.pad.Pkcs7, // 加密模式，默认为 ECB
};
const encrypted = cryptoJS.RabbitLegacy.encrypt(message, key, options);
const ciphertext = encrypted.toString();
console.log('加密密文：', ciphertext);
const decrypted = cryptoJS.RabbitLegacy.decrypt(ciphertext, key, options);
console.log('解密明文：', decrypted.toString(cryptoJS.enc.Utf8))
- CryptoJS.MD5(message)：计算给定消息的MD5哈希值，返回值需使用toString()转为字符串
'''
message：要计算哈希值的消息，字符串或者WordArray对象
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.MD5(message).toString())
console.log(cryptoJS.MD5(wordArray).toString())
- CryptoJS.SHA256(message)：计算给定消息的SHA-256哈希值，返回值需使用toString()转为字符串
'''
message：要计算哈希值的消息，字符串或者WordArray对象
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.SHA256(message).toString())
console.log(cryptoJS.SHA256(wordArray).toString())
- CryptoJS.SHA1(message)：计算给定消息的SHA-1哈希值，返回值需使用toString()转为字符串
'''
message：要计算哈希值的消息，字符串或者WordArray对象
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.SHA1(message).toString())
console.log(cryptoJS.SHA1(wordArray).toString())
- CryptoJS.SHA224(message)：计算给定消息的SHA-224哈希值，返回值需使用toString()转为字符串
'''
message：要计算哈希值的消息，字符串或者WordArray对象
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.SHA224(message).toString())
console.log(cryptoJS.SHA224(wordArray).toString())
- CryptoJS.SHA384(message)：计算给定消息的SHA-384哈希值，返回值需使用toString()转为字符串
'''
message：要计算哈希值的消息，字符串或者WordArray对象
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.SHA384(message).toString())
console.log(cryptoJS.SHA384(wordArray).toString())
- CryptoJS.SHA512(message)：计算给定消息的SHA-512哈希值，返回值需使用toString()转为字符串
'''
message：要计算哈希值的消息，字符串或者WordArray对象
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.SHA512(message).toString())
console.log(cryptoJS.SHA512(wordArray).toString())
- CryptoJS.SHA3(message)：计算给定消息的SHA-3哈希值，返回值需使用toString()转为字符串
'''
message：要计算哈希值的消息，字符串或者WordArray对象
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.SHA3(message).toString())
console.log(cryptoJS.SHA3(wordArray).toString())
- CryptoJS.RIPEMD160(message)：使用RIPEMD160哈希函数计算消息的哈希值。
'''
message：要计算哈希值的消息，字符串或者WordArray对象
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.RIPEMD160(message).toString())
console.log(cryptoJS.RIPEMD160(wordArray).toString())
- CryptoJS.HmacMD5(message, key)：使用HMAC（哈希消息认证码）算法和MD5哈希函数计算消息的哈希值。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacMD5(message,key).toString())
console.log(cryptoJS.HmacMD5(wordArray,key).toString())
- CryptoJS.HmacSHA1(message, key)：使用HMAC算法和SHA1哈希函数计算消息的哈希值。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacSHA1(message,key).toString())
console.log(cryptoJS.HmacSHA1(wordArray,key).toString())
- CryptoJS.HmacSHA256(message, key)：使用HMAC算法和SHA256哈希函数计算消息的哈希值。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacSHA256(message,key).toString())
console.log(cryptoJS.HmacSHA256(wordArray,key).toString())
- CryptoJS.HmacSHA224(message, key)：使用HMAC算法和SHA224哈希函数计算消息的哈希值。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacSHA224(message,key).toString())
console.log(cryptoJS.HmacSHA224(wordArray,key).toString())
- CryptoJS.HmacSHA512(message, key);：使用HMAC算法和SHA512哈希函数计算消息的哈希值。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacSHA512(message,key).toString())
console.log(cryptoJS.HmacSHA512(wordArray,key).toString())
- CryptoJS.HmacSHA384(message, key)：使用HMAC算法和SHA384哈希函数计算消息的哈希值。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacSHA384(message,key).toString())
console.log(cryptoJS.HmacSHA384(wordArray,key).toString())
- CryptoJS.HmacSHA3(message, key)：使用HMAC算法和SHA3哈希函数计算消息的哈希值。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacSHA3(message,key).toString())
console.log(cryptoJS.HmacSHA3(wordArray,key).toString())
- CryptoJS.HmacRIPEMD160(message, key)：使用HMAC算法和RIPEMD160哈希函数计算消息的哈希值。
'''
message：要加密的消息，可以是字符串或 WordArray 对象。
key：用于加密的密钥，可以是字符串、WordArray 对象或者一个包含字节的数组。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const key = "ThisIsTheSecretKey";
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacRIPEMD160(message,key).toString())
console.log(cryptoJS.HmacRIPEMD160(wordArray,key).toString())
- CryptoJS.PBKDF2(password, salt,options)：使用PBKDF2（密码基于密钥的派生函数）算法从密码和盐派生密钥，可以配合有密钥的算法，如：HmacMD5
'''
password：密码，作为生成密钥的输入。
salt：盐值，增加密码强度的随机值。
options：选项，包括密钥大小和迭代次数。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const password = 'myPassword';
const salt = 'somesalt';
const options = {
keySize: 256 / 32, // 生成的密钥长度（以字节为单位）
iterations: 1000, // 迭代次数
};
const key = cryptoJS.PBKDF2(password, salt, options).toString();// 生成密钥
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacMD5(message,key).toString())
console.log(cryptoJS.HmacMD5(wordArray,key).toString())
- CryptoJS.EvpKDF(password, salt,options)：使用EvpKDF（加密算法的密钥派生函数）从密码和盐派生密钥，可以配合有密钥的算法，如：HmacMD5
'''
password：密码，作为生成密钥的输入。
salt：盐值，增加密码强度的随机值。
options：选项，包括密钥大小和迭代次数。
'''
const cryptoJS = require('crypto-js')
const message = 'hello word';
const password = 'myPassword';
const salt = 'somesalt';
const options = {
keySize: 256 / 32, // 生成的密钥长度（以字节为单位）
iterations: 1000, // 迭代次数
};
const key = cryptoJS.EvpKDF(password, salt, options).toString();// 生成密钥
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
console.log(cryptoJS.HmacMD5(message,key).toString())
console.log(cryptoJS.HmacMD5(wordArray,key).toString())
四、cryptoJS.x64 是 CryptoJS 库中用于处理 64 位整数
64 位整数是由 64 个二进制位组成的整数类型，可以表示的范围是从 -9223372036854775808 到 9223372036854775807
- CryptoJS.x64.Word.create(high, low)：创建64 位整数的对象
'''
high：表示 64 位整数的高位
low：表示 64 位整数的低位
'''
const cryptoJS = require('crypto-js')
const high = 66051
const low = 67438087
cryptoJS.x64.Word.create(high, low)
- CryptoJS.x64.WordArray.create(words, sigBytes)：用给定的 64 位整数数组和字节数初始化一个 WordArray 对象
'''
words：CryptoJS.x64.Word数组
sigBytes：字节数的整数，指定字节数组的长度。
'''
const message = 'hello word';
const high1 = 66051
const low1 = 67438087
const high2 = 404298267
const low2 = 471670303
const wordArray = cryptoJS.x64.WordArray.create();
wordArray.init(message)
const wordArray1 = cryptoJS.x64.WordArray.create([
cryptoJS.x64.Word.create(high1, low1),
cryptoJS.x64.Word.create(high2, low2)
], 10);
wordArray1.init(message)
- CryptoJS.x64.WordArray.toX32()： 将 WordArray 对象转换为 32 位整数数组的形式
- CryptoJS.x64.WordArray.clone()：克隆一个 WordArray 对象
五、填充方式
- CryptoJS.pad.Pkcs7：使用 PKCS7 填充方式。这是最常用的填充方式，会在原始数据的末尾添加字节，使得数据长度符合加密算法的要求。
- CryptoJS.pad.AnsiX923：使用 ANSI X.923 填充方式。在原始数据的末尾添加字节，其中最后一个字节表示填充的长度。
- CryptoJS.pad.Iso10126：使用 ISO 10126 填充方式。在原始数据的末尾添加字节，其中最后一个字节表示填充的长度，其他填充字节为随机值。
- CryptoJS.pad.Iso97971：使用 ISO/IEC 9797-1 填充方式。在原始数据的末尾添加字节，其中所有填充字节都为 0x00。
- CryptoJS.pad.ZeroPadding：使用零填充方式。在原始数据的末尾添加字节，使得数据长度符合加密算法的要求，填充字节都为 0x00。
- CryptoJS.pad.NoPadding：不进行填充。如果原始数据的长度不符合加密算法的要求，会抛出异常。
六、加密模式
- CryptoJS.mode.CBC：使用 CBC (Cipher-Block Chaining) 模式。在 CBC 模式中，每个明文块会与前一个密文块进行异或操作，然后再进行加密。
- CryptoJS.mode.CFB：使用 CFB (Cipher Feedback) 模式。在 CFB 模式中，前一个密文块会被加密，然后与当前的明文块进行异或操作，得到当前的密文块。
- CryptoJS.mode.CTR：使用 CTR (Counter) 模式。在 CTR 模式中，通过使用一个计数器和密钥生成密钥流，然后将密钥流与明文进行异或操作，得到密文。
- CryptoJS.mode.CTRGladman：Gladman 版本的 CTR 模式。它是 CryptoJS 库中的一个特殊实现，与标准的 CTR 模式略有不同。
- CryptoJS.mode.OFB：使用 OFB (Output Feedback) 模式。在 OFB 模式中，通过使用一个初始化向量和密钥生成密钥流，然后将密钥流与明文进行异或操作，得到密文。
- CryptoJS.mode.ECB：使用 ECB (Electronic Codebook) 模式。在 ECB 模式中，每个明文块都会被独立加密，没有前后依赖关系。
七、编码
- Crypto.enc.Hex.stringify(wordArray): 将 CryptoJS 编码的数据转换为十六进制字符串，返回字符串
- Crypto.enc.Hex.parse(hexStr): 将十六进制字符串转换为 CryptoJS 编码的数据，返回WordArray对象
- Crypto.enc.Latin1.stringify(wordArray): 将 CryptoJS 编码的数据转换为 Latin-1 字符串（ISO-8859-1），返回字符串
- Crypto.enc.Latin1.parse(latin1Str): 将 Latin-1 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
- Crypto.enc.Utf8.stringify(wordArray): 将 CryptoJS 编码的数据转换为 UTF-8 字符串，返回字符串
- Crypto.enc.Utf8.parse(utf8Str): 将 UTF-8 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
- Crypto.enc.Utf16BE.stringify(wordArray): 将 CryptoJS 编码的数据转换为大端序（Big Endian）UTF-16 字符串，返回字符串
- Crypto.enc.Utf16BE.parse(utf16BEStr): 将大端序（Big Endian）UTF-16 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
- Crypto.enc.Utf16.stringify(wordArray): 将 CryptoJS 编码的数据转换为平台字节序（Platform Endian）UTF-16 字符串，返回字符串
- Crypto.enc.Utf16.parse(utf16Str): 将平台字节序（Platform Endian）UTF-16 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
- Crypto.enc.Utf16LE.stringify(wordArray): 将 CryptoJS 编码的数据转换为小端序（Little Endian）UTF-16 字符串，返回字符串
- Crypto.enc.Utf16LE.parse(utf16LEStr): 将小端序（Little Endian）UTF-16 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
- Crypto.enc.Base64.stringify(wordArray): 将 CryptoJS 编码的数据转换为 Base64 字符串，返回字符串
- Crypto.enc.Base64.parse(base64Str): 将 Base64 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
- Crypto.enc.Base64url.stringify(wordArray): 将 CryptoJS 编码的数据转换为 Base64 URL 安全字符串，返回字符串
- Crypto.enc.Base64url.parse(base64urlStr): 将 Base64 URL 安全字符串转换为 CryptoJS 编码的数据，返回WordArray对象