JavaScript Crypto 库算法使用案例
JavaScript Crypto 库算法使用案例
MD5、SHA1、SHA256、SHA224、SHA512、SHA384、SHA3、RIPEMD160 等哈希算法是不可逆的，即无法从哈希值反推出原始数据。
HMAC、PBKDF2、EvpKDF 等算法是基于哈希算法的消息认证码算法，也是不可逆的。
AES、DES、TripleDES、RC4、RC4Drop、Rabbit、RabbitLegacy 等对称加密算法是可逆的，即可以通过密钥将密文解密为明文。
非对称加密算法如 RSA、DSA、Diffie-Hellman 等也是可逆的，但是在加密和解密时使用的是不同的密钥。
MD5
MD5是一种常用的哈希算法，不可逆。用于将任意长度的消息压缩成一个128位的摘要1。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摘要，并输出了结果。
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摘要，并输出了结果。
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摘要，并输出了结果。
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摘要，并输出了结果。
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摘要，并输出了结果。
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摘要，并输出了结果。
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摘要，并输出了结果。
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摘要，并输出了结果。
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认证，并输出了结果。
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函数将密码转换为密钥。最后，我们输出了转换前的密码、盐值、迭代次数、密钥长度、哈希算法和转换后的密钥。
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函数将密码转换为密钥。最后，我们输出了转换前的密码、盐值、密钥长度、迭代次数、哈希算法和转换后的密钥。
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函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
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函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
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函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
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函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
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，然后再进行解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
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函数将加密后的数据解密。最后，我们输出了原始数据、加密后的数据和解密后的数据。
RabbitLegacy
RabbitLegacy是Rabbit算法的一个旧版本，它使用一个64位的初始化向量，而不是Rabbit算法的128位初始化向量。RabbitLegacy算法已经不再安全，不建议使用。如果需要使用Rabbit算法，请使用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方法获取加密或解密后的数据。
在计算机中，字节是计算机存储和处理数据的基本单位。一个字节通常由8个位组成。位是计算机中最小的数据单元，它只能表示0或1两种状态。在加密中，摘要是一种用于验证数据完整性的技术。摘要通常是一个固定长度的字节序列，它是通过对原始数据进行哈希计算得到的。因此，摘要的长度通常以字节为单位。例如，SHA-256算法生成的摘要长度为32字节，即256位。 ↩︎