nodejs之 crypto-js模块，浏览器端加解密算法库_cryptojs

一、简介

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
1

三、加解密方法

1. 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))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2. 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3. 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4. 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

5. 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

6. 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

7. 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

8. 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

9. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14

10. 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())
1
2
3
4
5
6
7
8
9
10
11
12

11. 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())
1
2
3
4
5
6
7
8
9
10
11
12

12. 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())
1
2
3
4
5
6
7
8
9
10
11
12

13. 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())
1
2
3
4
5
6
7
8
9
10
11
12

14. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13

15. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13

16. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13

17. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14

18. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14

19. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14

20. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14

21. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14

22. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14

23. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14

24. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

25. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

26. 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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

四、cryptoJS.x64 是 CryptoJS 库中用于处理 64 位整数

64 位整数是由 64 个二进制位组成的整数类型，可以表示的范围是从 -9223372036854775808 到 9223372036854775807

1. 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)
1
2
3
4
5
6
7
8
9

2. 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3. CryptoJS.x64.WordArray.toX32()： 将 WordArray 对象转换为 32 位整数数组的形式
4. CryptoJS.x64.WordArray.clone()：克隆一个 WordArray 对象

五、填充方式

1. CryptoJS.pad.Pkcs7：使用 PKCS7 填充方式。这是最常用的填充方式，会在原始数据的末尾添加字节，使得数据长度符合加密算法的要求。
2. CryptoJS.pad.AnsiX923：使用 ANSI X.923 填充方式。在原始数据的末尾添加字节，其中最后一个字节表示填充的长度。
3. CryptoJS.pad.Iso10126：使用 ISO 10126 填充方式。在原始数据的末尾添加字节，其中最后一个字节表示填充的长度，其他填充字节为随机值。
4. CryptoJS.pad.Iso97971：使用 ISO/IEC 9797-1 填充方式。在原始数据的末尾添加字节，其中所有填充字节都为 0x00。
5. CryptoJS.pad.ZeroPadding：使用零填充方式。在原始数据的末尾添加字节，使得数据长度符合加密算法的要求，填充字节都为 0x00。
6. CryptoJS.pad.NoPadding：不进行填充。如果原始数据的长度不符合加密算法的要求，会抛出异常。

六、加密模式

1. CryptoJS.mode.CBC：使用 CBC (Cipher-Block Chaining) 模式。在 CBC 模式中，每个明文块会与前一个密文块进行异或操作，然后再进行加密。
2. CryptoJS.mode.CFB：使用 CFB (Cipher Feedback) 模式。在 CFB 模式中，前一个密文块会被加密，然后与当前的明文块进行异或操作，得到当前的密文块。
3. CryptoJS.mode.CTR：使用 CTR (Counter) 模式。在 CTR 模式中，通过使用一个计数器和密钥生成密钥流，然后将密钥流与明文进行异或操作，得到密文。
4. CryptoJS.mode.CTRGladman：Gladman 版本的 CTR 模式。它是 CryptoJS 库中的一个特殊实现，与标准的 CTR 模式略有不同。
5. CryptoJS.mode.OFB：使用 OFB (Output Feedback) 模式。在 OFB 模式中，通过使用一个初始化向量和密钥生成密钥流，然后将密钥流与明文进行异或操作，得到密文。
6. CryptoJS.mode.ECB：使用 ECB (Electronic Codebook) 模式。在 ECB 模式中，每个明文块都会被独立加密，没有前后依赖关系。

七、编码

1. Crypto.enc.Hex.stringify(wordArray): 将 CryptoJS 编码的数据转换为十六进制字符串，返回字符串
2. Crypto.enc.Hex.parse(hexStr): 将十六进制字符串转换为 CryptoJS 编码的数据，返回WordArray对象
3. Crypto.enc.Latin1.stringify(wordArray): 将 CryptoJS 编码的数据转换为 Latin-1 字符串（ISO-8859-1），返回字符串
4. Crypto.enc.Latin1.parse(latin1Str): 将 Latin-1 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
5. Crypto.enc.Utf8.stringify(wordArray): 将 CryptoJS 编码的数据转换为 UTF-8 字符串，返回字符串
6. Crypto.enc.Utf8.parse(utf8Str): 将 UTF-8 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
7. Crypto.enc.Utf16BE.stringify(wordArray): 将 CryptoJS 编码的数据转换为大端序（Big Endian）UTF-16 字符串，返回字符串
8. Crypto.enc.Utf16BE.parse(utf16BEStr): 将大端序（Big Endian）UTF-16 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
9. Crypto.enc.Utf16.stringify(wordArray): 将 CryptoJS 编码的数据转换为平台字节序（Platform Endian）UTF-16 字符串，返回字符串
10. Crypto.enc.Utf16.parse(utf16Str): 将平台字节序（Platform Endian）UTF-16 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
11. Crypto.enc.Utf16LE.stringify(wordArray): 将 CryptoJS 编码的数据转换为小端序（Little Endian）UTF-16 字符串，返回字符串
12. Crypto.enc.Utf16LE.parse(utf16LEStr): 将小端序（Little Endian）UTF-16 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
13. Crypto.enc.Base64.stringify(wordArray): 将 CryptoJS 编码的数据转换为 Base64 字符串，返回字符串
14. Crypto.enc.Base64.parse(base64Str): 将 Base64 字符串转换为 CryptoJS 编码的数据，返回WordArray对象
15. Crypto.enc.Base64url.stringify(wordArray): 将 CryptoJS 编码的数据转换为 Base64 URL 安全字符串，返回字符串
16. Crypto.enc.Base64url.parse(base64urlStr): 将 Base64 URL 安全字符串转换为 CryptoJS 编码的数据，返回WordArray对象