Web 聊天室消息加解密方案详解

场景 2：群聊加密

1. 群密钥分发：创建者生成群密钥，用成员公钥加密后分发，确保只有成员能解出群密钥。
2. 消息传输：发送方用群密钥加密，服务器转发，所有成员用群密钥解密。
3. 密钥更新：成员变更时，重新生成群密钥并分发，旧成员自动失效。

2.1.4 代码实现（前端 + 后端）

前端（Vue3 + Web Crypto API）

// 1. 生成 AES-256 密钥（extractable: false 防止导出）
async function generateAesKey() {
  const key = await crypto.subtle.generateKey(
    { name: "AES-GCM", length: 256 },
    false,
    ["encrypt", "decrypt"]
  );
  return key;
}

// 2. AES-GCM 加密（注意参数补全）
async function aesGcmEncrypt(plaintext, aesKey, additionalData = "") {
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const plaintextUint8 = new TextEncoder().encode(plaintext);
  const adUint8 = new TextEncoder().encode(additionalData);

  const encrypted = await crypto.subtle.encrypt(
    { name: "AES-GCM", iv: iv, additionalData: adUint8, tagLength: 128 },
    aesKey,
    plaintextUint8
  );

  const encryptedUint8 = new Uint8Array(encrypted);
  // 最后 16 字节是标签
  const ciphertext = encryptedUint8.slice(0, encryptedUint8.length - 16);
  const tag = encryptedUint8.slice(encryptedUint8.length - 16);

  const combined = new Uint8Array([...iv, ...ciphertext, ...tag]);
  return btoa(String.fromCharCode(...combined));
}

// 3. AES-GCM 解密
async function aesGcmDecrypt(base64Str, aesKey, additionalData = "") {
  const combined = new Uint8Array(
    atob(base64Str).split("").map(c => c.charCodeAt(0))
  );
  
  const iv = combined.slice(0, 12);
  const tag = combined.slice(combined.length - 16);
  const ciphertext = combined.slice(12, combined.length - 16);
  const adUint8 = new TextEncoder().encode(additionalData);

  try {
    const decrypted = await crypto.subtle.decrypt(
      { name: "AES-GCM", iv: iv, additionalData: adUint8, tagLength: 128 },
      aesKey,
      new Uint8Array([...ciphertext, ...tag])
    );
    return new TextDecoder().decode(decrypted);
  } catch (err) {
    throw new Error("密文被篡改或密钥错误");
  }
}

// 4. 单聊消息发送示例
async function sendPrivateMessage(toUserId, plaintext, aesKey) {
  const messageId = uuidv4();
  const encryptedStr = await aesGcmEncrypt(plaintext, aesKey, messageId);
  socket.emit("privateMessage", {
    toUserId,
    messageId,
    encryptedStr,
    timestamp: Date.now()
  });
}

后端（Node.js + crypto）

后端主要承担转发职责，不处理解密逻辑以保护密钥安全。若需验证完整性可添加签名校验。

const express = require("express");
const http = require("http");
const { Server } = require("socket.io");

const app = express();
const server = http.createServer(app);
const io = new Server(server, {
  cors: { origin: "http://localhost:8080" }
});

const userMap = new Map();

io.on("connection", (socket) => {
  socket.on("userRegister", (userId, eccPublicKey) => {
    userMap.set(userId, { socketId: socket.id, eccPublicKey });
    socket.userId = userId;
    console.log(`用户${userId}上线`);
  });

  socket.on("privateMessage", (data) => {
    const { toUserId, messageId, encryptedStr, timestamp } = data;
    const targetUser = userMap.get(toUserId);
    if (targetUser) {
      io.to(targetUser.socketId).emit("privateMessage", {
        fromUserId: socket.userId,
        messageId,
        encryptedStr,
        timestamp
      });
    }
  });

  socket.on("groupMessage", (groupData) => {
    const { groupId, encryptedStr, messageId, timestamp } = groupData;
    io.to(groupId).emit("groupMessage", {
      fromUserId: socket.userId,
      messageId,
      encryptedStr,
      timestamp
    });
  });
});

