CryptoJS (crypto.js) 为 JavaScript 提供了各种各样的加密算法，由于它使用起来稍微有些复杂。所以本文主要着重说一下CryptoJS进行MD5/SHA256/BASE64/AES加解密的方法与示例。
Crypto-JS的几种加密方式
CryptoJS (crypto.js) 为 JavaScript 提供了各种各样的加密算法。
crypto-js/core
crypto-js/x64-core
crypto-js/lib-typedarrays
crypto-js/md5
crypto-js/sha1
crypto-js/sha256
crypto-js/sha224
crypto-js/sha512
crypto-js/sha384
crypto-js/sha3
crypto-js/ripemd160
crypto-js/hmac-md5
crypto-js/hmac-sha1
crypto-js/hmac-sha256
crypto-js/hmac-sha224
crypto-js/hmac-sha512
crypto-js/hmac-sha384
crypto-js/hmac-sha3
crypto-js/hmac-ripemd160
crypto-js/pbkdf2
crypto-js/aes
crypto-js/tripledes
crypto-js/rc4
crypto-js/rabbit
crypto-js/rabbit-legacy
crypto-js/evpkdf
crypto-js/format-openssl
crypto-js/format-hex
crypto-js/enc-latin1
crypto-js/enc-utf8
crypto-js/enc-hex
crypto-js/enc-utf16
crypto-js/enc-base64
crypto-js/mode-cfb
crypto-js/mode-ctr
crypto-js/mode-ctr-gladman
crypto-js/mode-ofb
crypto-js/mode-ecb
crypto-js/pad-pkcs7
crypto-js/pad-ansix923
crypto-js/pad-iso10126
crypto-js/pad-iso97971
crypto-js/pad-zeropadding
crypto-js/pad-nopaddingHMAC 系列是消息验证，用于验证一个消息是否被篡改——如网站上传递 email 和 hmac(email)，则接收时可以通过 hmac(email) 获知 email 是否是用户伪造的
MD5、SHA1、SHA256、SHA224、SHA512、SHA384、SHA3、RIPEMD160 等哈希算法是不可逆的，即无法从哈希值反推出原始数据。
HMAC、PBKDF2、EvpKDF 等算法是基于哈希算法的消息认证码算法，也是不可逆的。
AES、DES、TripleDES、RC4、RC4Drop、Rabbit、RabbitLegacy 等对称加密算法是可逆的，即可以通过密钥将密文解密为明文。
非对称加密算法如 RSA、DSA、Diffie-Hellman 等也是可逆的，但是在加密和解密时使用的是不同的密钥。
Crypto-js库MD5加密方法
MD5是一种常用的哈希算法，不可逆。用于将任意长度的消息压缩成一个128位的摘要。MD5算法具有以下特点：
压缩性：任意长度的消息都可以被压缩成一个128位的摘要。
容易计算：MD5算法的计算速度比较快，适用于对大量数据进行哈希计算。
抗修改性：对原始数据进行任何修改，都会导致哈希值的变化。
抗碰撞性：对不同的原始数据，哈希值相同的概率非常小。以下是使用Node.js实现MD5算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function md5(str) {
const hash = crypto.createHash(‘md5’);
hash.update(str);
return hash.digest(‘hex’);
}
console.log(md5(‘hello world’));
/*
1 ==> c4ca4238a0b923820dcc509a6f75849b
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个md5函数，用于计算MD5摘要。函数接受一个参数：str 表示要计算摘要的字符串。在计算摘要时，我们首先创建一个md5哈希对象，然后使用 update 方法向对象中添加要计算摘要的数据，最后使用 digest 方法计算摘要并返回。在上面的示例中，我们计算了字符串’hello world’的MD5摘要，并输出了结果。
Crypto-js库SHA1加密方法
SHA1是一种常用的哈希算法，用于将任意长度的消息压缩成一个160位的摘要。SHA1算法具有以下特点：
压缩性：任意长度的消息都可以被压缩成一个160位的摘要。
容易计算：SHA1算法的计算速度比较快，适用于对大量数据进行哈希计算。
抗修改性：对原始数据进行任何修改，都会导致哈希值的变化。
抗碰撞性：对不同的原始数据，哈希值相同的概率非常小。以下是使用Node.js实现SHA1算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function sha1(str) {
const hash = crypto.createHash(‘sha1’);
hash.update(str);
return hash.digest(‘hex’);
}
console.log(sha1(‘hello world’));
/*
1 ==> 356a192b7913b04c54574d18c28d46e6395428ab
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个 sha1 函数，用于计算 SHA1 摘要。函数接受一个参数：str表示要计算摘要的字符串。在计算摘要时，我们首先创建一个sha1哈希对象，然后使用update方法向对象中添加要计算摘要的数据，最后使用digest方法计算摘要并返回。在上面的示例中，我们计算了字符串’hello world’的SHA1摘要，并输出了结果。
Crypto-js库SHA256加密方法
SHA256是一种常用的哈希算法，用于将任意长度的消息压缩成一个256位的摘要。SHA256算法具有以下特点：
压缩性：任意长度的消息都可以被压缩成一个256位的摘要。
容易计算：SHA256算法的计算速度比较快，适用于对大量数据进行哈希计算。
抗修改性：对原始数据进行任何修改，都会导致哈希值的变化。
抗碰撞性：对不同的原始数据，哈希值相同的概率非常小。以下是使用Node.js实现SHA256算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function sha256(str) {
const hash = crypto.createHash(‘sha256’);
hash.update(str);
return hash.digest(‘hex’);
}
console.log(sha256(‘hello world’));
/*
1 ==> 6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个sha256函数，用于计算SHA256摘要。函数接受一个参数：str表示要计算摘要的字符串。在计算摘要时，我们首先创建一个sha256哈希对象，然后使用update方法向对象中添加要计算摘要的数据，最后使用digest方法计算摘要并返回。在上面的示例中，我们计算了字符串’hello world’的SHA256摘要，并输出了结果。
Crypto-js库SHA224加密方法
SHA224是一种常用的哈希算法，用于将任意长度的消息压缩成一个224位的摘要。SHA224算法具有以下特点：
压缩性：任意长度的消息都可以被压缩成一个224位的摘要。
容易计算：SHA224算法的计算速度比较快，适用于对大量数据进行哈希计算。
抗修改性：对原始数据进行任何修改，都会导致哈希值的变化。
抗碰撞性：对不同的原始数据，哈希值相同的概率非常小。以下是使用Node.js实现SHA224算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function sha224(str) {
const hash = crypto.createHash(‘sha224’);
hash.update(str);
return hash.digest(‘hex’);
}
console.log(sha224(‘hello world’));
/*
1 ==> e25388fde8290dc286a6164fa2d97e551b53498dcbf7bc378eb1f178
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个sha224函数，用于计算SHA224摘要。函数接受一个参数：str表示要计算摘要的字符串。在计算摘要时，我们首先创建一个sha224哈希对象，然后使用update方法向对象中添加要计算摘要的数据，最后使用digest方法计算摘要并返回。在上面的示例中，我们计算了字符串’hello world’的SHA224摘要，并输出了结果。
Crypto-js库SHA512加密方法
SHA512是一种常用的哈希算法，用于将任意长度的消息压缩成一个512位的摘要。SHA512算法具有以下特点：
压缩性：任意长度的消息都可以被压缩成一个512位的摘要。
容易计算：SHA512算法的计算速度比较快，适用于对大量数据进行哈希计算。
抗修改性：对原始数据进行任何修改，都会导致哈希值的变化。
抗碰撞性：对不同的原始数据，哈希值相同的概率非常小。以下是使用Node.js实现SHA512算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function sha512(str) {
const hash = crypto.createHash(‘sha512’);
hash.update(str);
return hash.digest(‘hex’);
}
console.log(sha512(‘hello world’));
/*
1 ==> 4dff4ea340f0a823f15d3f4f01ab62eae0e5da579ccb851f8db9dfe84c58b2b37b89903a740e1ee172da793a6e79d560e5f7f9bd058a12a280433ed6fa46510a
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个sha512函数，用于计算SHA512摘要。函数接受一个参数：str表示要计算摘要的字符串。在计算摘要时，我们首先创建一个sha512哈希对象，然后使用update方法向对象中添加要计算摘要的数据，最后使用digest方法计算摘要并返回。在上面的示例中，我们计算了字符串’hello world’的SHA512摘要，并输出了结果。
Crypto-js库SHA384加密方法
SHA384是一种常用的哈希算法，用于将任意长度的消息压缩成一个384位的摘要。SHA384算法具有以下特点：
压缩性：任意长度的消息都可以被压缩成一个384位的摘要。
容易计算：SHA384算法的计算速度比较快，适用于对大量数据进行哈希计算。
抗修改性：对原始数据进行任何修改，都会导致哈希值的变化。
抗碰撞性：对不同的原始数据，哈希值相同的概率非常小。以下是使用Node.js实现SHA384算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function sha384(str) {
const hash = crypto.createHash(‘sha384’);
hash.update(str);
return hash.digest(‘hex’);
}
console.log(sha384(‘hello world’));
/*
1 ==> 47f05d367b0c32e438fb63e6cf4a5f35c2aa2f90dc7543f8a41a0f95ce8a40a313ab5cf36134a2068c4c969cb50db776
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个sha384函数，用于计算SHA384摘要。函数接受一个参数：str表示要计算摘要的字符串。在计算摘要时，我们首先创建一个sha384哈希对象，然后使用update方法向对象中添加要计算摘要的数据，最后使用digest方法计算摘要并返回。在上面的示例中，我们计算了字符串’hello world’的SHA384摘要，并输出了结果。
Crypto-js库SHA3加密方法
SHA3是一种常用的哈希算法，用于将任意长度的消息压缩成一个固定长度的摘要。SHA3算法具有以下特点：
压缩性：任意长度的消息都可以被压缩成一个固定长度的摘要。
容易计算：SHA3算法的计算速度比较快，适用于对大量数据进行哈希计算。
抗修改性：对原始数据进行任何修改，都会导致哈希值的变化。
抗碰撞性：对不同的原始数据，哈希值相同的概率非常小。以下是使用Node.js实现SHA3算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function sha3(str) {
const hash = crypto.createHash(‘sha3-256’);
hash.update(str);
return hash.digest(‘hex’);
}
console.log(sha3(‘hello world’));
/*
1 ==> 67b176705b46206614219f47a05aee7ae6a3edbe850bbbe214c536b989aea4d2
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个sha3函数，用于计算SHA3摘要。函数接受一个参数：str表示要计算摘要的字符串。在计算摘要时，我们首先创建一个sha3哈希对象，然后使用update方法向对象中添加要计算摘要的数据，最后使用digest方法计算摘要并返回。在上面的示例中，我们计算了字符串’hello world’的SHA3摘要，并输出了结果。
Crypto-js库RIPEMD160加密方法
RIPEMD160是一种常用的哈希算法，用于将任意长度的消息压缩成一个160位的摘要。RIPEMD160算法具有以下特点：
压缩性：任意长度的消息都可以被压缩成一个160位的摘要。
容易计算：RIPEMD160算法的计算速度比较快，适用于对大量数据进行哈希计算。
抗修改性：对原始数据进行任何修改，都会导致哈希值的变化。
抗碰撞性：对不同的原始数据，哈希值相同的概率非常小。以下是使用Node.js实现RIPEMD160算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function ripemd160(str) {
const hash = crypto.createHash(‘ripemd160’);
hash.update(str);
return hash.digest(‘hex’);
}
console.log(ripemd160(‘hello world’));
/*
1 ==> c47907abd2a80492ca9388b05c0e382518ff3960
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个ripemd160函数，用于计算RIPEMD160摘要。函数接受一个参数：str表示要计算摘要的字符串。在计算摘要时，我们首先创建一个ripemd160哈希对象，然后使用update方法向对象中添加要计算摘要的数据，最后使用digest方法计算摘要并返回。在上面的示例中，我们计算了字符串’hello world’的RIPEMD160摘要，并输出了结果。
Crypto-js库HMAC加密方法
HMAC是一种常用的消息认证码算法，用于验证消息的完整性和真实性。HMAC算法的全称是“基于哈希函数的消息认证码”（Hash-based Message Authentication Code），它通过在原始数据上附加一个密钥，然后对附加了密钥的数据进行哈希计算，最后将哈希值作为认证码。HMAC算法具有以下特点：
安全性高：HMAC算法使用密钥对原始数据进行加密，可以有效防止数据被篡改。
灵活性强：HMAC算法可以使用多种哈希函数，如SHA256、SHA512等。
计算速度快：HMAC算法的计算速度比较快，适用于对大量数据进行认证计算。以下是使用Node.js实现HMAC算法的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const crypto = require(‘crypto’);
function hmac(key, str) {
const hmac = crypto.createHmac(‘sha256’, key);
hmac.update(str);
return hmac.digest(‘hex’);
}
console.log(hmac(‘secret’, ‘hello world’));
/*
hmac(‘密钥’, ‘需要计算认证码的字符串’) ==> 9964da4845db286e4df728b0b106aafb8d87b3d52867f63d0ac925c52759eeb0
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个hmac函数，用于计算HMAC认证码。函数接受两个参数：key表示密钥，str表示要计算认证码的字符串。在计算认证码时，我们首先创建一个HMAC哈希对象，然后使用update方法向对象中添加要计算认证码的数据，最后使用digest方法计算认证码并返回。在上面的示例中，我们使用密钥’secret’对字符串’hello world’进行HMAC认证，并输出了结果。
Crypto-js库PBKDF2加密方法
PBKDF2是一种常用的密码加密算法，用于将用户密码转换成一个固定长度的密钥。PBKDF2算法的全称是“基于密码的密钥派生函数”（Password-Based Key Derivation Function），它通过在用户密码上附加一个随机盐值，然后对附加了盐值的密码进行多次哈希计算，最后将计算结果作为密钥。PBKDF2算法具有以下特点：
安全性高：PBKDF2算法使用随机盐值和多次哈希计算，可以有效防止密码被破解。
灵活性强：PBKDF2算法可以使用多种哈希函数，如SHA256、SHA512等。
计算速度慢：PBKDF2算法的计算速度比较慢，适用于对密码进行加密计算。以下是使用Node.js实现PBKDF2算法的示例代码：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
const crypto = require(‘crypto’);
function pbkdf2(password, salt, iterations, keylen, digest) {
return new Promise((resolve, reject) => {
crypto.pbkdf2(password, salt, iterations, keylen, digest, (err, derivedKey) => {
if (err) {
reject(err);
} else {
resolve(derivedKey.toString(‘hex’));
}
});
});
}
const password = ‘password’;
const salt = crypto.randomBytes(16).toString(‘hex’);
const iterations = 100000;
const keylen = 32;
const digest = ‘sha256’;
pbkdf2(password, salt, iterations, keylen, digest)
.then((key) => {
console.log(密码: ${password});
console.log(盐值: ${salt});
console.log(迭代次数: ${iterations});
console.log(密钥长度: ${keylen});
console.log(哈希算法: ${digest});
console.log(转换后的密钥: ${key});
})
.catch((err) => {
console.error(err);
});
/*
const password = ‘123’;
const salt = ‘123’;
const iterations = 123;
const keylen = 123;
const digest = ‘sha256’;
==>
密码: 123
盐值: 123
迭代次数: 123
密钥长度: 123
哈希算法: sha256
转换后的密钥: af878c22b0663114e3a74345bccb9a95d074ec4b4325320489d8a312f9dda8f5a7f79291a18e866777324a2bf01add1fd747ea198ceaa468c9f7188a80523dda60dc27f9136691c8f0aee031d14475ce1e7946b29f47cc0d8c0ff7f8d411631b5f2f8ac442b87c79b19e382bad19cd07709207b1e536d3f510d88d
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个pbkdf2函数，用于将密码转换为密钥。这个函数接受五个参数：password表示要转换的密码，salt表示盐值，iterations表示迭代次数，keylen表示密钥长度，digest表示哈希算法。在函数内部，我们使用crypto.pbkdf2方法将密码转换为密钥，并将密钥转换为十六进制字符串。最后，我们使用Promise对象返回密钥。在主函数中，我们定义了password、salt、iterations、keylen和digest等参数，并调用pbkdf2函数将密码转换为密钥。最后，我们输出了转换前的密码、盐值、迭代次数、密钥长度、哈希算法和转换后的密钥。
Crypto-js库EvpKDF加密方法
EvpKDF是一种常用的密码加密算法，用于将用户密码转换成一个固定长度的密钥。EvpKDF算法的全称是“基于密码的密钥派生函数”（Password-Based Key Derivation Function），它通过在用户密码上附加一个随机盐值，然后对附加了盐值的密码进行多次哈希计算，最后将计算结果作为密钥。EvpKDF算法具有以下特点：
安全性高：EvpKDF算法使用随机盐值和多次哈希计算，可以有效防止密码被破解。
灵活性强：EvpKDF算法可以使用多种哈希函数，如SHA256、SHA512等。
计算速度慢：EvpKDF算法的计算速度比较慢，适用于对密码进行加密计算。以下是使用Node.js实现EvpKDF算法的示例代码：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
const crypto = require(‘crypto’);
function evpKDF(password, salt, keylen, iterations, digest) {
return new Promise((resolve, reject) => {
crypto.pbkdf2(password, salt, iterations, keylen, digest, (err, derivedKey) => {
if (err) {
reject(err);
} else {
resolve(derivedKey.toString(‘hex’));
}
});
});
}
const password = ‘password’;
const salt = crypto.randomBytes(16).toString(‘hex’);
const keylen = 32;
const iterations = 100000;
const digest = ‘sha256’;
evpKDF(password, salt, keylen, iterations, digest)
.then((key) => {
console.log(密码: ${password});
console.log(盐值: ${salt});
console.log(密钥长度: ${keylen});
console.log(迭代次数: ${iterations});
console.log(哈希算法: ${digest});
console.log(转换后的密钥: ${key});
})
.catch((err) => {
console.error(err);
});
/*
const password = ‘123’;
const salt = ‘123’;
const keylen = 132;
const iterations = 100000;
const digest = ‘sha256’;
==>
密码: 123
盐值: 123
密钥长度: 132
迭代次数: 100000
哈希算法: sha256
转换后的密钥: 67a7a835eb2787fb9578f9082821d89039426f4ae66d64e534d4285ed83586199865d28fddc5dca5e49e14023dca614715556e2f8e88523640e91698cb47ff59542d47cdeb25f83b830f5b8918c78854fd8210f0f40ce7164618ed335a61b32c0d14cb3f862e720686466ea9069bb071e5c1d7eef984baf8b64799a222cf14275e4e1612
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了一个evpKDF函数，用于将密码转换为密钥。这个函数接受五个参数：password表示要转换的密码，salt表示盐值，keylen表示密钥长度，iterations表示迭代次数，digest表示哈希算法。在函数内部，我们使用crypto.pbkdf2方法将密码转换为密钥，并将密钥转换为十六进制字符串。最后，我们使用Promise对象返回密钥。在主函数中，我们定义了password、salt、keylen、iterations和digest等参数，并调用evpKDF函数将密码转换为密钥。最后，我们输出了转换前的密码、盐值、密钥长度、迭代次数、哈希算法和转换后的密钥。
Crypto-js库AES加密方法
AES是一种常用的对称加密算法，用于对数据进行加密和解密。AES算法的全称是“高级加密标准”（Advanced Encryption Standard），它使用固定长度的密钥对数据进行加密和解密，密钥长度可以是128位、192位或256位。AES算法具有以下特点：
安全性高：AES算法使用固定长度的密钥进行加密和解密，可以有效防止数据被破解。
灵活性强：AES算法可以使用多种密钥长度，如128位、192位或256位。
计算速度快：AES算法的计算速度比较快，适用于对大量数据进行加密和解密。以下是使用Node.js实现AES算法的示例代码：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
const crypto = require(‘crypto’);
function aesEncrypt(data, key, iv) {
const cipher = crypto.createCipheriv(‘aes-256-cbc’, key, iv);
let encrypted = cipher.update(data, ‘utf8’, ‘hex’);
encrypted += cipher.final(‘hex’);
return encrypted;
}
function aesDecrypt(encrypted, key, iv) {
const decipher = crypto.createDecipheriv(‘aes-256-cbc’, key, iv);
let decrypted = decipher.update(encrypted, ‘hex’, ‘utf8’);
decrypted += decipher.final(‘utf8’);
return decrypted;
}
const data = ‘hello world’;
const key = crypto.randomBytes(32); // 密钥，一个 Buffer 类
const iv = crypto.randomBytes(16); // 初始化向量，一个 Buffer 类
const encrypted = aesEncrypt(data, key, iv);
const decrypted = aesDecrypt(encrypted, key, iv);
console.log(原始数据: ${data});
console.log(密钥: ${key});
console.log(初始化向量: ${iv});
console.log(加密后的数据: ${encrypted});
console.log(解密后的数据: ${decrypted});
/*
const data = ‘1’;
const key = Buffer.from(‘01234567890123456789012345678901’, ‘utf-8’);
const iv = Buffer.from(‘0123456789012345’, ‘utf-8’);
const encrypted = aesEncrypt(data, key, iv);
const decrypted = aesDecrypt(encrypted, key, iv);
==>
原始数据: 1
密钥: 01234567890123456789012345678901
初始化向量: 0123456789012345
加密后的数据: 8fa6aaeb56062010a71b3750cc337fe5
解密后的数据: 1
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了两个函数：aesEncrypt和aesDecrypt，分别用于对数据进行加密和解密。这两个函数接受三个参数：data表示要加密或解密的数据，key表示密钥，iv表示初始化向量。在加密和解密时，我们使用createCipheriv和createDecipheriv方法创建AES加密或解密对象，然后使用update方法向对象中添加要加密或解密的数据。最后，我们使用final方法获取加密或解密后的数据。在主函数中，我们定义了data、key和iv等参数，并调用aesEncrypt函数将数据加密，然后调用aesDecrypt函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
Crypto-js库DES加密方法
DES是一种常用的对称加密算法，用于对数据进行加密和解密。DES算法的全称是“数据加密标准”（Data Encryption Standard），它使用固定长度的密钥对数据进行加密和解密，密钥长度为64位。但是由于DES算法的密钥强度较弱，因此现在已经不再推荐使用。DES算法具有以下特点：
安全性较低：DES算法使用固定长度的密钥进行加密和解密，密钥长度较短，容易被破解。
灵活性较差：DES算法只能使用64位的密钥长度，不够灵活。
计算速度较快：DES算法的计算速度比较快，适用于对大量数据进行加密和解密。以下是使用Node.js实现DES算法的示例代码：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
const crypto = require(‘crypto’);
function desEncrypt(data, key, iv) {
const cipher = crypto.createCipheriv(‘des-cbc’, key, iv);
let encrypted = cipher.update(data, ‘utf8’, ‘hex’);
encrypted += cipher.final(‘hex’);
return encrypted;
}
function desDecrypt(encrypted, key, iv) {
const decipher = crypto.createDecipheriv(‘des-cbc’, key, iv);
let decrypted = decipher.update(encrypted, ‘hex’, ‘utf8’);
decrypted += decipher.final(‘utf8’);
return decrypted;
}
const data = ‘hello world’;
const key = crypto.randomBytes(8); // 密钥，一个 Buffer 类
const iv = crypto.randomBytes(8); // 初始化向量，一个 Buffer 类
const encrypted = desEncrypt(data, key, iv);
const decrypted = desDecrypt(encrypted, key, iv);
console.log(原始数据: ${data});
console.log(密钥: ${key});
console.log(初始化向量: ${iv});
console.log(加密后的数据: ${encrypted});
console.log(解密后的数据: ${decrypted});
/*
const data = ‘1’;
const key = Buffer.from(‘12345678’, ‘utf-8’);
const iv = Buffer.from(‘12345678’, ‘utf-8’);
const encrypted = desEncrypt(data, key, iv);
const decrypted = desDecrypt(encrypted, key, iv);
==>
原始数据: 1
密钥: 12345678
初始化向量: 12345678
加密后的数据: db7d5df1fd65aa2f
解密后的数据: 1
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了两个函数：desEncrypt和desDecrypt，分别用于对数据进行加密和解密。这两个函数接受三个参数：data表示要加密或解密的数据，key表示密钥，iv表示初始化向量。在加密和解密时，我们使用createCipheriv和createDecipheriv方法创建DES加密或解密对象，然后使用update方法向对象中添加要加密或解密的数据。最后，我们使用final方法获取加密或解密后的数据。在主函数中，我们定义了data、key和iv等参数，并调用desEncrypt函数将数据加密，然后调用desDecrypt函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
Crypto-js库TripleDES加密方法
TripleDES是一种常用的对称加密算法，用于对数据进行加密和解密。TripleDES算法的全称是“三重数据加密标准”（Triple Data Encryption Standard），它使用固定长度的密钥对数据进行加密和解密，密钥长度为192位。TripleDES算法具有以下特点：
安全性较高：TripleDES算法使用三个不同的密钥进行加密和解密，密钥长度较长，安全性较高。
灵活性较差：TripleDES算法只能使用168位的密钥长度，不够灵活。
计算速度较慢：TripleDES算法的计算速度比较慢，适用于对数据进行加密和解密。以下是使用Node.js实现TripleDES算法的示例代码：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
const crypto = require(‘crypto’);
function tripleDesEncrypt(data, key, iv) {
const cipher = crypto.createCipheriv(‘des-ede3-cbc’, key, iv);
let encrypted = cipher.update(data, ‘utf8’, ‘hex’);
encrypted += cipher.final(‘hex’);
return encrypted;
}
function tripleDesDecrypt(encrypted, key, iv) {
const decipher = crypto.createDecipheriv(‘des-ede3-cbc’, key, iv);
let decrypted = decipher.update(encrypted, ‘hex’, ‘utf8’);
decrypted += decipher.final(‘utf8’);
return decrypted;
}
const data = ‘hello world’;
const key = crypto.randomBytes(24); // 密钥，一个 Buffer 类
const iv = crypto.randomBytes(8); // 初始化向量，一个 Buffer 类
const encrypted = tripleDesEncrypt(data, key, iv);
const decrypted = tripleDesDecrypt(encrypted, key, iv);
console.log(原始数据: ${data});
console.log(密钥: ${key});
console.log(初始化向量: ${iv});
console.log(加密后的数据: ${encrypted});
console.log(解密后的数据: ${decrypted});
/*
const data = ‘1’;
const key = Buffer.from(‘012345678901234567890123’, ‘utf-8’);
const iv = Buffer.from(‘12345678’, ‘utf-8’);
const encrypted = tripleDesEncrypt(data, key, iv);
const decrypted = tripleDesDecrypt(encrypted, key, iv);
==>
原始数据: 1
密钥: 012345678901234567890123
初始化向量: 12345678
加密后的数据: 0d23ede5a77e7088
解密后的数据: 1
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了两个函数：tripleDesEncrypt和tripleDesDecrypt，分别用于对数据进行加密和解密。这两个函数接受三个参数：data表示要加密或解密的数据，key表示密钥，iv表示初始化向量。在加密和解密时，我们使用createCipheriv和createDecipheriv方法创建TripleDES加密或解密对象，然后使用update方法向对象中添加要加密或解密的数据。最后，我们使用final方法获取加密或解密后的数据。在主函数中，我们定义了data、key和iv等参数，并调用tripleDesEncrypt函数将数据加密，然后调用tripleDesDecrypt函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
Crypto-js库RC4加密方法
RC4是一种常用的对称加密算法，用于对数据进行加密和解密。RC4算法的全称是“Rivest Cipher 4”，它使用一个变长的密钥对数据进行加密和解密，密钥长度可以是1到256位。RC4算法具有以下特点：
安全性较低：RC4算法的安全性较低，容易被破解。
灵活性较强：RC4算法可以使用1到256位的密钥长度，比较灵活。
计算速度较快：RC4算法的计算速度比较快，适用于对大量数据进行加密和解密。以下是使用Node.js实现RC4算法的示例代码：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
const crypto = require(‘crypto’);
function rc4Encrypt(data, key) {
const cipher = crypto.createCipheriv(‘rc4’, key, ‘’);
let encrypted = cipher.update(data, ‘utf8’, ‘hex’);
encrypted += cipher.final(‘hex’);
return encrypted;
}
function rc4Decrypt(encrypted, key) {
const decipher = crypto.createDecipheriv(‘rc4’, key, ‘’);
let decrypted = decipher.update(encrypted, ‘hex’, ‘utf8’);
decrypted += decipher.final(‘utf8’);
return decrypted;
}
const data = ‘hello world’;
const key = ‘my secret key’;
const encrypted = rc4Encrypt(data, key);
const decrypted = rc4Decrypt(encrypted, key);
console.log(原始数据: ${data});
console.log(密钥: ${key});
console.log(加密后的数据: ${encrypted});
console.log(解密后的数据: ${decrypted});
/*
const data = ‘1’;
const key = ‘123’;
const encrypted = rc4Encrypt(data, key);
const decrypted = rc4Decrypt(encrypted, key);
==>
原始数据: 1
密钥: 123
加密后的数据: 62
解密后的数据: 1
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了两个函数：rc4Encrypt和rc4Decrypt，分别用于对数据进行加密和解密。这两个函数接受两个参数：data表示要加密或解密的数据，key表示密钥。在加密和解密时，我们使用createCipheriv和createDecipheriv方法创建RC4加密或解密对象，然后使用update方法向对象中添加要加密或解密的数据。最后，我们使用final方法获取加密或解密后的数据。在主函数中，我们定义了data和key等参数，并调用rc4Encrypt函数将数据加密，然后调用rc4Decrypt函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
Crypto-js库RC4Drop加密方法
RC4Drop是一种改进的RC4算法，它通过在加密过程中丢弃一定数量的密钥流，从而提高了RC4算法的安全性。RC4Drop算法的全称是“丢弃RC4算法”（Discard RC4），它使用一个变长的密钥对数据进行加密和解密，密钥长度可以是1到256位。RC4Drop算法具有以下特点：
安全性较高：RC4Drop算法通过丢弃一定数量的密钥流，提高了RC4算法的安全性。
灵活性较强：RC4Drop算法可以使用1到256位的密钥长度，比较灵活。
计算速度较快：RC4Drop算法的计算速度比较快，适用于对大量数据进行加密和解密。以下是使用Node.js实现RC4Drop算法的示例代码：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
const crypto = require(‘crypto’);
function rc4DropEncrypt(data, key, drop) {
const cipher = crypto.createCipheriv(‘rc4’, key, ‘’);
let encrypted = cipher.update(data, ‘utf8’, ‘hex’);
encrypted += cipher.final(‘hex’);
return encrypted.substr(drop * 2);
}
function rc4DropDecrypt(encrypted, key, drop) {
encrypted = ‘0’.repeat(drop * 2) + encrypted;
const decipher = crypto.createDecipheriv(‘rc4’, key, ‘’);
let decrypted = decipher.update(encrypted, ‘hex’, ‘utf8’);
decrypted += decipher.final(‘utf8’);
return decrypted;
}
const data = ‘hello world’;
const key = ‘my secret key’;
const drop = 1024;
const encrypted = rc4DropEncrypt(data, key, drop);
const decrypted = rc4DropDecrypt(encrypted, key, drop);
console.log(原始数据: ${data});
console.log(密钥: ${key});
console.log(加密后的数据: ${encrypted});
console.log(解密后的数据: ${decrypted});
/*
const data = ‘hello world’;
const key = ‘my secret key’;
const drop = 1024;
const encrypted = rc4DropEncrypt(data, key, drop);
const decrypted = rc4DropDecrypt(encrypted, key, drop);
==>
结果乱码了。。。
*/
在上面的代码中，我们首先导入了crypto模块，然后定义了两个函数：rc4DropEncrypt和rc4DropDecrypt，分别用于对数据进行加密和解密。这两个函数接受三个参数：data表示要加密或解密的数据，key表示密钥，drop表示丢弃的字节数。在加密和解密时，我们使用createCipheriv和createDecipheriv方法创建RC4加密或解密对象，然后使用update方法向对象中添加要加密或解密的数据。在加密时，我们使用substr方法截取加密后的数据，丢弃前drop个字节。在解密时，我们在加密后的数据前面添加drop个字节的0，然后再进行解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
Crypto-js库Rabbit加密方法
Rabbit是一种常用的流密码算法，用于对数据进行加密和解密。Rabbit算法的全称是“快速安全流密码”（Fast and Secure Stream Cipher），它使用一个变长的密钥和一个变长的初始化向量对数据进行加密和解密。Rabbit算法具有以下特点：
安全性较高：Rabbit算法的安全性较高，可以有效防止数据被破解。
灵活性较强：Rabbit算法可以使用不同长度的密钥和初始化向量，比较灵活。
计算速度较快：Rabbit算法的计算速度比较快，适用于对大量数据进行加密和解密。以下是使用Node.js实现Rabbit算法的示例代码：
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
26
27
28
29
30
// 代码报错
const crypto = require(‘crypto’);
function rabbitEncrypt(data, key, iv) {
const cipher = crypto.createCipheriv(‘rc4’, key, iv);
let encrypted = cipher.update(data, ‘utf8’, ‘hex’);
encrypted += cipher.final(‘hex’);
return encrypted;
}
function rabbitDecrypt(encrypted, key, iv) {
const decipher = crypto.createDecipheriv(‘rc4’, key, iv);
let decrypted = decipher.update(encrypted, ‘hex’, ‘utf8’);
decrypted += decipher.final(‘utf8’);
return decrypted;
}
const data = ‘hello world’;
const key = crypto.randomBytes(16);
const iv = crypto.randomBytes(8);
const encrypted = rabbitEncrypt(data, key, iv);
const decrypted = rabbitDecrypt(encrypted, key, iv);
console.log(Original data: ${data});
console.log(Encrypted data: ${encrypted});
console.log(Decrypted data: ${decrypted});
在上面的代码中，我们首先导入了crypto模块，然后定义了两个函数：rabbitEncrypt和rabbitDecrypt，分别用于对数据进行加密和解密。这两个函数接受三个参数：data表示要加密或解密的数据，key表示密钥，iv表示初始化向量。在加密和解密时，我们使用createCipheriv和createDecipheriv方法创建Rabbit加密或解密对象，然后使用update方法向对象中添加要加密或解密的数据。最后，我们使用final方法获取加密或解密后的数据。在主函数中，我们定义了data、key和iv等参数，并调用rabbitEncrypt函数将数据加密，然后调用rabbitDecrypt函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
Crypto-js库RabbitLegacy加密方法
RabbitLegacy是Rabbit算法的一个旧版本，它使用一个64位的初始化向量，而不是Rabbit算法的128位初始化向量。RabbitLegacy算法已经不再安全，不建议使用。如果需要使用Rabbit算法，请使用Rabbit算法的最新版本。
以下是使用Node.js实现RabbitLegacy算法的示例代码：
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
26
27
28
29
30
// 代码报错
const crypto = require(‘crypto’);
function rabbitLegacyEncrypt(data, key, iv) {
const cipher = crypto.createCipheriv(‘rc4-drop’, key, iv);
let encrypted = cipher.update(data, ‘utf8’, ‘hex’);
encrypted += cipher.final(‘hex’);
return encrypted;
}
function rabbitLegacyDecrypt(encrypted, key, iv) {
const decipher = crypto.createDecipheriv(‘rc4-drop’, key, iv);
let decrypted = decipher.update(encrypted, ‘hex’, ‘utf8’);
decrypted += decipher.final(‘utf8’);
return decrypted;
}
const data = ‘hello world’;
const key = ‘secret’;
const iv = crypto.randomBytes(8);
const encrypted = rabbitLegacyEncrypt(data, key, iv);
const decrypted = rabbitLegacyDecrypt(encrypted, key, iv);
console.log(Original data: ${data});
console.log(Encrypted data: ${encrypted});
console.log(Decrypted data: ${decrypted});
在上面的代码中，我们首先导入了crypto模块，然后定义了两个函数：rabbitLegacyEncrypt和rabbitLegacyDecrypt，分别用于对数据进行加密和解密。这两个函数接受三个参数：data表示要加密或解密的数据，key表示密钥，iv表示初始化向量。在加密和解密时，我们使用createCipheriv和createDecipheriv方法创建RabbitLegacy加密或解密对象，然后使用update方法向对象中添加要加密或解密的数据。最后，我们使用final方法获取加密或解密后的数据。
到此这篇关于js前端加密库Crypto-js进行MD5/SHA256/BASE64/AES加解密的方法与示例的文章就介绍到这了,更多相关js前端加密库Crypto-js加解密的方法与示例内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
最后编辑：Jeebiz 更新时间：2024-11-05 14:09
