JavaScript加密实战指南：从入门到精通CryptoJS全解析

2026-04-29 11:22:10作者：冯爽妲Honey

引言：JavaScript加密库的现状与价值

在现代Web开发中，数据安全已成为不可或缺的一环。JavaScript加密库为前端和Node.js环境提供了强大的加密能力，保护用户数据在传输和存储过程中的安全性。CryptoJS作为一款纯JavaScript实现的加密标准库，支持多种主流加密算法，曾是前端加密领域的重要选择。本文将全面解析CryptoJS的使用方法、核心功能和实战应用，帮助开发者在实际项目中正确应用加密技术。

⚠️ 重要安全提示：根据项目最新状态，CryptoJS的活跃开发已停止，不再提供官方维护。现代Node.js和浏览器环境已内置原生Crypto模块，建议新项目优先考虑使用原生API以获得更好的安全性和性能保障。

快速上手：环境准备与安装

环境要求

Node.js 12.0或更高版本
npm包管理器
现代浏览器（Chrome 60+、Firefox 55+、Edge 16+）

安装方法

npm安装（推荐）

npm install crypto-js

Git克隆安装

git clone https://gitcode.com/gh_mirrors/cr/crypto-js
cd crypto-js
npm install

基础架构：CryptoJS的模块化设计

CryptoJS采用高度模块化的架构设计，允许开发者按需引入所需功能，有效减小最终打包体积。整个库的架构可分为三个主要层次：

核心基础模块

模块路径	功能描述	应用场景
crypto-js/core	核心加密功能实现	所有加密操作的基础
crypto-js/x64-core	64位运算支持	高性能哈希算法实现
crypto-js/lib-typedarrays	类型化数组支持	二进制数据处理

编码与格式化模块

模块路径	功能描述	应用场景
crypto-js/enc-latin1	Latin1编码支持	传统文本编码处理
crypto-js/enc-utf8	UTF-8编码支持	现代文本数据处理
crypto-js/enc-hex	十六进制编码	哈希结果表示
crypto-js/enc-utf16	UTF-16编码支持	特定场景文本处理
crypto-js/enc-base64	Base64编码	数据传输编码
crypto-js/enc-base64url	URL安全Base64	URL参数加密
crypto-js/format-openssl	OpenSSL格式支持	与OpenSSL互操作
crypto-js/format-hex	十六进制格式	数据展示与存储

💡 技巧：在浏览器环境中，建议只引入项目实际需要的模块，以减少加载时间和资源占用。例如仅需SHA256哈希时，只需引入crypto-js/sha256即可。

算法体系：加密算法全解析

哈希算法

哈希算法用于将任意长度的数据转换为固定长度的哈希值，广泛应用于数据完整性校验和密码存储。

算法模块	输出长度	应用场景	安全性
crypto-js/md5	128位	传统校验	较低
crypto-js/sha1	160位	历史应用	中等
crypto-js/sha256	256位	数据校验	高
crypto-js/sha224	224位	特定安全需求	高
crypto-js/sha512	512位	高安全性要求	很高
crypto-js/sha384	384位	平衡安全与性能	很高
crypto-js/sha3	可变长度	最新标准	很高
crypto-js/ripemd160	160位	替代SHA1	中等

原理简析：哈希算法通过一系列数学运算将输入数据转换为固定长度的输出，具有单向性和雪崩效应（输入微小变化导致输出巨大变化）。

HMAC算法

HMAC（基于哈希的消息认证码）结合密钥和哈希算法，提供数据完整性和认证功能。

算法模块	基础算法	应用场景
crypto-js/hmac-md5	MD5	低安全要求认证
crypto-js/hmac-sha1	SHA1	传统系统认证
crypto-js/hmac-sha256	SHA256	API签名
crypto-js/hmac-sha224	SHA224	特定安全需求
crypto-js/hmac-sha512	SHA512	高安全性认证
crypto-js/hmac-sha384	SHA384	安全敏感操作
crypto-js/hmac-sha3	SHA3	最新标准认证
crypto-js/hmac-ripemd160	RIPEMD160	替代方案

对称加密算法

对称加密使用相同的密钥进行加密和解密，运算速度快，适合大量数据加密。

