Crypto-js加密库使用指南：MD5/SHA256/AES加解密方法与Node.js示例

CryptoJS（crypto.js）为JavaScript提供了丰富的加密算法支持。鉴于其API相对复杂，本文重点讲解如何利用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-nopadding

HMAC系列主要用于消息完整性验证，用于检测消息是否被篡改。例如在传输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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

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算法的示例代码：

// 代码报错
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算法，请使用其最新版本。

以下是使用Node.js实现RabbitLegacy算法的示例代码：

// 代码报错
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加解密的方法与示例内容，请搜索本站以前的文章或继续浏览下面的相关文章。希望大家以后多多支持本站！

JavaScript前端加密库Crypto-js常用算法详解：MD5/SHA系列/AES/HMAC等加解密实战