server.listen(3000, () => console.log("后端服务启动：3000 端口"));

2.1.5 优劣分析

2.2 方案 2：非对称加密（RSA-2048/ECC secp256r1）

2.2.1 方案概述

非对称加密使用密钥对（公钥 + 私钥）。ECC（椭圆曲线加密）在同等安全性下密钥更短，性能优于 RSA，更适合 Web 场景。

2.2.2 核心原理

1. ECC secp256r1：基于有限域上的椭圆方程。私钥为随机整数，公钥为曲线上点。通过临时随机数派生共享密钥。
2. RSA-2048：基于大数分解问题。适合兼容旧系统，但加密长度受限（最大约 245 字节）。

2.2.3 实现步骤（分场景）

场景 1：单聊加密（ECC）

1. 密钥分发：用户生成密钥对，公钥上传服务器，私钥本地保存。
2. 消息加密：发送方用接收方公钥生成临时密钥，派生 AES 密钥加密消息，发送临时公钥 + 密文。
3. 消息解密：接收方用私钥派生相同 AES 密钥解密。

场景 2：群聊加密（ECC）

直接加密会导致 N 个成员需加密 N 次。优化方案是发送方生成临时 AES 群密钥，用每个成员公钥加密该 AES 密钥，再发送'加密的 AES 密钥 + AES 加密的消息'。

2.2.4 代码实现（前端 ECC 加密）

使用 libsodium-wrappers 库简化操作：

import sodium from "libsodium-wrappers";
await sodium.ready;

// 1. 生成 ECC secp256r1 密钥对
function generateEccKeyPair() {
  const keyPair = sodium.crypto_box_keypair();
  return {
    privateKey: sodium.to_base64(keyPair.privateKey),
    publicKey: sodium.to_base64(keyPair.publicKey)
  };
}

// 2. ECC 加密
function eccEncrypt(plaintext, receiverPkBase64, senderSkBase64) {
  const receiverPk = sodium.from_base64(receiverPkBase64);
  const senderSk = sodium.from_base64(senderSkBase64);
  const nonce = sodium.randombytes_buf(sodium.crypto_box_NONCEBYTES);
  
  const ciphertext = sodium.crypto_box_easy(
    sodium.encode_utf8(plaintext),
    nonce,
    receiverPk,
    senderSk
  );
  
  const combined = sodium.concat([nonce, ciphertext]);
  return sodium.to_base64(combined);
}

// 3. ECC 解密
function eccDecrypt(encryptedBase64, senderPkBase64, receiverSkBase64) {
  const senderPk = sodium.from_base64(senderPkBase64);
  const receiverSk = sodium.from_base64(receiverSkBase64);
  const combined = sodium.from_base64(encryptedBase64);
  
  const nonce = combined.slice(0, sodium.crypto_box_NONCEBYTES);
  const ciphertext = combined.slice(sodium.crypto_box_NONCEBYTES);
  
  try {
    const plaintext = sodium.crypto_box_open_easy(
      ciphertext, nonce, senderPk, receiverSk
    );
    return sodium.decode_utf8(plaintext);
  } catch (err) {
    throw new Error("解密失败：密钥错误或密文篡改");
  }
}

// 单聊发送示例
const userAKeyPair = generateEccKeyPair();
const userBPublicKey = "xxx"; // 从服务器获取
const plaintext = "Hello, 非对称加密单聊！";
const encryptedStr = eccEncrypt(plaintext, userBPublicKey, userAKeyPair.privateKey);

socket.emit("privateMessage", {
  toUserId: "userB",
  encryptedStr,
  fromUserPublicKey: userAKeyPair.publicKey
});

2.2.5 优劣分析