算法模块	密钥长度	特点	应用场景
crypto-js/aes	128/192/256位	最流行对称加密	数据传输加密
crypto-js/tripledes	168位	增强版DES	兼容性需求
crypto-js/rc4	可变长度	流加密算法	实时数据加密
crypto-js/rabbit	128位	高性能	移动端应用
crypto-js/rabbit-legacy	128位	旧版实现	兼容性支持
crypto-js/blowfish	32-448位	可变密钥长度	特定安全需求

原理简析：对称加密通过替换、置换等操作将明文转换为密文，同一密钥控制加密和解密过程，效率高但密钥分发存在挑战。

密钥派生函数

算法模块	功能	应用场景
crypto-js/pbkdf2	基于密码的密钥派生	密码存储
crypto-js/evpkdf	OpenSSL密钥派生	与OpenSSL兼容

加密模式与填充方式

加密模式决定了分组密码如何处理长于块大小的数据，填充方式则用于将数据长度调整为块大小的整数倍。

加密模式

模式模块	特点	安全性
crypto-js/mode-cfb	密文反馈模式	较高
crypto-js/mode-ctr	计数器模式	高
crypto-js/mode-ctr-gladman	Gladman实现的CTR	高
crypto-js/mode-ofb	输出反馈模式	中等
crypto-js/mode-ecb	电子密码本模式	低（不推荐）

填充方式

填充模块	特点	应用场景
crypto-js/pad-pkcs7	PKCS#7标准填充	推荐默认使用
crypto-js/pad-ansix923	ANSI X.923填充	特定协议需求
crypto-js/pad-iso10126	ISO 10126填充	国际标准兼容
crypto-js/pad-iso97971	ISO 9797-1填充	金融领域应用
crypto-js/pad-zeropadding	零填充	遗留系统兼容
crypto-js/pad-nopadding	无填充	特定场景

浏览器实战：前端加密实现

基础引入方式

模块化引入（推荐）

<script type="module">
  import AES from './node_modules/crypto-js/aes.js';
  import SHA256 from './node_modules/crypto-js/sha256.js';
  
  // 使用示例
  const hash = SHA256('Hello World');
  console.log('SHA256哈希结果:', hash.toString());
</script>

传统引入方式

<script src="path-to/crypto-js/crypto-js.js"></script>
<script>
  // 全库引入后使用
  const encrypted = CryptoJS.AES.encrypt('敏感数据', '加密密钥').toString();
  console.log('加密结果:', encrypted);
</script>

常用功能实现

用户密码哈希存储

// 密码哈希处理示例
function hashPassword(password, salt) {
  // 使用SHA256和盐值进行密码哈希
  return CryptoJS.SHA256(password + salt).toString();
}

// 生成随机盐值
function generateSalt() {
  // 使用CryptoJS生成随机16字节盐值
  return CryptoJS.lib.WordArray.random(16).toString();
}

// 使用示例
const userPassword = 'user123456';
const salt = generateSalt();
const hashedPassword = hashPassword(userPassword, salt);

console.log('盐值:', salt);
console.log('哈希后密码:', hashedPassword);

本地数据加密存储

// 本地存储加密工具
const LocalStorageEncryptor = {
  // 加密存储数据
  setItem: function(key, value, secretKey) {
    try {
      // 将对象转换为JSON字符串
      const jsonValue = JSON.stringify(value);
      // 使用AES加密
      const encrypted = CryptoJS.AES.encrypt(jsonValue, secretKey).toString();
      // 存储加密后的数据
      localStorage.setItem(key, encrypted);
      return true;
    } catch (e) {
      console.error('存储加密失败:', e);
      return false;
    }
  },
  
  // 获取解密数据
  getItem: function(key, secretKey) {
    try {
      // 获取加密数据
      const encrypted = localStorage.getItem(key);
      if (!encrypted) return null;
      
      // 解密数据
      const bytes = CryptoJS.AES.decrypt(encrypted, secretKey);
      const jsonValue = bytes.toString(CryptoJS.enc.Utf8);
      
      // 解析JSON并返回
      return JSON.parse(jsonValue);
    } catch (e) {
      console.error('获取解密失败:', e);
      return null;
    }
  }
};

