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

后端（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.userId = null;

  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 核心原理

• ECC secp256r1：基于椭圆曲线离散对数问题，公钥为曲线上点，私钥为整数。
• RSA-2048：基于大数分解，最大加密长度受限（约 245 字节）。

2.2.3 实现步骤

单聊加密（ECC）

1. 密钥分发：双方交换公钥至服务器。
2. 消息加密：发送方生成临时随机数，派生共享密钥 K，用 K 加密明文（如 AES），发送临时点 C1 + 密文。
3. 消息解密：接收方用私钥派生 K，解密明文。

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

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

推荐使用 libsodium-wrappers 库，它对 ECC 的支持更完善。

import sodium from "libsodium-wrappers";

await sodium.ready;

function generateEccKeyPair() {
  const keyPair = sodium.crypto_box_keypair();
  return {
    privateKey: sodium.to_base64(keyPair.privateKey),
    publicKey: sodium.to_base64(keyPair.publicKey)
  };
}

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);
}

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("解密失败：密钥错误或密文篡改");
  }
}

2.2.5 优劣分析

• 优点：密钥分发安全，支持身份认证，前向安全性好，私钥本地存储。
• 缺点：性能较差，消息长度受限，群聊延迟高，部分旧浏览器不支持。

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

2.3.1 方案概述

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

2.3.2 核心原理

1. 密钥交换（ECDH）：双方无需传输密钥，通过各自密钥对派生相同的共享密钥。
2. 消息传输（AES-GCM）：用派生的 AES 密钥加密消息，实现高速传输。

2.3.3 实现步骤

单聊完整流程

1. 密钥协商：A 发送临时公钥给 B，B 返回长期公钥；双方 ECDH 派生共享密钥，拉伸为 AES 密钥。
2. 消息加密：用 AES 密钥加密消息。
3. 会话更新：定期重新协商密钥，保证前向安全性。

群聊优化 群主生成 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 等采用，提供强安全性，支持前向安全性和抗重放攻击。

2.4.2 核心原理

1. 双棘轮算法：结合对称棘轮与非对称棘轮，每次消息交互后更新密钥。
2. 预密钥机制：用户生成一批预密钥上传服务器，支持离线发起会话。
3. Sender Key 机制：群聊内生成 Sender Key，发送方加密消息，成员解密。

2.4.3 实现步骤

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

2.4.4 代码实现

推荐官方维护的 libsignal-protocol-javascript 库。

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

class SignalStore {
  constructor() {
    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 是流密码，Poly1305 是高效消息认证码。组合后适合低性能设备，无需 AES 硬件加速，纯软件实现速度比 AES-GCM 快。

2.5.2 核心原理

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

2.5.3 实现步骤

1. 密钥生成：生成 32 字节 ChaCha20 密钥。
2. 加密：生成 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 优劣分析

• 优点：性能优异，兼容性好，适合低性能设备。
• 缺点：密钥分发问题同 AES，需非对称加密辅助。