2.3 方案 3：混合加密（AES-256-GCM + ECC secp256r1）

2.3.1 方案概述

混合加密结合了对称加密的高性能与非对称加密的密钥分发优势，类似 TLS 协议原理，是 Web 聊天室的最优解之一。

2.3.2 核心原理

1. 密钥交换（ECDH）：双方通过 ECDH 协议派生共享密钥，无需传输密钥本身。
2. 消息传输（AES-GCM）：用派生的 AES 密钥加密实际消息，保证高速传输。
3. 前向安全：每次会话生成新的 ECC 密钥对，确保历史消息安全。

2.3.3 实现步骤（单聊 + 群聊）

场景 1：单聊加密（完整流程）

1. 密钥协商：A 生成临时密钥对发送给 B，B 返回其长期公钥；双方各自计算共享点 S，派生 AES 密钥。
2. 消息加密：使用派生的 AES 密钥加密消息。
3. 会话更新：每发送一定数量消息或超时后，重新执行 ECDH 协商。

场景 2：群聊加密（优化方案）

群创建者生成 AES 群密钥，用每个成员的公钥加密该密钥后分发。成员收到后解密得到群密钥，后续消息直接用群密钥加密。

2.3.4 代码实现（前端 ECDH 密钥协商 + AES 加密）

// 1. 生成 ECC 长期密钥对
async function generateLongEccKeyPair() {
  const keyPair = await crypto.subtle.generateKey(
    { name: "ECDH", namedCurve: "P-256" },
    true,
    ["deriveKey"]
  );
  const publicKeyRaw = await crypto.subtle.exportKey("spki", keyPair.publicKey);
  const publicKeyBase64 = btoa(String.fromCharCode(...new Uint8Array(publicKeyRaw)));
  return {
    privateKey: keyPair.privateKey,
    publicKey: publicKeyBase64
  };
}

// 2. ECDH 派生 AES 密钥
async function deriveAesKey(localPrivateKey, peerPublicKeyBase64) {
  const peerPublicKeyRaw = new Uint8Array(
    atob(peerPublicKeyBase64).split("").map(c => c.charCodeAt(0))
  );
  const peerPublicKey = await crypto.subtle.importKey(
    "spki", peerPublicKeyRaw,
    { name: "ECDH", namedCurve: "P-256" },
    false, []
  );

  const sharedSecret = await crypto.subtle.deriveKey(
    { name: "ECDH", public: peerPublicKey },
    localPrivateKey,
    { name: "AES-GCM", length: 256 },
    false, ["encrypt", "decrypt"]
  );
  return sharedSecret;
}

// 3. 单聊完整流程示例
async function initPrivateChat(withUserId) {
  const localLongKeyPair = await loadLocalLongKeyPair();
  const peerLongPublicKey = await axios.get(`/api/user/${withUserId}/publicKey`);
  
  const localTempKeyPair = await crypto.subtle.generateKey(
    { name: "ECDH", namedCurve: "P-256" }, true, ["deriveKey"]
  );
  const localTempPublicKeyRaw = await crypto.subtle.exportKey("spki", localTempKeyPair.publicKey);
  const localTempPublicKey = btoa(String.fromCharCode(...new Uint8Array(localTempPublicKeyRaw)));

  const peerTempPublicKey = await new Promise((resolve) => {
    socket.emit("requestTempPublicKey", { toUserId: withUserId, localTempPublicKey });
    socket.once("responseTempPublicKey", (data) => resolve(data.peerTempPublicKey));
  });

  const aesKey = await deriveAesKey(localTempKeyPair.privateKey, peerTempPublicKey);
  const plaintext = "混合加密单聊消息：AES+ECC";
  const messageId = uuidv4();
  const encryptedStr = await aesGcmEncrypt(plaintext, aesKey, messageId);

  socket.emit("privateMessage", { toUserId, messageId, encryptedStr });

  socket.on("privateMessage", async (data) => {
    if (data.fromUserId === withUserId) {
      const decryptedText = await aesGcmDecrypt(data.encryptedStr, aesKey, data.messageId);
      console.log("解密消息：", decryptedText);
    }
  });
}

