1. 为什么前端登录需要加密?从“明文裸奔”到“安全传输”
大家好,我是老张,一个在前后端安全领域摸爬滚打了十多年的老码农。今天想和大家聊聊一个几乎所有Web项目都会遇到的问题:前端登录密码的加密处理。
我记得大概七八年前,我接手过一个老项目,当时为了赶进度,登录接口的密码竟然是明文传输的!你能想象吗?用户在登录框里输入的“123456”,在浏览器的网络请求里看得一清二楚。后来我们被安全团队“请去喝茶”,那个尴尬啊,现在想起来都觉得脸上发烫。从那以后,我就养成了一个习惯:任何从用户端发往服务器的敏感数据,都必须加密。
那么问题来了,前端加密到底在防什么?很多人可能会说:“不是有HTTPS吗?” 没错,HTTPS确实能防止传输过程中的数据被窃听,但它解决不了所有问题。比如,如果有人在你的网站上装了恶意插件,或者存在中间人攻击的风险,明文密码依然可能泄露。前端加密就像是给你的数据加上了第二道锁,即使数据在传输过程中被截获,攻击者看到的也是一堆乱码,大大增加了破解的难度。
在实际项目中,我主要用两种加密方式:AES对称加密和SHA256哈希加密。这两种方案各有各的适用场景,选对了能让你的系统既安全又好维护。接下来,我就结合自己踩过的坑和实战经验,详细说说怎么用CryptoJS这个库来实现它们。
2. 环境准备:5分钟快速上手CryptoJS
工欲善其事,必先利其器。咱们先花几分钟把CryptoJS这个工具装好、配置好。
2.1 安装CryptoJS的两种方式
CryptoJS是个纯JavaScript写的加密库,用起来特别方便。安装方式主要有两种,你可以根据自己的项目情况来选择。
第一种是通过npm或yarn安装,这是现代前端项目的标准做法:
# 使用npm
npm install crypto-js --save
# 或者使用yarn
yarn add crypto-js
安装完成后,你可以在项目的package.json文件里看到它已经被添加到依赖列表里了。这种方式的好处是能和你的项目构建工具(比如Webpack、Vite)完美集成,打包时会自动处理。
第二种是直接通过CDN引入,适合一些简单的页面或者快速原型开发:
<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js"></script>
我个人的经验是,如果是正经的工程项目,强烈推荐用npm安装。因为CDN方式有网络依赖,万一CDN服务挂了或者被墙了,你的加密功能就全废了。而且npm安装的版本你可以锁定,不会因为CDN更新导致不兼容的问题。
2.2 在项目中引入和使用
安装好了,怎么在项目里用呢?这里我以Vue项目为例,React、Angular或者其他框架的思路其实都差不多。
在Vue项目里,我习惯在main.js里全局引入,这样在任何组件里都能直接用了:
// main.js
import CryptoJS from 'crypto-js'
// 挂载到Vue原型上,这样在任何组件里都能用this.$cryptoJS访问
Vue.prototype.$cryptoJS = CryptoJS
// 或者如果你不想污染Vue原型,也可以导出为单独的模块
export { CryptoJS }
然后在你的登录组件里,就可以这样测试一下是否引入成功了:
// Login.vue
export default {
mounted() {
console.log('CryptoJS库加载成功:', this.$cryptoJS)
// 简单测试一下MD5
const testHash = this.$cryptoJS.MD5('hello world').toString()
console.log('测试MD5加密:', testHash)
}
}
如果控制台能正常输出CryptoJS对象和加密结果,说明环境配置成功了。这里有个小技巧:我建议在开发环境加上这个测试代码,生产环境再移除,避免在控制台暴露不必要的调试信息。
3. SHA256哈希加密:单向加密的经典方案
先来说说SHA256,这是我用得最多的一种加密方式,特别是在处理用户密码的时候。
3.1 SHA256到底是什么?为什么不可逆?
SHA256的全称是“安全哈希算法256位”,它属于哈希函数家族。你可以把它想象成一个超级复杂的“榨汁机”:你把任何长度的数据(比如“hello world”)放进去,它都会给你榨出一杯固定256位(32字节)的“果汁”。关键是,这个过程是单向的——你没法通过这杯“果汁”还原出原来的水果是什么。
为什么不可逆这么重要?想象一下,如果你的数据库被拖库了,里面存的都是可逆加密的密码,黑客拿到密钥就能解密所有用户的密码。但如果存的是SHA256哈希值,黑客只能看到一堆乱码,想反推出原始密码几乎不可能(至少以现在的计算能力是这样)。
我在实际项目中验证过,对同一个字符串“123456”进行SHA256加密,每次得到的结果都是固定的:
8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92
但如果你稍微改一下,变成“1234567”,结果就完全不一样了:
8bb0cf6eb9b17d0f7d22b456f121257dc1254e1f01665370476383ea776df414
这种“雪崩效应”正是哈希函数安全性的体现。
3.2 实战:用SHA256加密登录密码
具体到登录场景,SHA256的用法其实特别简单。下面是一个完整的登录密码加密示例:
// 在登录方法中
handleLogin() {
// 1. 获取用户输入的密码
const rawPassword = this.passwordInput
// 2. 进行SHA256加密
const hash = this.$cryptoJS.SHA256(rawPassword)
// 3. 转换为字符串(默认是十六进制)
const encryptedPassword = hash.toString()
// 4. 发送到后端
this.$axios.post('/api/login', {
username: this.usernameInput,
password: encryptedPassword // 注意:这里传的是加密后的哈希值
}).then(response => {
// 处理登录成功逻辑
})
}
这里有个很重要的细节:toString()方法。如果不调用这个方法,hash变量实际上是一个CryptoJS的内部对象(WordArray),不是字符串。直接把这个对象传给后端,后端是解析不了的。所以一定要记得调用toString()。
3.3 前后端配合的验证逻辑
前端加密只是第一步,后端怎么验证这个密码对不对呢?这里有个常见的误区:有些新手开发者以为后端也要用同样的方式加密然后比较,其实不对。正确的流程是这样的:
-
用户注册时:前端把密码用SHA256加密后传给后端,后端直接把这个哈希值存到数据库里。注意,这里存的就是加密后的字符串,不是原始密码。
-
用户登录时:前端还是用同样的方式加密密码,然后把加密后的字符串传给后端。
-
后端验证:后端收到加密后的密码,直接从数据库里取出之前存储的哈希值,然后进行字符串比较。如果两个哈希值完全一样,就说明密码正确。
// 后端Node.js示例(简化版)
app.post('/api/login', async (req, res) => {
const { username, password } = req.body // password已经是前端加密过的哈希值
// 从数据库查找用户
const user = await User.findOne({ where: { username } })
if (!user) {
return res.status(401).json({ message: '用户不存在' })
}
// 直接比较哈希值
if (user.password_hash === password) {
// 登录成功,生成token等操作
return res.json({ success: true, token: '...' })
} else {
return res.status(401).json({ message: '密码错误' })
}
})
这种方案的好处是后端不需要知道用户的原始密码,安全性更高。但缺点也很明显:如果两个用户用了相同的密码,他们的密码哈希值也会一样。这时候就需要引入“盐值”(salt)的概念了,这个我们后面会讲到。
4. AES对称加密:可逆加密的灵活应用
如果说SHA256是“单向门”,只能进不能出,那么AES就是“双向门”,既能加密也能解密。这在某些场景下特别有用。
4.1 AES加密的核心概念:密钥、IV和模式
在开始写代码之前,咱们得先搞清楚AES加密的几个关键概念,不然很容易踩坑。
密钥(Key):这是加密和解密的“钥匙”。AES支持128位、192位和256位三种长度的密钥。密钥越长越安全,但计算开销也越大。对于大多数Web应用,128位(16个字符)就足够了。这里要注意的是,密钥必须是固定长度的字符串,比如128位对应16个字符,256位对应32个字符。
初始化向量(IV):你可以把它理解成加密的“随机种子”。即使相同的明文用相同的密钥加密,只要IV不同,得到的密文就完全不同。这能防止攻击者通过分析密文模式来破解。IV的长度必须和加密块大小一致,AES是128位(16字节)。
加密模式:这是AES的工作方式,常见的有:
- ECB模式:最简单,但安全性最差。相同的明文块会加密成相同的密文块,容易受到攻击。
- CBC模式:最常用的模式,每个明文块先与前一个密文块进行异或操作后再加密,安全性更好。
- CFB、OFB、CTR模式:这些是流加密模式,适合加密数据流。
我强烈推荐用CBC模式,它在安全性和性能之间取得了很好的平衡。ECB模式虽然简单,但在实际项目中我从来不用,因为它的安全性问题太明显了。
填充方式:因为AES是按固定块(128位)加密的,如果数据长度不是块的整数倍,就需要填充。最常用的是PKCS7填充(在有些实现里叫PKCS5,其实差不多)。
4.2 完整实现:AES加密和解密函数
理解了这些概念,咱们来看具体的代码实现。我会写一个完整的AES工具类,包含加密和解密两个方法:
// utils/crypto.js
import CryptoJS from 'crypto-js'
// 定义密钥和IV(在实际项目中,这些应该从环境变量或配置中心获取)
const AES_KEY = CryptoJS.enc.Utf8.parse('1234567890123456') // 16字节密钥
const AES_IV = CryptoJS.enc.Utf8.parse('abcdefghijklmnop') // 16字节IV
export default {
/**
* AES加密
* @param {string} plainText - 要加密的明文
* @returns {string} 加密后的密文(Base64格式)
*/
encrypt(plainText) {
try {
// 1. 将明文转换成CryptoJS可处理的格式
const srcs = CryptoJS.enc.Utf8.parse(plainText)
// 2. 执行AES加密
const encrypted = CryptoJS.AES.encrypt(srcs, AES_KEY, {
iv: AES_IV,
mode: CryptoJS.mode.CBC, // 使用CBC模式
padding: CryptoJS.pad.Pkcs7 // 使用PKCS7填充
})
// 3. 将加密结果转换为Base64字符串
// 注意:encrypted本身是个对象,我们需要的是ciphertext
const base64CipherText = CryptoJS.enc.Base64.stringify(encrypted.ciphertext)
// 4. 对Base64字符串进行URL编码(防止特殊字符问题)
return encodeURIComponent(base64CipherText)
} catch (error) {
console.error('AES加密失败:', error)
throw new Error('加密过程出错')
}
},
/**
* AES解密
* @param {string} cipherText - 要解密的密文(Base64格式)
* @returns {string} 解密后的明文
*/
decrypt(cipherText) {
try {
// 1. 先进行URL解码
const decodedCipherText = decodeURIComponent(cipherText)
// 2. 将Base64字符串转换回CryptoJS可处理的格式
const encryptedHexStr = CryptoJS.enc.Base64.parse(decodedCipherText)
// 3. 重新构建加密对象
const srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr)
// 4. 执行AES解密
const decrypt = CryptoJS.AES.decrypt(srcs, AES_KEY, {
iv: AES_IV,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7
})
// 5. 将解密结果转换为UTF-8字符串
const decryptedStr = decrypt.toString(CryptoJS.enc.Utf8)
return decryptedStr.toString()
} catch (error) {
console.error('AES解密失败:', error)
throw new Error('解密过程出错')
}
}
}
这个工具类可以直接用在你的登录逻辑里:
// 在登录组件中使用
import cryptoUtil from '@/utils/crypto'
export default {
methods: {
async handleLogin() {
// 加密密码
const encryptedPassword = cryptoUtil.encrypt(this.password)
// 发送到后端
const response = await this.$axios.post('/api/login', {
username: this.username,
password: encryptedPassword
})
// 如果后端返回的数据也是加密的,可以解密
if (response.data.encryptedUserInfo) {
const userInfo = cryptoUtil.decrypt(response.data.encryptedUserInfo)
console.log('解密后的用户信息:', userInfo)
}
}
}
}
4.3 密钥管理:安全存储的最佳实践
看到这里你可能要问了:“老张,你把密钥直接写在代码里,这不安全吧?” 问得好!这确实是个大问题。
在实际项目中,我从来不会把密钥硬编码在代码里。下面分享几种我常用的密钥管理方案:
方案一:环境变量配置 这是最简单也最常用的方法。把密钥放在环境变量里,不同环境(开发、测试、生产)用不同的密钥。
// .env.development
VUE_APP_AES_KEY=development_key_1234
VUE_APP_AES_IV=development_iv_abcd
// .env.production
VUE_APP_AES_KEY=production_key_xxxx
VUE_APP_AES_IV=production_iv_yyyy
// 在代码中使用
const AES_KEY = CryptoJS.enc.Utf8.parse(process.env.VUE_APP_AES_KEY)
const AES_IV = CryptoJS.enc.Utf8.parse(process.env.VUE_APP_AES_IV)
方案二:从后端动态获取 对于安全性要求特别高的场景,可以在用户登录时,后端返回一个临时密钥(用HTTPS传输),前端用这个密钥加密本次会话的数据。这个密钥有过期时间,每次登录都重新生成。
// 1. 先获取临时密钥
const keyResponse = await this.$axios.get('/api/encryption-key')
const { tempKey, tempIV, expiresIn } = keyResponse.data
// 2. 用临时密钥加密数据
const encryptedData = this.encryptWithKey(data, tempKey, tempIV)
// 3. 发送加密后的数据
await this.$axios.post('/api/sensitive-data', { encryptedData })
方案三:硬件安全模块(HSM) 对于金融、支付这类对安全性要求极高的系统,可以考虑使用HSM。不过这个方案成本比较高,一般的中小型项目用不到。
无论用哪种方案,都要记住几个原则:
- 不要在前端代码里写死密钥
- 定期更换密钥(比如每季度或每半年)
- 开发、测试、生产环境使用不同的密钥
- 密钥要有足够的长度和复杂度
5. AES vs SHA256:如何根据场景选择?
现在你两种加密方式都会用了,但到底该用哪个呢?我画了个简单的对比表格,帮你快速决策:
| 特性 | AES对称加密 | SHA256哈希加密 |
|---|---|---|
| 加密类型 | 对称加密(可逆) | 哈希函数(不可逆) |
| 主要用途 | 需要解密的场景 | 密码存储、数据完整性验证 |
| 性能 | 相对较慢 | 非常快 |
| 密钥管理 | 需要安全存储密钥 | 不需要密钥 |
| 安全性 | 依赖密钥安全 | 抗碰撞性高 |
| 典型场景 | 加密传输敏感数据、加密本地存储 | 用户密码存储、文件校验 |
5.1 登录密码:为什么我更推荐SHA256?
对于登录密码,我强烈推荐用SHA256而不是AES。原因有几个:
第一,密码验证不需要知道原始密码。后端只需要比较哈希值是否一致,没必要存储可解密的密码。这样即使数据库泄露,攻击者拿到的也只是哈希值,想反推出原始密码非常困难。
第二,可以加“盐”(salt)增强安全性。单纯的SHA256还有个问题:如果两个用户密码相同,哈希值也相同。攻击者可以预先计算常见密码的哈希值(彩虹表),然后直接匹配。加盐就是给每个密码额外添加一段随机字符串:
// 加盐的SHA256加密
function hashPassword(password, salt) {
// 将盐和密码组合后再哈希
const saltedPassword = salt + password
return this.$cryptoJS.SHA256(saltedPassword).toString()
}
// 使用示例
const salt = '随机生成的一串字符,每个用户不同'
const hashedPassword = hashPassword('user123', salt)
这样即使两个用户密码相同,因为盐不同,最终的哈希值也不同。彩虹表攻击就失效了。
5.2 哪些场景适合用AES?
那AES用在什么地方呢?我举几个实际项目中的例子:
场景一:加密传输敏感数据 比如用户身份证号、银行卡号这些极度敏感的信息。虽然HTTPS能保证传输安全,但有些合规要求(比如等保三级)会要求应用层也加密。
// 加密身份证号
const encryptedIdCard = cryptoUtil.encrypt('110101199001011234')
// 发送到后端
await this.$axios.post('/api/user/update', {
idCard: encryptedIdCard
})
场景二:本地存储加密 有些数据需要保存在localStorage或sessionStorage里,但又不想让用户直接看到明文:
// 保存加密的用户信息到localStorage
const userInfo = {
userId: '123',
phone: '13800138000',
email: 'user@example.com'
}
const encryptedUserInfo = cryptoUtil.encrypt(JSON.stringify(userInfo))
localStorage.setItem('user_data', encryptedUserInfo)
// 读取时解密
const storedData = localStorage.getItem('user_data')
if (storedData) {
const decryptedData = cryptoUtil.decrypt(storedData)
const userInfo = JSON.parse(decryptedData)
}
场景三:加密URL参数 有些时候需要在URL里传递敏感参数,但又不想让用户直接看到:
// 加密参数
const params = {
orderId: '202312345678',
amount: '100.00',
timestamp: Date.now()
}
const encryptedParams = cryptoUtil.encrypt(JSON.stringify(params))
// 生成带加密参数的URL
const url = `/payment/confirm?data=${encodeURIComponent(encryptedParams)}`
6. 实战进阶:混合加密与安全性增强
在实际的大型项目中,我很少只用单一的加密方式。更多时候是多种技术组合使用,形成纵深防御。
6.1 SHA256 + AES的混合方案
这是我最近在一个金融项目中用的方案,兼顾了安全性和灵活性:
// 混合加密方案
export default {
/**
* 混合加密:先用SHA256哈希密码,再用AES加密哈希值
*/
hybridEncrypt(password) {
// 第一步:SHA256哈希
const hash = CryptoJS.SHA256(password).toString()
// 第二步:AES加密哈希值
const srcs = CryptoJS.enc.Utf8.parse(hash)
const encrypted = CryptoJS.AES.encrypt(srcs, this.AES_KEY, {
iv: this.AES_IV,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7
})
return CryptoJS.enc.Base64.stringify(encrypted.ciphertext)
},
/**
* 后端对应的解密验证
* 注意:后端需要先AES解密,再验证SHA256哈希
*/
async backendVerify(encryptedData, storedHash) {
// 1. AES解密得到哈希值
const decryptedHash = this.aesDecrypt(encryptedData)
// 2. 比较哈希值
return decryptedHash === storedHash
}
}
这个方案的好处是:即使AES密钥泄露,攻击者拿到的也只是密码的哈希值,而不是原始密码。而SHA256的不可逆特性保证了哈希值无法还原为密码。
6.2 时间戳防重放攻击
重放攻击是Web安全中常见的问题:攻击者截获你的加密请求,然后原封不动地重放一次。对付这种攻击,我常用的方法是加时间戳:
// 加密时加入时间戳
function encryptWithTimestamp(data) {
const payload = {
data: data,
timestamp: Date.now(), // 当前时间戳
nonce: Math.random().toString(36).substr(2) // 随机数
}
return cryptoUtil.encrypt(JSON.stringify(payload))
}
// 后端解密时验证时间戳
function decryptAndVerify(encryptedData) {
const decrypted = cryptoUtil.decrypt(encryptedData)
const payload = JSON.parse(decrypted)
// 检查时间戳是否在合理范围内(比如5分钟内)
const now = Date.now()
if (now - payload.timestamp > 5 * 60 * 1000) {
throw new Error('请求已过期')
}
// 检查nonce是否使用过(防止重放)
if (this.usedNonces.has(payload.nonce)) {
throw new Error('请求已处理')
}
this.usedNonces.add(payload.nonce)
return payload.data
}
6.3 实际项目中的完整登录流程
结合上面所有的技术点,我给大家展示一个完整的、生产环境可用的登录加密流程:
// 前端登录逻辑
async function handleLogin(username, password) {
try {
// 1. 生成客户端随机数(防止重放)
const clientNonce = generateNonce()
// 2. 获取服务器随机数和时间戳
const { serverNonce, timestamp } = await getServerChallenge()
// 3. 组合密码、时间戳和随机数进行SHA256哈希
const combinedString = `${password}:${timestamp}:${clientNonce}:${serverNonce}`
const passwordHash = CryptoJS.SHA256(combinedString).toString()
// 4. 用AES加密登录请求
const loginData = {
username,
passwordHash,
clientNonce,
timestamp
}
const encryptedData = aesEncrypt(JSON.stringify(loginData))
// 5. 发送加密后的请求
const response = await axios.post('/api/v2/login', {
encryptedData,
signature: signRequest(encryptedData) // 请求签名,防篡改
})
// 6. 处理响应(响应数据也是加密的)
const decryptedResponse = aesDecrypt(response.data.encryptedResult)
return JSON.parse(decryptedResponse)
} catch (error) {
console.error('登录失败:', error)
throw error
}
}
// 辅助函数:生成随机数
function generateNonce() {
return CryptoJS.lib.WordArray.random(16).toString()
}
// 辅助函数:请求签名
function signRequest(data) {
const secret = '你的签名密钥'
return CryptoJS.HmacSHA256(data, secret).toString()
}
这个方案看起来复杂,但安全性很高。它同时防御了多种攻击:
- 防窃听:所有敏感数据都加密了
- 防重放:有时间戳和随机数
- 防篡改:有请求签名
- 防彩虹表:密码哈希时加入了盐值(随机数)
7. 常见问题与调试技巧
做了这么多年项目,我总结了一些大家常遇到的问题和解决方法。
7.1 前端加密了,后端解密失败?
这是最常见的问题,通常是因为前后端的加密参数不一致。检查这几个点:
-
密钥和IV不一致:确保前后端的密钥和IV完全一样,包括长度和编码。我建议在项目文档里明确写出密钥的生成规则。
-
加密模式不同:前端用CBC,后端也要用CBC。我曾经遇到过前端用CBC,后端用ECB,怎么解都解不开的情况。
-
填充方式不同:CryptoJS默认用PKCS7,但有些后端库可能用其他填充方式。
-
编码问题:确保前后端都用UTF-8编码。特别是中文字符,编码不一致会导致解密后乱码。
调试时可以这样排查:
// 前端调试代码
const testData = 'hello world'
const encrypted = cryptoUtil.encrypt(testData)
console.log('加密结果:', encrypted)
console.log('密钥:', CryptoJS.enc.Utf8.stringify(AES_KEY))
console.log('IV:', CryptoJS.enc.Utf8.stringify(AES_IV))
// 把这三个值发给后端同学,让他们用同样的参数解密
7.2 加密后的数据长度问题
AES加密后的数据长度会有变化,这是正常的。因为:
- 数据会被填充到16字节的整数倍
- 输出通常是Base64编码,会比原始数据长大约1/3
如果你发现加密后的数据特别长,可能是重复加密了。比如:
// 错误示例:重复加密
let encrypted = cryptoUtil.encrypt(data)
encrypted = cryptoUtil.encrypt(encrypted) // 又加密了一次!
// 正确做法:只加密一次
const encrypted = cryptoUtil.encrypt(data)
7.3 性能考虑:加密会影响用户体验吗?
对于登录这种低频操作,加密解密的那点性能开销基本可以忽略。但如果你要加密大量数据(比如上传文件),就要注意了。
我做过测试,在主流浏览器上:
- SHA256加密1MB数据大约需要50ms
- AES加密1MB数据大约需要200ms
如果用户网络不好,再加上加密时间,可能会感觉到卡顿。这时候可以考虑:
- 分块加密:大文件分成小块,分批加密上传
- Web Worker:在后台线程加密,不阻塞主线程
- 选择性加密:只加密真正敏感的部分
7.4 兼容性问题
CryptoJS虽然兼容性很好,但在一些老版本浏览器(比如IE10以下)可能会有问题。如果你的项目要支持老浏览器,记得做兼容性测试。
我通常这样处理:
// 检查浏览器是否支持CryptoJS
function isCryptoJSSupported() {
try {
// 尝试执行一个简单的加密操作
const test = CryptoJS.MD5('test').toString()
return typeof test === 'string' && test.length > 0
} catch (e) {
return false
}
}
// 如果不支持,降级方案
if (!isCryptoJSSupported()) {
// 1. 提示用户升级浏览器
// 2. 或者使用更简单的加密方案
// 3. 或者让后端做兼容处理(不推荐,安全性降低)
}
8. 密钥轮换与安全最佳实践
最后聊聊密钥管理,这是加密系统中最容易出问题的地方。
8.1 如何安全地轮换密钥?
密钥不能永远不变,定期轮换是必须的。但轮换密钥有个难题:老数据怎么解密?
我常用的方案是密钥版本管理:
// 密钥配置,支持多个版本
const KEY_CONFIG = {
'v1': { // 版本1的密钥(已废弃,只用于解密老数据)
key: CryptoJS.enc.Utf8.parse('old_key_1234567890'),
iv: CryptoJS.enc.Utf8.parse('old_iv_abcdefgh'),
deprecated: true
},
'v2': { // 版本2的密钥(当前使用)
key: CryptoJS.enc.Utf8.parse('current_key_123456'),
iv: CryptoJS.enc.Utf8.parse('current_iv_abcdef'),
deprecated: false
}
}
// 加密时使用当前版本
function encryptWithVersion(data, version = 'v2') {
const config = KEY_CONFIG[version]
if (!config) {
throw new Error(`不支持的密钥版本:${version}`)
}
// ... 加密逻辑,使用config.key和config.iv
// 在加密结果中包含版本信息
return {
version,
encryptedData: encrypted,
timestamp: Date.now()
}
}
// 解密时根据版本选择密钥
function decryptWithVersion(encryptedPackage) {
const { version, encryptedData } = encryptedPackage
const config = KEY_CONFIG[version]
if (!config) {
throw new Error(`不支持的密钥版本:${version}`)
}
// ... 解密逻辑,使用对应版本的密钥
}
这样当需要轮换密钥时:
- 生成新密钥(v3)
- 新数据用v3加密
- 老数据用对应的版本解密
- 过一段时间后,逐步迁移老数据到新密钥
- 最终废弃老密钥
8.2 监控与告警
加密系统不能“设完就不管”,需要有监控:
- 加密失败率监控:如果突然升高,可能是有兼容性问题
- 解密失败率监控:如果突然升高,可能是密钥不一致或数据被篡改
- 性能监控:加密解密耗时是否在正常范围内
我在项目里会加这样的监控代码:
// 带监控的加密函数
function encryptWithMonitoring(data) {
const startTime = Date.now()
try {
const result = cryptoUtil.encrypt(data)
const endTime = Date.now()
// 上报成功率和耗时
reportMetrics({
type: 'encrypt',
success: true,
duration: endTime - startTime,
dataSize: data.length
})
return result
} catch (error) {
// 上报失败
reportMetrics({
type: 'encrypt',
success: false,
error: error.message
})
throw error
}
}
8.3 最后的建议
在我多年的实践中,有几点经验想分享给大家:
第一,不要自己发明加密算法。密码学是个非常专业的领域,自己写的算法很可能有漏洞。用经过时间检验的库(比如CryptoJS)和标准算法(AES、SHA256)是最稳妥的。
第二,安全是个整体工程。前端加密只是整个安全体系中的一环。还要配合HTTPS、输入验证、输出编码、CSRF防护、XSS防护等措施,才能构建真正安全的系统。
第三,定期更新依赖。CryptoJS虽然稳定,但也会有安全更新。定期检查并更新到最新版本,修复已知漏洞。
第四,做好应急预案。万一加密系统出问题了(比如密钥泄露),要有快速响应方案:如何快速更换密钥?如何通知用户?如何最小化损失?
加密看起来复杂,但用对了工具、理解了原理,其实并没有那么难。关键是要有安全意识,在项目设计阶段就把安全考虑进去,而不是事后补救。
544



被折叠的 条评论
为什么被折叠?



