深入详解在JavaScript中使用现代原生Web Crypto API实现AES与RSA加密算法的具体操作步骤,包含密钥生成、明文转换、加解密流程、完整可运行代码以及AES与RSA混合加密的工程实践方案。
JavaScript中AES和RSA加密算法的实现步骤
时间:2026-11-19
浏览:73
文章目录
在现代 Web 应用中,保护敏感数据(如用户支付信息、身份凭证、离线缓存和高保密业务请求体)常依赖前端加密技术。在现代 JavaScript 环境下,无论是浏览器端还是 Node.js 16+ / Deno / Bun 环境,推荐的加密手段是 W3C 标准的原生 Web Crypto API(通过 crypto.subtle 访问)。与早期的第三方纯 JavaScript 脚本相比,原生 API 由底层宿主(如浏览器底层 BoringSSL / OpenSSL)硬件加速执行,不仅性能极高,还能有效防范侧信道攻击并避免第三方依赖膨胀。本文将完整拆解 AES 对称加密与 RSA 非对称加密的实现步骤、可运行示例及工业级混合加密协同方案。
一、AES 加密算法的实现步骤
AES(Advanced Encryption Standard,高级加密标准)属于对称加密算法,加密与解密使用同一个密钥。在 JavaScript 的 Web Crypto API 中,强烈推荐使用 AES-GCM(Galois/Counter Mode)模式。相较于易受填充攻击的 CBC 模式和完全缺乏随机性的 ECB 模式,AES-GCM 属于 AEAD(带有关联数据的认证加密),能够在加解密的同时校验数据完整性,任何对密文的篡改都会在解密阶段直接报错拒绝。
AES-GCM 核心实现步骤
- 准备或导入密钥(Key):通过
crypto.subtle.generateKey随机生成一个 256 位的CryptoKey对象,或使用crypto.subtle.importKey将服务端约定的原始字节转换为密钥对象。 - 生成独占初始化向量(IV / Nonce):使用
crypto.getRandomValues生成 12 字节(96 位)的随机数。每次加密操作必须使用全新、唯一的 IV,绝不能在同一密钥下重用相同的 IV。 - 明文编码与加密:通过
TextEncoder将 JavaScript 字符串编码为Uint8Array二进制字节流,调用crypto.subtle.encrypt计算密文。返回的ArrayBuffer已自动包含密文与 GCM 认证标签(Auth Tag)。 - 拼接 IV 与密文并导出:解密端必须知晓加密所用的 IV。因此常规做法是将 12 字节的 IV 与密文拼接为一个连续的字节数组,再通过 Base64 编码为字符串便于网络传输。
- 解密与认证还原:接收端先将 Base64 还原为字节数组,切分出前 12 字节 IV 与后续密文,调用
crypto.subtle.decrypt。若密文或标签被修改,Promise 会直接 reject;校验通过后使用TextDecoder恢复原始 UTF-8 字符串。
完整可运行的 AES-GCM 代码示例
以下代码无任何外部依赖,可在现代浏览器控制台或 Node.js 环境中直接复制执行:
// ==========================================
// AES-GCM 对称加解密标准实现
// ==========================================
// 1. 生成 256 位 AES-GCM 对称密钥
async function generateAesKey() {
return await crypto.subtle.generateKey(
{ name: "AES-GCM", length: 256 },
true, // 是否允许导出(测试阶段设为 true)
["encrypt", "decrypt"]
);
}
// 2. AES-GCM 加密函数:明文 -> 包含 IV 的 Base64 密文字符串
async function encryptWithAesGcm(plainText, key) {
const encoder = new TextEncoder();
const data = encoder.encode(plainText);
// GCM 模式推荐使用 12 字节(96 位)的随机 IV
const iv = crypto.getRandomValues(new Uint8Array(12));
// 执行加密,密文末尾会自动追加 16 字节的认证标签 (Auth Tag)
const ciphertextBuffer = await crypto.subtle.encrypt(
{ name: "AES-GCM", iv: iv },
key,
data
);
// 将 12 字节 IV 和密文合并为一个 Uint8Array,便于传输
const combined = new Uint8Array(iv.length + ciphertextBuffer.byteLength);
combined.set(iv, 0);
combined.set(new Uint8Array(ciphertextBuffer), iv.length);
// 转换为 Base64 字符串
return btoa(String.fromCharCode(...combined));
}
// 3. AES-GCM 解密函数:包含 IV 的 Base64 密文 -> 还原明文
async function decryptWithAesGcm(base64Payload, key) {
// 将 Base64 转换为 Uint8Array
const binaryString = atob(base64Payload);
const bytes = new Uint8Array(binaryString.length);
for (let i = 0; i < binaryString.length; i++) {
bytes[i] = binaryString.charCodeAt(i);
}
// 提取前 12 字节的 IV
const iv = bytes.slice(0, 12);
// 提取剩余字节作为密文与 Tag
const ciphertext = bytes.slice(12);
// 执行解密:若密文被篡改,此处将直接抛出异常 (OperationError)
const decryptedBuffer = await crypto.subtle.decrypt(
{ name: "AES-GCM", iv: iv },
key,
ciphertext
);
const decoder = new TextDecoder();
return decoder.decode(decryptedBuffer);
}
// 运行测试
(async () => {
const key = await generateAesKey();
const message = "用户隐私数据:CardNo=62220202028888, Bal=99999.00";
const encrypted = await encryptWithAesGcm(message, key);
console.log("AES-GCM 加密结果 (Base64):", encrypted);
const decrypted = await decryptWithAesGcm(encrypted, key);
console.log("AES-GCM 解密成功:", decrypted);
})();
二、RSA 加密算法的实现步骤
RSA 是最经典的非对称加密算法,拥有一对密钥:公钥(Public Key)和私钥(Private Key)。公钥可以公开发布给前端客户端,任何持有公钥的人都可以加密数据;而私钥严格保存在服务端受信环境中,只有私钥才能解密。
在现代 Web Crypto API 中,RSA 算法的标准加密填充模式为 RSA-OAEP(最优非对称加密填充,带 SHA-256 摘要)。早期的 RSA-PKCS1-v1_5 填充已被密码学界证明存在选择密文攻击(如 Bleichenbacher 填充预言机攻击),在现代前端开发中应一律采用 RSA-OAEP。
RSA-OAEP 核心实现步骤
- 生成密钥对(KeyPair):指定算法名称为
RSA-OAEP,密钥模长设置为 2048 位或 4096 位,公钥指数标准为65537(0x010001),摘要算法选用SHA-256。 - 密钥导出与导入(SPKI / PKCS#8):前端与后端对接时,后端下发的通常是 PEM 格式或 Base64 格式的公钥。前端需要先将公钥 Base64 解析为
ArrayBuffer,通过crypto.subtle.importKey使用spki格式导入为公钥对象。 - 公钥加密(Encrypt):将待加密字符串经
TextEncoder转为字节数组,调用crypto.subtle.encrypt,传入算法参数{ name: "RSA-OAEP" }和公钥对象。 - 私钥解密(Decrypt):持有私钥的一端调用
crypto.subtle.decrypt,将密文 ArrayBuffer 解码还原为明文。
完整可运行的 RSA-OAEP 代码示例
以下示例展示了如何在 JavaScript 中生成符合规范的 RSA-OAEP 密钥对,并完成公钥加密与私钥解密的全流程:
// ==========================================
// RSA-OAEP 非对称加解密标准实现
// ==========================================
// 1. 生成 2048 位 RSA-OAEP 密钥对
async function generateRsaKeyPair() {
return await crypto.subtle.generateKey(
{
name: "RSA-OAEP",
modulusLength: 2048, // 推荐至少 2048 位
publicExponent: new Uint8Array([1, 0, 1]), // 65537
hash: "SHA-256" // 摘要算法
},
true, // 允许导出
["encrypt", "decrypt"]
);
}
// 2. 将 SPKI 格式公钥导出为 Base64 字符串(供前后端传输)
async function exportPublicKeyBase64(publicKey) {
const exported = await crypto.subtle.exportKey("spki", publicKey);
return btoa(String.fromCharCode(...new Uint8Array(exported)));
}
// 3. 将 Base64 格式公钥导入为 CryptoKey 对象
async function importPublicKeyFromBase64(base64Spki) {
const binaryString = atob(base64Spki);
const bytes = new Uint8Array(binaryString.length);
for (let i = 0; i < binaryString.length; i++) {
bytes[i] = binaryString.charCodeAt(i);
}
return await crypto.subtle.importKey(
"spki",
bytes.buffer,
{ name: "RSA-OAEP", hash: "SHA-256" },
true,
["encrypt"]
);
}
// 4. RSA-OAEP 公钥加密:明文 -> Base64 密文 (注意长度限制 < 190 字节)
async function encryptWithRsaOaep(plainText, publicKey) {
const encoder = new TextEncoder();
const data = encoder.encode(plainText);
const ciphertextBuffer = await crypto.subtle.encrypt(
{ name: "RSA-OAEP" },
publicKey,
data
);
return btoa(String.fromCharCode(...new Uint8Array(ciphertextBuffer)));
}
// 5. RSA-OAEP 私钥解密:Base64 密文 -> 原始明文
async function decryptWithRsaOaep(base64Ciphertext, privateKey) {
const binaryString = atob(base64Ciphertext);
const bytes = new Uint8Array(binaryString.length);
for (let i = 0; i < binaryString.length; i++) {
bytes[i] = binaryString.charCodeAt(i);
}
const decryptedBuffer = await crypto.subtle.decrypt(
{ name: "RSA-OAEP" },
privateKey,
bytes.buffer
);
const decoder = new TextDecoder();
return decoder.decode(decryptedBuffer);
}
// 运行测试
(async () => {
const keyPair = await generateRsaKeyPair();
const secretPassword = "UserTopSecretPassword_2026!";
// 导出公钥并模拟前端重新导入
const spkiBase64 = await exportPublicKeyBase64(keyPair.publicKey);
const importedPubKey = await importPublicKeyFromBase64(spkiBase64);
// 公钥加密
const encrypted = await encryptWithRsaOaep(secretPassword, importedPubKey);
console.log("RSA-OAEP 加密结果 (Base64, 定长 256 字节):", encrypted);
// 私钥解密
const decrypted = await decryptWithRsaOaep(encrypted, keyPair.privateKey);
console.log("RSA-OAEP 解密还原:", decrypted);
})();
三、核心认知辨析与工程实践:混合加密架构
原因剖析:这种设想在现实中会直接导致程序崩溃或严重的性能衰减,原因有二:
1. 严格的容量天花板:RSA 算法在数学上要求明文数值必须严格小于模数 N。叠加 OAEP 填充后,单次最大加密明文长度公式为:明文字节数 ≤ 模数字节数 - 2 × Hash字节数 - 2。在常见的 2048 位密钥配合 SHA-256 下,单次最大允许明文仅为 190 字节(256 - 64 - 2 = 190)!只要请求 JSON 超过 190 字节,调用 encrypt 会立刻抛出 OperationError 异常。
2. 极高的 CPU 计算开销:RSA 的大数模幂运算极其消耗计算资源,耗时是 AES 对称加密的数百到上千倍。若在前端对大数据块进行分段 RSA 加密,会导致前端主线程严重卡顿掉帧,服务端在高并发下也会被 RSA 解密耗尽 CPU。
原因剖析:不能。前端加密防范的威胁模型是“中间网关抓包审计防偷窥、应用日志留存防脱敏泄露、防离线静态落库数据泄露”。但如果没有传输层 HTTPS 协议,攻击者可以通过中间人(MITM)篡改前端加载的 JavaScript 代码本身,直接将代码中的加密逻辑剥离或替换为你未知的公钥。因此,前端业务加密是应用层的纵深防御,绝不可替代传输层 TLS/HTTPS。
生产级解决方案:RSA + AES 混合加密(Hybrid Encryption)
为了兼得“RSA 的安全密钥交换”与“AES 的高速大容量”,现代软件工程普遍采用混合加密架构:
- 会话秘钥动态化:前端发起请求时,动态生成一个一次性的随机 256 位 AES 密钥(Session Key)和 12 字节 IV。
- AES 快速加密内容:用该一次性 AES 密钥快速加密任意大小的业务 JSON 数据(微秒级完成,无长度限制)。
- RSA 封装保护秘钥:用后端的 RSA 公钥加密这串 32 字节的 AES 密钥(32 字节远小于 190 字节上限,安全合规)。
- 打包封发:将
{ encryptedKey, iv, ciphertext }封装为统一通信信封(Envelope)提交给后端。
混合加密封装实战代码
// ==========================================
// 生产级:RSA + AES-GCM 混合加密封包实现
// ==========================================
async function hybridEncryptPayload(businessPayloadObject, backendRsaPublicKey) {
// 1. 将业务大对象序列化为 UTF-8 字节流
const jsonString = JSON.stringify(businessPayloadObject);
const payloadBytes = new TextEncoder().encode(jsonString);
// 2. 前端动态生成一次性 256 位 AES-GCM 对称密钥
const sessionKey = await crypto.subtle.generateKey(
{ name: "AES-GCM", length: 256 },
true, // 允许导出以供 RSA 加密
["encrypt"]
);
// 3. 生成 12 字节随机 IV
const iv = crypto.getRandomValues(new Uint8Array(12));
// 4. 用 AES-GCM 加密业务数据
const ciphertextBuffer = await crypto.subtle.encrypt(
{ name: "AES-GCM", iv: iv },
sessionKey,
payloadBytes
);
// 5. 导出 AES 原始密钥二进制 (32 字节 raw 格式)
const rawSessionKey = await crypto.subtle.exportKey("raw", sessionKey);
// 6. 用后端 RSA-OAEP 公钥加密该 32 字节的 AES 密钥
const encryptedKeyBuffer = await crypto.subtle.encrypt(
{ name: "RSA-OAEP" },
backendRsaPublicKey,
rawSessionKey
);
// 7. 组装为可直接发起 HTTP POST 请求的 JSON 信封
return {
// RSA 加密后的 AES 密钥 (Base64)
encryptedKey: btoa(String.fromCharCode(...new Uint8Array(encryptedKeyBuffer))),
// AES 初始化向量 (Base64)
iv: btoa(String.fromCharCode(...iv)),
// AES 加密后的业务密文含 Tag (Base64)
ciphertext: btoa(String.fromCharCode(...new Uint8Array(ciphertextBuffer)))
};
}
四、AES 与 RSA 核心指标对比与避坑指南
在实际项目落地时,开发者需要清晰把握两者的特性差异与底层选型边界,如下表所示:
| 对比指标 | AES 对称加密 (推荐 GCM) | RSA 非对称加密 (推荐 OAEP) |
|---|---|---|
| 核心机制 | 单密钥共享(加解密同一密钥) | 公钥与私钥配对(公钥加密,私钥解密) |
| 推荐强度 | AES-256 (256-bit 密钥) | RSA-2048 位或 RSA-4096 位 |
| 单次加密容量 | 无实际限制(支持数十 GB 级流式加密) | 严格受限(2048位 + SHA256 仅能加密 190 字节) |
| 运行耗时与性能 | 硬件级微秒级执行,吞吐极高 | 大数模幂计算,耗时高出 AES 100~1000 倍 |
| 核心应用场景 | 大体积业务报文加密、文件加密、本地存储 | 密钥安全交换、数字签名、敏感极短凭证传输 |
| 关键避坑点 | IV 必须全局随机唯一,严禁重复使用 | 严禁使用过时的 PKCS#1 v1.5 填充方式 |
开发避坑要点速查
- IV 重用是 AES-GCM 的致命死穴:在 GCM 模式下,如果在同一个 Key 下使用了完全相同的 IV,攻击者可以通过异或密文直接恢复出明文异或值,并且伪造后续认证标签。因此,必须使用密码学安全随机数
crypto.getRandomValues为每一次加密生成全新独立的 IV。 - 跨语言对齐格式(如 Java / Go / Python 与前端交互):
- AES-GCM:确认服务端所采用的 Tag 长度是否默认为 128 位(16 字节)。Web Crypto API 默认输出尾部包含 16 字节 Tag 的密文。若后端使用的是 Java
Cipher.getInstance("AES/GCM/NoPadding"),需注意 Java 的doFinal()同样将 Tag 附加在末尾,无需额外处理。 - RSA-OAEP:务必确保两端的哈希算法完全一致(统一推荐
SHA-256)。若一端使用 SHA-1 而另一端使用 SHA-256,解密将直接抛出校验失败错误。
- AES-GCM:确认服务端所采用的 Tag 长度是否默认为 128 位(16 字节)。Web Crypto API 默认输出尾部包含 16 字节 Tag 的密文。若后端使用的是 Java
- 私钥永不下发:非对称加密的安全边界建立在“私钥不离开受控服务端”的前提上。任何将 RSA 私钥打包或通过接口下发至前端的做法,都会直接导致非对称体系瓦解。
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。