2.3.5 优劣分析

2.4 方案 4：端到端加密（基于 Signal Protocol）

2.4.1 方案概述

Signal Protocol 是专为即时通讯设计的端到端加密方案，被 WhatsApp、Signal 等采用，提供顶级安全性，支持单聊/群聊、前向安全及抗重放攻击。

2.4.2 核心原理

1. 双棘轮算法：结合对称棘轮与不对称棘轮，每次交互更新密钥，确保前向安全。
2. 预密钥机制：用户提前上传一批预密钥，支持离线发起会话。
3. Sender Key 机制：群聊中生成 Sender Key，发送方加密消息，成员解密。

2.4.3 实现步骤（单聊场景）

1. 初始化：生成身份密钥、签名密钥、预密钥，上传公钥到服务器。
2. 会话建立：A 获取 B 的预密钥，生成临时密钥对，派生初始会话密钥。
3. 持续更新：每发送消息更新发送密钥，定期更新预密钥。

2.4.4 代码实现（基于 libsignal-protocol-javascript）

import * as signal from "libsignal-protocol-javascript";

class SignalStore {
  constructor() {\n    this.identityKeyPair = null;
    this.preKeys = new Map();
    this.signedPreKey = null;
    this.sessions = new Map();
  }
  putIdentityKeyPair(keyPair) { this.identityKeyPair = keyPair; }
  getIdentityKeyPair() { return this.identityKeyPair; }
  storePreKey(id, preKey) { this.preKeys.set(id, preKey); }
  getPreKey(id) { return this.preKeys.get(id); }
  storeSession(addr, session) { this.sessions.set(addr, session); }
  loadSession(addr) { return this.sessions.get(addr); }
}

async function registerSignalUser(userId) {
  const store = new SignalStore();
  const keyHelper = signal.KeyHelper;
  
  const identityKeyPair = await keyHelper.generateIdentityKeyPair();
  store.putIdentityKeyPair(identityKeyPair);
  
  const signedPreKey = await keyHelper.generateSignedPreKey(
    identityKeyPair, Math.floor(Date.now() / 1000)
  );
  store.signedPreKey = signedPreKey;
  
  for (let i = 0; i < 100; i++) {
    const preKey = await keyHelper.generatePreKey(i);
    store.storePreKey(preKey.keyId, preKey);
  }

  await axios.post("/api/signal/register", {
    userId,
    identityPublicKey: Buffer.from(identityKeyPair.pubKey).toString("base64"),
    signedPreKey: {
      keyId: signedPreKey.keyId,
      publicKey: Buffer.from(signedPreKey.pubKey).toString("base64"),
      signature: Buffer.from(signedPreKey.signature).toString("base64")
    },
    preKeys: Array.from(store.preKeys.entries()).map(([id, pk]) => ({
      keyId: id,
      publicKey: Buffer.from(pk.pubKey).toString("base64")
    }))
  });
  return store;
}