// 使用示例
const userData = {
  username: 'john_doe',
  email: 'john@example.com',
  preferences: { theme: 'dark', notifications: true }
};

// 加密存储
LocalStorageEncryptor.setItem('user_data', userData, 'my-secret-key-123');

// 解密获取
const decryptedData = LocalStorageEncryptor.getItem('user_data', 'my-secret-key-123');
console.log('解密后的数据:', decryptedData);

Node.js实战：后端加密应用

模块引入方式

CommonJS引入

// 引入所需模块
const AES = require('crypto-js/aes');
const SHA256 = require('crypto-js/sha256');
const encUtf8 = require('crypto-js/enc-utf8');

// 哈希示例
const data = '需要哈希的数据';
const hash = SHA256(data);
console.log('哈希结果:', hash.toString());

ES模块引入

import AES from 'crypto-js/aes';
import SHA256 from 'crypto-js/sha256';
import { enc } from 'crypto-js/core';

// 加密示例
const originalText = 'Node.js加密示例';
const encrypted = AES.encrypt(originalText, 'secret-key');
console.log('加密结果:', encrypted.toString());

API签名实现

const crypto = require('crypto-js');

/**
 * 生成API请求签名
 * @param {Object} params - 请求参数
 * @param {string} secretKey - 密钥
 * @param {string} method - HTTP方法
 * @param {string} path - 请求路径
 * @returns {string} 签名结果
 */
function generateApiSignature(params, secretKey, method, path) {
  // 1. 对参数按字母排序
  const sortedParams = Object.keys(params)
    .sort()
    .reduce((obj, key) => {
      obj[key] = params[key];
      return obj;
    }, {});
  
  // 2. 拼接为查询字符串
  const queryString = Object.entries(sortedParams)
    .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
    .join('&');
  
  // 3. 构建签名基础字符串
  const signatureBase = `${method.toUpperCase()}\n${path}\n${queryString}`;
  
  // 4. 使用HMAC-SHA256生成签名
  const signature = crypto.HmacSHA256(signatureBase, secretKey).toString(crypto.enc.Hex);
  
  return signature;
}

// 使用示例
const apiParams = {
  action: 'queryData',
  timestamp: Date.now(),
  nonce: Math.random().toString(36).substr(2, 10),
  dataType: 'json'
};

const apiSecret = 'your-api-secret-key';
const httpMethod = 'GET';
const requestPath = '/api/v1/data';

const signature = generateApiSignature(apiParams, apiSecret, httpMethod, requestPath);
console.log('API请求签名:', signature);

文件加密处理

const fs = require('fs');
const path = require('path');
const crypto = require('crypto-js');

/**
 * 加密文件
 * @param {string} inputPath - 输入文件路径
 * @param {string} outputPath - 输出文件路径
 * @param {string} secretKey - 加密密钥
 */
function encryptFile(inputPath, outputPath, secretKey) {
  try {
    // 读取文件内容
    const fileContent = fs.readFileSync(inputPath);
    
    // 将Buffer转换为WordArray
    const wordArray = crypto.lib.WordArray.create(fileContent);
    
    // 加密
    const encrypted = crypto.AES.encrypt(wordArray, secretKey);
    
    // 写入加密后文件
    fs.writeFileSync(outputPath, encrypted.toString());
    
    console.log(`文件加密成功: ${outputPath}`);
  } catch (error) {
    console.error('文件加密失败:', error);
  }
}

/**
 * 解密文件
 * @param {string} inputPath - 输入文件路径
 * @param {string} outputPath - 输出文件路径
 * @param {string} secretKey - 解密密钥
 */
function decryptFile(inputPath, outputPath, secretKey) {
  try {
    // 读取加密内容
    const encryptedContent = fs.readFileSync(inputPath, 'utf8');
    
    // 解密
    const decrypted = crypto.AES.decrypt(encryptedContent, secretKey);
    
    // 将WordArray转换为Buffer
    const buffer = Buffer.from(decrypted.words);
    
    // 写入解密后文件
    fs.writeFileSync(outputPath, buffer);
    
    console.log(`文件解密成功: ${outputPath}`);
  } catch (error) {
    console.error('文件解密失败:', error);
  }
}

