JavaScript中AES和RSA加密算法的实现步骤

作者:白帽猫时间:2026-11-19 11:38:01浏览:72

深入详解在JavaScript中使用现代原生Web Crypto API实现AES与RSA加密算法的具体操作步骤,包含密钥生成、明文转换、加解密流程、完整可运行代码以及AES与RSA混合加密的工程实践方案。

在现代 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 核心实现步骤

  1. 准备或导入密钥(Key):通过 crypto.subtle.generateKey 随机生成一个 256 位的 CryptoKey 对象,或使用 crypto.subtle.importKey 将服务端约定的原始字节转换为密钥对象。
  2. 生成独占初始化向量(IV / Nonce):使用 crypto.getRandomValues 生成 12 字节(96 位)的随机数。每次加密操作必须使用全新、唯一的 IV,绝不能在同一密钥下重用相同的 IV。
  3. 明文编码与加密:通过 TextEncoder 将 JavaScript 字符串编码为 Uint8Array 二进制字节流,调用 crypto.subtle.encrypt 计算密文。返回的 ArrayBuffer 已自动包含密文与 GCM 认证标签(Auth Tag)。
  4. 拼接 IV 与密文并导出:解密端必须知晓加密所用的 IV。因此常规做法是将 12 字节的 IV 与密文拼接为一个连续的字节数组,再通过 Base64 编码为字符串便于网络传输。
  5. 解密与认证还原:接收端先将 Base64 还原为字节数组,切分出前 12 字节 IV 与后续密文,调用 crypto.subtle.decrypt。若密文或标签被修改,Promise 会直接 reject;校验通过后使用 TextDecoder 恢复原始 UTF-8 字符串。
JavaScript中AES和RSA加密算法的实现步骤
图 1:Web Crypto API 中 AES-GCM 认证加密与解密全生命周期流程

完整可运行的 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 核心实现步骤

  1. 生成密钥对(KeyPair):指定算法名称为 RSA-OAEP,密钥模长设置为 2048 位或 4096 位,公钥指数标准为 65537(0x010001),摘要算法选用 SHA-256。
  2. 密钥导出与导入(SPKI / PKCS#8):前端与后端对接时,后端下发的通常是 PEM 格式或 Base64 格式的公钥。前端需要先将公钥 Base64 解析为 ArrayBuffer,通过 crypto.subtle.importKey 使用 spki 格式导入为公钥对象。
  3. 公钥加密(Encrypt):将待加密字符串经 TextEncoder 转为字节数组,调用 crypto.subtle.encrypt,传入算法参数 { name: "RSA-OAEP" } 和公钥对象。
  4. 私钥解密(Decrypt):持有私钥的一端调用 crypto.subtle.decrypt,将密文 ArrayBuffer 解码还原为明文。
JavaScript中AES和RSA加密算法的实现步骤
图 2:Web Crypto API 中 RSA-OAEP 密钥对生成、公私钥拆分与加解密流程

完整可运行的 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 具备公私钥分离的优势,前端为什么不能直接对所有接口请求体使用 RSA 加密?”

原因剖析:这种设想在现实中会直接导致程序崩溃或严重的性能衰减,原因有二:

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。

认知辨析 2:“前端加密完成了,是不是就可以脱离 HTTPS 裸奔了?”

原因剖析:不能。前端加密防范的威胁模型是“中间网关抓包审计防偷窥、应用日志留存防脱敏泄露、防离线静态落库数据泄露”。但如果没有传输层 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)提交给后端。
JavaScript中AES和RSA加密算法的实现步骤
图 3:RSA + AES 混合加密前后端端到端安全协同工作流程

混合加密封装实战代码

// ==========================================
// 生产级: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 填充方式
JavaScript中AES和RSA加密算法的实现步骤
图 4:AES 与 RSA 核心性能指标与工程选型决策矩阵

开发避坑要点速查

  • 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,解密将直接抛出校验失败错误。
  • 私钥永不下发:非对称加密的安全边界建立在“私钥不离开受控服务端”的前提上。任何将 RSA 私钥打包或通过接口下发至前端的做法,都会直接导致非对称体系瓦解。
作者最新文章
相关文章
更多