async function initSignalChat(store, targetUserId) {
  const keyHelper = signal.KeyHelper;
  const address = new signal.SignalProtocolAddress(targetUserId, 1);
  const targetPubKeys = await axios.get(`/api/signal/user/${targetUserId}/keys`);
  
  const ephemeralKeyPair = await keyHelper.generateEphemeralKeyPair();
  const sessionBuilder = new signal.SessionBuilder(store, address);

  await sessionBuilder.processPreKey({
    registrationId: 1,
    identityKey: Buffer.from(targetPubKeys.identityPublicKey, "base64"),
    signedPreKey: {
      keyId: targetPubKeys.signedPreKey.keyId,
      publicKey: Buffer.from(targetPubKeys.signedPreKey.publicKey, "base64"),
      signature: Buffer.from(targetPubKeys.signedPreKey.signature, "base64")
    },
    preKey: {
      keyId: targetPubKeys.preKey.keyId,
      publicKey: Buffer.from(targetPubKeys.preKey.publicKey, "base64")
    }
  });

  const sessionCipher = new signal.SessionCipher(store, address);
  const plaintext = "Signal Protocol 端到端加密消息";
  const ciphertext = await sessionCipher.encrypt(Buffer.from(plaintext, "utf8"));

  socket.emit("signalMessage", {
    toUserId: targetUserId,
    ciphertext: {
      type: ciphertext.type,
      ephemeralKeyId: ciphertext.ephemeralKeyId,
      ciphertext: Buffer.from(ciphertext.body).toString("base64")
    }
  });

  socket.on("signalMessage", async (data) => {
    if (data.fromUserId === targetUserId) {
      const decryptCiphertext = {
        type: data.ciphertext.type,
        ephemeralKeyId: data.ciphertext.ephemeralKeyId,
        body: Buffer.from(data.ciphertext.ciphertext, "base64")
      };
      const decrypted = await sessionCipher.decrypt(decryptCiphertext);
      console.log("解密消息：", decrypted.toString("utf8"));
    }
  });
}

2.4.5 优劣分析

2.5 方案 5：轻量级加密（ChaCha20-Poly1305）

2.5.1 方案概述

ChaCha20 是 Google 设计的流密码，Poly1305 是高效 MAC。两者组合适合低性能设备，无需 AES 硬件加速，纯软件实现速度比 AES-GCM 快 30%~50%。

2.5.2 核心原理

1. ChaCha20：输入密钥、Nonce 和计数器，生成密钥流与明文异或。
2. Poly1305：计算认证标签，验证密文完整性。

2.5.3 实现步骤（单聊场景）

1. 密钥生成：生成 32 字节 ChaCha20 密钥。
2. 加密：生成 96 位 Nonce，加密明文，计算标签，发送 Nonce+ 密文 + 标签。
3. 解密：拆分数据，生成密钥流解密，验证标签。

2.5.4 代码实现（前端 libsodium）

import sodium from "libsodium-wrappers";
await sodium.ready;

function generateChaChaKey() {
  return sodium.to_base64(sodium.randombytes_buf(sodium.crypto_aead_chacha20poly1305_ietf_KEYBYTES));
}

function chachaEncrypt(plaintext, keyBase64, additionalData = "") {
  const key = sodium.from_base64(keyBase64);
  const nonce = sodium.randombytes_buf(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
  const ad = sodium.encode_utf8(additionalData);

  const ciphertext = sodium.crypto_aead_chacha20poly1305_ietf_encrypt(
    sodium.encode_utf8(plaintext), ad, null, nonce, key
  );
  
  const combined = sodium.concat([nonce, ciphertext]);
  return sodium.to_base64(combined);
}

function chachaDecrypt(encryptedBase64, keyBase64, additionalData = "") {
  const key = sodium.from_base64(keyBase64);
  const combined = sodium.from_base64(encryptedBase64);
  const nonce = combined.slice(0, sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
  const ciphertext = combined.slice(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
  const ad = sodium.encode_utf8(additionalData);

  try {
    const plaintext = sodium.crypto_aead_chacha20poly1305_ietf_decrypt(
      null, ciphertext, ad, nonce, key
    );
    return sodium.decode_utf8(plaintext);
  } catch (err) {
    throw new Error("解密失败：标签不匹配");
  }
}

// 单聊发送示例
const chachaKey = generateChaChaKey();
const plaintext = "低性能设备友好：ChaCha20 加密";
const encryptedStr = chachaEncrypt(plaintext, chachaKey, "messageId_123");

socket.emit("privateMessage", {
  toUserId: "userB",
  encryptedStr,
  keyId: "chacha_key_001"
});

2.5.5 优劣分析