// 使用示例
const testFile = path.join(__dirname, 'test.txt');
const encryptedFile = path.join(__dirname, 'test.enc');
const decryptedFile = path.join(__dirname, 'test_decrypted.txt');
const encryptionKey = 'strong-encryption-key-32-chars!';

// 创建测试文件
fs.writeFileSync(testFile, '这是一个文件加密测试内容');

// 加密文件
encryptFile(testFile, encryptedFile, encryptionKey);

// 解密文件
decryptFile(encryptedFile, decryptedFile, encryptionKey);

加密场景解决方案

敏感数据传输加密

在前后端数据传输中，敏感信息需要加密保护。以下是一个完整的前后端加密通信方案：

前端加密实现：

// 前端加密工具
const CryptoUtil = {
  // 生成AES密钥
  generateKey: function() {
    return crypto.lib.WordArray.random(32).toString(); // 256位密钥
  },
  
  // 加密数据
  encryptData: function(data, key) {
    return crypto.AES.encrypt(JSON.stringify(data), key).toString();
  },
  
  // 解密数据
  decryptData: function(encryptedData, key) {
    const bytes = crypto.AES.decrypt(encryptedData, key);
    return JSON.parse(bytes.toString(crypto.enc.Utf8));
  }
};

// 通信示例
async function securePost(url, data, publicKey) {
  // 1. 生成临时AES密钥
  const aesKey = CryptoUtil.generateKey();
  
  // 2. 使用AES加密数据
  const encryptedData = CryptoUtil.encryptData(data, aesKey);
  
  // 3. 使用公钥加密AES密钥（此处简化，实际应使用RSA）
  const encryptedKey = btoa(aesKey); // 实际项目中应替换为RSA加密
  
  // 4. 发送加密数据和加密的密钥
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Encrypted-Key': encryptedKey
    },
    body: JSON.stringify({ data: encryptedData })
  });
  
  // 5. 处理响应
  const encryptedResponse = await response.json();
  return CryptoUtil.decryptData(encryptedResponse.data, aesKey);
}

// 使用示例
const sensitiveData = {
  userId: 12345,
  paymentInfo: {
    cardNumber: '4111111111111111',
    expiryDate: '12/25'
  }
};

securePost('/api/sensitive-data', sensitiveData)
  .then(response => console.log('服务器响应:', response))
  .catch(error => console.error('请求错误:', error));

后端解密实现：

// Node.js后端解密中间件
const crypto = require('crypto-js');
const express = require('express');
const app = express();

// 解密中间件
app.use(express.json());
app.use((req, res, next) => {
  if (req.headers['x-encrypted-key'] && req.body.data) {
    try {
      // 获取加密的AES密钥（实际项目中应使用RSA私钥解密）
      const encryptedKey = req.headers['x-encrypted-key'];
      const aesKey = atob(encryptedKey); // 实际项目中应替换为RSA解密
      
      // 解密数据
      const bytes = crypto.AES.decrypt(req.body.data, aesKey);
      req.decryptedData = JSON.parse(bytes.toString(crypto.enc.Utf8));
    } catch (error) {
      return res.status(400).json({ error: '数据解密失败' });
    }
  }
  next();
});

// 处理加密请求的API端点
app.post('/api/sensitive-data', (req, res) => {
  if (!req.decryptedData) {
    return res.status(400).json({ error: '未提供加密数据' });
  }
  
  // 处理解密后的数据
  console.log('收到解密数据:', req.decryptedData);
  
  // 加密响应
  const aesKey = atob(req.headers['x-encrypted-key']);
  const responseData = { status: 'success', message: '数据已安全处理' };
  const encryptedResponse = crypto.AES.encrypt(JSON.stringify(responseData), aesKey).toString();
  
  res.json({ data: encryptedResponse });
});

app.listen(3000, () => console.log('服务器运行在端口3000'));

安全存储用户凭证

存储用户密码时，绝不能明文存储，应使用密码哈希结合盐值的方式：

// 用户认证工具
const AuthUtil = {
  // 生成盐值和哈希密码
  hashPassword: function(password) {
    // 生成16字节随机盐值
    const salt = crypto.lib.WordArray.random(16).toString();
    
    // 使用PBKDF2进行密钥派生
    const iterations = 1000; // 迭代次数
    const keySize = 256 / 32; // 256位密钥
    const hash = crypto.PBKDF2(password, salt, { 
      keySize: keySize, 
      iterations: iterations 
    }).toString();
    
    return { salt, hash, iterations };
  },
  
  // 验证密码
  verifyPassword: function(password, storedHash, storedSalt, storedIterations) {
    const keySize = 256 / 32;
    const hash = crypto.PBKDF2(password, storedSalt, { 
      keySize: keySize, 
      iterations: storedIterations 
    }).toString();
    
    return hash === storedHash;
  }
};

// 使用示例
// 注册新用户时
const userPassword = 'userSecurePassword123';
const { salt, hash, iterations } = AuthUtil.hashPassword(userPassword);

// 存储到数据库
console.log('存储到数据库的信息:');
console.log('盐值:', salt);
console.log('哈希:', hash);
console.log('迭代次数:', iterations);

// 用户登录验证时
const loginPassword = 'userSecurePassword123';
const isPasswordValid = AuthUtil.verifyPassword(loginPassword, hash, salt, iterations);
console.log('密码验证结果:', isPasswordValid); // true

项目构建与测试

构建项目

CryptoJS使用Grunt作为构建工具，可通过以下命令构建项目：

# 安装依赖
npm install

# 执行构建
npm run build

构建过程将处理并打包各个模块，生成可用于浏览器和Node.js环境的文件。

运行测试

项目提供了完整的测试套件，可通过以下命令运行：

# 运行所有测试
npm test

# 查看测试覆盖率
npm run test:coverage

测试文件位于test/目录下，包含各种算法的单元测试和功能测试。

版本特性与迁移指南

主要版本特性

版本	发布时间	主要特性	安全改进
4.2.0	2021年	添加Blowfish支持，改进PBKDF2默认参数	增强默认安全性
4.1.0	2020年	添加base64url编码，优化webpack打包	移除潜在安全隐患
4.0.0	2020年	使用原生crypto模块生成随机数	解决Math.random()安全问题
3.3.0	2018年	添加SHA3支持，改进错误处理	常规安全更新

⚠️ 安全警告：3.1.x及更早版本使用Math.random()生成随机数，在加密场景中不够安全，强烈建议升级到4.x版本或迁移到原生Crypto模块。

替代方案对比

随着CryptoJS停止维护，以下是一些推荐的替代方案：

方案	优势	劣势	适用场景
浏览器原生Crypto API	系统内置，性能最佳，持续维护	浏览器兼容性要求高	现代前端应用
Node.js crypto模块	原生支持，性能优异，安全可靠	仅限Node.js环境	Node.js后端应用
TweetNaCl.js	轻量级，专注安全，代码量小	算法支持较少	对体积敏感的应用
Forge	功能全面，支持PKI等高级功能	体积较大	需要复杂加密功能

迁移策略

从CryptoJS迁移到原生Crypto API的基本步骤：

哈希功能迁移：

// CryptoJS
const hash = CryptoJS.SHA256('data').toString();

// 原生Crypto API
async function sha256(data) {
  const encoder = new TextEncoder();
  const dataBuffer = encoder.encode(data);
  const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
  return Array.from(new Uint8Array(hashBuffer))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

AES加密迁移：

// CryptoJS
const encrypted = CryptoJS.AES.encrypt('data', 'key').toString();

// 原生Crypto API
async function encryptAES(data, key) {
  const encoder = new TextEncoder();
  const dataBuffer = encoder.encode(data);
  const keyBuffer = encoder.encode(key).slice(0, 32); // 确保32字节
  
  const cryptoKey = await crypto.subtle.importKey(
    'raw', keyBuffer, { name: 'AES-GCM' }, false, ['encrypt']
  );
  
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const encrypted = await crypto.subtle.encrypt(
    { name: 'AES-GCM', iv }, cryptoKey, dataBuffer
  );
  
  return {
    iv: Array.from(iv).map(b => b.toString(16).padStart(2, '0')).join(''),
    ciphertext: Array.from(new Uint8Array(encrypted))
      .map(b => b.toString(16).padStart(2, '0')).join('')
  };
}