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

目录

​编辑

一、Web 聊天室消息加解密需求与技术约束

1.1 核心安全需求

1.2 技术约束

二、主流消息加解密方案详解

2.1 方案 1：对称加密（AES-256-GCM）

2.1.1 方案概述

2.1.2 核心原理

2.1.3 实现步骤（分场景）

场景 1：单聊加密

场景 2：群聊加密

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

前端（Vue3 + Web Crypto API）

后端（Node.js + crypto）

2.1.5 优劣分析

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

2.2.1 方案概述

2.2.2 核心原理

（1）ECC secp256r1 原理（推荐）

（2）RSA-2048 原理（兼容旧系统）

2.2.3 实现步骤（分场景）

场景 1：单聊加密（ECC）

场景 2：群聊加密（ECC）

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

2.2.5 优劣分析

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

2.3.1 方案概述

2.3.2 核心原理

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

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

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

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

2.3.5 优劣分析

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

2.4.1 方案概述

2.4.2 核心原理

2.4.3 实现步骤（单聊场景）

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

2.4.5 优劣分析

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

2.5.1 方案概述

2.5.2 核心原理

2.5.3 实现步骤（单聊场景）

2.5.4 代码实现（前端 libsodium）

2.5.5 优劣分析

一、Web 聊天室消息加解密需求与技术约束

Web 聊天室基于 WebSocket/Socket.IO 实现实时双向通信，消息类型涵盖文本、图片、文件，场景包括单聊、群聊、广播。其安全风险主要集中在消息监听（中间人攻击）、内容篡改、身份冒充、数据泄露（服务器存储未加密消息），需通过加密方案满足核心安全需求，同时兼顾实时性与兼容性。

1.1 核心安全需求

1.2 技术约束

1. 实时性：加密解密耗时需控制在毫秒级，避免 WebSocket 消息延迟（如群聊消息发送后需秒级展示）；
2. 浏览器兼容性：前端需基于 JS 实现加密，依赖浏览器对加密 API 的支持（如 Web Crypto API、第三方库）；
3. 前后端协同：前后端需统一加密算法、密钥格式、数据传输格式（如 IV / 密文 / 标签的拼接规则）；
4. 设备适配：支持低性能设备（如旧手机 WebView），避免算法对硬件加速的强依赖；
5. 密钥管理：前端私钥存储需安全（避免 localStorage 泄露），群聊密钥分发需高效。

二、主流消息加解密方案详解

2.1 方案 1：对称加密（AES-256-GCM）

2.1.1 方案概述

对称加密使用同一密钥完成加密与解密，AES（Advanced Encryption Standard）是当前最主流的对称加密算法，256 位密钥长度满足金融级安全需求；GCM（Galois/Counter Mode）是认证加密模式，同时提供机密性与完整性（通过认证标签验证），适合 Web 聊天室实时传输场景。

2.1.2 核心原理

1. AES-256 基础：分组密码，将明文按 128 位分组，用 256 位密钥通过多轮置换 / 混淆运算生成密文；
2. GCM 模式工作流程：

• 生成 12 字节初始化向量（IV，需随机且不重复，每次加密不同）；
• 用密钥 + IV 生成计数器（Counter），计数器与密钥通过 AES 运算生成密钥流，与明文异或得到密文；
• 对 “IV + 密文 + 附加数据（如消息 ID）” 计算 Galois 哈希，生成 16 字节认证标签（用于解密时验证完整性）；

1. 解密验证：接收方用相同密钥 + IV 解密得到明文，重新计算认证标签并与发送方标签比对，不一致则密文被篡改。

2.1.3 实现步骤（分场景）

场景 1：单聊加密

1. 密钥协商：

• 用户 A 与 B 通过 “安全渠道” 交换 AES-256 密钥（如通过服务器转发，但需用非对称加密保护密钥，此步骤暂不展开，后续混合加密会优化）；
• 密钥生成：使用密码学安全随机数生成器（如 Web Crypto 的crypto.getRandomValues()）生成 32 字节（256 位）密钥。

1. 消息加密（发送方 A）：

• 生成 12 字节 IV（crypto.getRandomValues(new Uint8Array(12))）；
• 调用 AES-GCM 加密 API，输入 “明文 + 密钥 + IV + 附加数据（如messageId）”，输出密文与认证标签；
• 拼接 “IV（12 字节）+ 密文（N 字节）+ 认证标签（16 字节）”，转为 Base64 字符串通过 WebSocket 发送。

1. 消息解密（接收方 B）：

• 解析 Base64 字符串，按长度拆分 IV（前 12 字节）、密文（中间 N 字节）、认证标签（后 16 字节）；
• 调用 AES-GCM 解密 API，输入 “密文 + 密钥 + IV + 认证标签 + 附加数据”，验证标签通过后得到明文。

场景 2：群聊加密

1. 群密钥生成与分发：

• 群创建者生成 AES-256 群密钥，通过服务器将密钥分发给所有群成员（需用成员的非对称公钥加密群密钥，避免分发泄露）；

1. 消息传输：

• 发送方用群密钥加密消息（流程同单聊），服务器转发密文给所有群成员；
• 所有成员用群密钥解密消息；

1. 密钥更新：

• 群成员变更（如踢人 / 加人）时，创建者重新生成群密钥，用新成员公钥加密后分发，旧成员通过现有加密通道接收新密钥。

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

前端（Vue3 + Web Crypto API）

// 1. 生成AES-256密钥

async function generateAesKey() {

// extractable: false 表示密钥不可导出（避免泄露），keyUsages指定用途

const key = await crypto.subtle.generateKey(

{ name: "AES-GCM", length: 256 },

false,

["encrypt", "decrypt"]

);

return key;

}

// 2. AES-GCM加密（明文：string，密钥：CryptoKey，附加数据：string）

async function aesGcmEncrypt(plaintext, aesKey,) {

// 生成12字节IV

const iv = crypto.getRandomValues(new Uint8Array(12));

// 编码明文与附加数据

const plaintextUint8 = new TextEncoder().encode(plaintext);

const adUint8 = new TextEncoder().encode(additionalData);

// 加密：返回密文+认证标签（合并为一个ArrayBuffer）

const encrypted = await crypto.subtle.encrypt(

{ name: "AES-GCM", iv: iv, additionalData: adUint8, tagLength: 128 }, // tagLength=128位（16字节）

aesKey,

plaintextUint8

);

// 拆分密文与标签（最后16字节是标签）

const encryptedUint8 = new Uint8Array(encrypted);

const ciphertext = encryptedUint8.slice(0, encryptedUint8.length - 16);

const tag = encryptedUint8.slice(encryptedUint8.length - 16);

// 拼接IV+密文+标签，转为Base64

const combined = new Uint8Array([...iv, ...ciphertext, ...tag]);

return btoa(String.fromCharCode(...combined));

}

// 3. AES-GCM解密（加密字符串：base64Str，密钥：CryptoKey，附加数据：string）

async function aesGcmDecrypt(base64Str, aesKey,) {

// Base64转Uint8Array

const combined = new Uint8Array(

atob(base64Str).split("").map(c => c.charCodeAt(0))

);

// 拆分IV（12）、密文（N）、标签（16）

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(); // 生成唯一消息ID（附加数据）

const encryptedStr = await aesGcmEncrypt(plaintext, aesKey, messageId);

// 通过Socket.IO发送

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 crypto = require("crypto");

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 方案概述

非对称加密使用密钥对（公钥 + 私钥），公钥可公开（用于加密 / 验签），私钥需保密（用于解密 / 签名）。RSA 基于大数分解问题，ECC（椭圆曲线加密）基于椭圆曲线离散对数问题，ECC 在相同安全性下密钥长度更短（secp256r1 公钥 64 字节 vs RSA-2048 公钥 256 字节），性能更优，更适合 Web 场景。

2.2.2 核心原理

（1）ECC secp256r1 原理（推荐）

1. 椭圆曲线参数：使用 NIST P-256 曲线（secp256r1），定义有限域上的椭圆方程y² = x³ - 3x + b；
2. 密钥对生成：

• 私钥：随机生成 256 位整数d（32 字节）；
• 公钥：椭圆曲线上的点Q = d * G（G为曲线基点），表示为 64 字节（x 坐标 32 字节 + y 坐标 32 字节）；

1. 加密流程：

• 发送方用接收方公钥Q生成临时点C1 = k * G（k为随机数）；
• 计算共享点S = k * Q，从S的 x 坐标派生对称密钥K；
• 用K加密明文（如 AES-128），输出C1 + 密文 + 标签；

1. 解密流程：

• 接收方用私钥d计算共享点S = d * C1；
• 从S派生密钥K，解密得到明文。

（2）RSA-2048 原理（兼容旧系统）

1. 密钥对生成：

• 生成两个大素数p、q，计算n = p*q（公钥 modulus）；
• 计算欧拉函数φ(n) = (p-1)(q-1)，选择公钥指数e（通常为 65537）；
• 计算私钥指数d（满足e*d ≡ 1 mod φ(n)）；

1. 加密：密文c = m^e mod n（m为明文，需小于n，RSA-2048 最大加密 245 字节）；
2. 解密：明文m = c^d mod n。

2.2.3 实现步骤（分场景）

场景 1：单聊加密（ECC）

1. 密钥对生成与分发：

• 用户 A 生成 ECC 密钥对（私钥dA，公钥QA），将QA发送给服务器；
• 用户 B 生成密钥对（私钥dB，公钥QB），将QB发送给服务器；
• A 向服务器请求 B 的公钥QB，B 请求 A 的公钥QA。

1. 消息加密（A→B）：

• A 生成随机数k，计算临时点C1 = k*G、共享点S = k*QB；
• 从S.x派生 AES-128 密钥K（用 SHA-256 哈希后取前 16 字节）；
• 用K加密明文（AES-GCM），生成密文C2；
• 发送 “C1（64 字节）+ C2（IV + 密文 + 标签）” 给 B。

1. 消息解密（B→A）：

• B 用私钥dB计算S = dB*C1，派生密钥K；
• 用K解密C2得到明文。

场景 2：群聊加密（ECC）

1. 密钥分发问题：

• 若用 ECC 直接加密，发送方需用每个群成员的公钥加密消息，成员数为 N 时需加密 N 次，性能极差；
• 优化方案：发送方生成临时 AES 群密钥，用每个成员的公钥加密 AES 密钥，再发送 “加密的 AES 密钥 + AES 加密的消息”，成员解密 AES 密钥后解密消息。

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

使用libsodium-wrappers（ECC 支持更完善的 JS 库）：

import sodium from "libsodium-wrappers";

// 初始化libsodium

await sodium.ready;

// 1. 生成ECC secp256r1密钥对

function generateEccKeyPair() {

// curve25519与secp256r1兼容，libsodium默认支持

const keyPair = sodium.crypto_box_keypair();

return {

privateKey: sodium.to_base64(keyPair.privateKey), // 私钥（32字节→Base64）

publicKey: sodium.to_base64(keyPair.publicKey) // 公钥（32字节→Base64）

};

}

// 2. ECC加密（明文，接收方公钥Base64，发送方私钥Base64）

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); // 24字节nonce

// 加密：返回密文（包含认证标签）

const ciphertext = sodium.crypto_box_easy(

sodium.encode_utf8(plaintext),

nonce,

receiverPk,

senderSk

);

// 拼接nonce+密文，转为Base64

const combined = sodium.concat([nonce, ciphertext]);

return sodium.to_base64(combined);

}

// 3. ECC解密（加密字符串Base64，发送方公钥Base64，接收方私钥Base64）

function eccDecrypt(encryptedBase64, senderPkBase64, receiverSkBase64) {

const senderPk = sodium.from_base64(senderPkBase64);

const receiverSk = sodium.from_base64(receiverSkBase64);

const combined = sodium.from_base64(encryptedBase64);

// 拆分nonce（24字节）与密文

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(); // A的密钥对

const userBPublicKey = "xxx"; // 从服务器获取B的公钥

const plaintext = "Hello, 非对称加密单聊！";

const encryptedStr = eccEncrypt(plaintext, userBPublicKey, userAKeyPair.privateKey);

// 发送给B

socket.emit("privateMessage", {

toUserId: "userB",

encryptedStr,

fromUserPublicKey: userAKeyPair.publicKey // B解密需A的公钥

});

2.2.5 优劣分析

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

2.3.1 方案概述

混合加密结合对称加密的高性能与非对称加密的密钥分发优势，是 Web 聊天室的最优解之一（类似 TLS 协议原理）：用 ECC 实现对称密钥（AES 密钥）的安全交换，用 AES-GCM 加密实际消息内容，兼顾安全与实时性。

2.3.2 核心原理

1. 密钥交换阶段（ECC ECDH）：

• ECDH（Elliptic Curve Diffie-Hellman）是密钥协商协议，双方无需传输密钥，通过各自密钥对派生相同的共享密钥；
• 流程：A 生成密钥对（dA, QA），B 生成（dB, QB）；A 发送QA给 B，B 发送QB给 A；A 计算S = dA*QB，B 计算S = dB*QA，双方得到相同共享点S；从S.x派生 AES-256 密钥。

1. 消息传输阶段（AES-GCM）：

• 用派生的 AES 密钥加密消息（流程同方案 1），实现高速传输；
• 每次会话生成新的 ECC 密钥对，保证前向安全性。

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

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

1. 密钥协商（ECDH）：

• 步骤 1：用户 A 生成临时 ECC 密钥对（tempSkA, tempPkA），发送tempPkA给服务器，请求 B 的公钥；
• 步骤 2：服务器转发tempPkA给 B，并返回 B 的长期公钥longPkB（B 注册时生成并存储）；
• 步骤 3：B 生成临时密钥对（tempSkB, tempPkB），用tempSkB与tempPkA派生共享密钥sharedKey，发送tempPkB给 A；
• 步骤 4：A 用tempSkA与tempPkB派生相同的sharedKey，通过 SHA-256 哈希 + 密钥拉伸生成 AES-256 密钥aesKey。

1. 消息加密（AES-GCM）：

• A 用aesKey加密消息，发送 “IV + 密文 + 标签” 给 B；
• B 用aesKey解密消息。

1. 会话更新：

• 每发送 100 条消息或 24 小时后，重新执行 ECDH 协商，生成新aesKey，保证前向安全性。

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

1. 群密钥生成与分发：

• 群创建者 C 生成 AES 群密钥groupAesKey；
• C 从服务器获取所有群成员的长期公钥（longPk1, longPk2, ..., longPkn）；
• C 用每个成员的公钥加密groupAesKey（ECC 加密），生成encryptedKey1, encryptedKey2, ..., encryptedKeyn；
• 服务器将encryptedKeyi分发给成员 i，成员 i 用私钥解密得到groupAesKey。

1. 消息传输：

• 任何成员发送群消息时，用groupAesKey加密（AES-GCM），服务器转发密文；
• 成员接收后用groupAesKey解密。

1. 群密钥更新：

• 成员变更时，当前持有groupAesKey的成员（如 C）生成新groupAesKey，用新成员公钥加密分发，旧成员通过现有加密通道接收新密钥。

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

// 1. 生成ECC长期密钥对（用户注册时生成，私钥存储在安全区域）

async function generateLongEccKeyPair() {

const keyPair = await crypto.subtle.generateKey(

{ name: "ECDH", namedCurve: "P-256" }, // P-256即secp256r1

true, // 允许导出公钥（私钥仅在内存使用，不导出）

["deriveKey"]

);

// 导出公钥（SPKI格式→Base64）

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密钥（本地私钥，对方公钥Base64）

async function deriveAesKey(localPrivateKey, peerPublicKeyBase64) {

// 导入对方公钥（SPKI格式）

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, // 仅用于派生，不允许其他操作

[]

);

// 派生共享密钥（256位）

const sharedSecret = await crypto.subtle.deriveKey(

{ name: "ECDH", public: peerPublicKey },

localPrivateKey,

{ name: "AES-GCM", length: 256 }, // 目标密钥类型：AES-256-GCM

false, // 不允许导出AES密钥

["encrypt", "decrypt"]

);

return sharedSecret;

}

// 3. 单聊完整流程示例

async function initPrivateChat(withUserId) {

// 步骤1：获取本地长期密钥对（用户登录时加载）

const localLongKeyPair = await loadLocalLongKeyPair(); // 从安全存储加载私钥

// 步骤2：向服务器请求对方长期公钥

const peerLongPublicKey = await axios.get(`/api/user/${withUserId}/publicKey`);

// 步骤3：生成本地临时密钥对（每次会话新生成）

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

// 步骤4：发送本地临时公钥给对方，请求对方临时公钥

const peerTempPublicKey = await new Promise((resolve) => {

socket.emit("requestTempPublicKey", { toUserId: withUserId, localTempPublicKey });

socket.once("responseTempPublicKey", (data) => resolve(data.peerTempPublicKey));

});

// 步骤5：ECDH派生AES密钥

const aesKey = await deriveAesKey(localTempKeyPair.privateKey, peerTempPublicKey);

// 步骤6：发送加密消息

const plaintext = "混合加密单聊消息：AES+ECC";

const messageId = uuidv4();

const encryptedStr = await aesGcmEncrypt(plaintext, aesKey, messageId);

socket.emit("privateMessage", {

toUserId,

messageId,

encryptedStr

});

// 步骤7：接收对方消息并解密

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 是专为即时通讯设计的端到端加密（E2EE）方案，被 WhatsApp、Signal、Facebook Messenger 采用，提供强安全性（符合 NIST 标准），支持单聊 / 群聊、前向安全性、抗重放攻击，是私密聊天室的终极选择。

2.4.2 核心原理

Signal Protocol 核心由四部分组成：

1. 双棘轮算法（Double Ratchet Algorithm）：

• 结合 “对称棘轮” 与 “非对称棘轮”，每次消息交互后更新发送 / 接收密钥：
• 对称棘轮：用哈希链（SHA-256）更新密钥，每次发送消息后将发送密钥SK更新为SHA-256(SK)；
• 非对称棘轮：用 ECC 密钥对更新，接收方定期生成新预密钥，发送方用新预密钥更新会话密钥；
• 保证前向安全性：即使当前密钥泄露，过去的消息仍无法解密。

1. 预密钥机制（PreKey）：

• 用户生成一批预密钥（包含预密钥公钥PKp、预密钥 ID Idp）和签名密钥对（SKs, PKs），上传到服务器；
• 新用户发起会话时，从服务器获取对方的预密钥 + 签名公钥，无需等待对方在线即可建立加密通道。

1. 椭圆曲线加密（ECC secp256r1 + X25519）：

• 身份密钥（长期）：IK（secp256r1，用于签名）；
• 预密钥（短期）：PKp（X25519，用于密钥协商）；
• 临时密钥（单次会话）：EK（X25519，用于初始协商）。

1. Sender Key 机制（群聊加密）：

• 群内生成 Sender Key（对称密钥），发送方用 Sender Key 加密消息，生成消息密钥MK；
• 群成员用 Sender Key 解密MK，再用MK解密消息；
• Sender Key 更新时，通过现有加密通道用成员身份公钥加密分发。

2.4.3 实现步骤（单聊场景）

1. 用户初始化（注册阶段）：

• 生成身份密钥对IK = (IKs, IKp)（长期，不更新）；
• 生成签名密钥对SK = (SKs, SKp)（中期，定期更新）；
• 生成 100 个预密钥PreKey = [(Idp1, PKp1), (Idp2, PKp2), ..., (Idp100, PKp100)]（短期，用完即补）；
• 用SKs对PKp签名，上传IKp、PKp、PreKey到 Signal 服务器（仅存储公钥，不存储私钥）。

1. 会话建立（A→B 首次聊天）：

• 步骤 1：A 从服务器获取 B 的IKp、PKp、一个未使用的PreKey (Idp, PKp)；
• 步骤 2：A 生成临时密钥对EK = (EKs, EKp)；
• 步骤 3：A 用EKs、B 的PKp、B 的PreKey.PKp派生初始会话密钥RK（Root Key）和发送密钥SK；
• 步骤 4：A 发送 “EKp + PreKey.Idp + 消息密文” 给 B，消息密文用SK加密；
• 步骤 5：B 用自己的PreKey私钥、EKp派生相同的RK和接收密钥RK，解密得到消息。

1. 会话持续（双棘轮更新）：

• A 发送消息后，用哈希链更新发送密钥SK = SHA-256(SK)；
• B 接收消息后，用哈希链更新接收密钥RK = SHA-256(RK)；
• 每 10 条消息后，B 生成新预密钥，A 用新预密钥更新RK，保证前向安全性。

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

Signal Protocol 算法复杂，推荐使用官方维护的libsignal-protocol-javascript库：

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

// 1. 初始化信号存储（存储身份密钥、预密钥、会话状态）

class SignalStore {

constructor() {

this.identityKeyPair = null; // 身份密钥对

this.preKeys = new Map(); // 预密钥：Id→PreKey

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

}

// 2. 用户注册：生成身份密钥、预密钥并上传服务器

async function registerSignalUser(userId) {

const store = new SignalStore();

const keyHelper = signal.KeyHelper;

// 生成身份密钥对（长期）

const identityKeyPair = await keyHelper.generateIdentityKeyPair();

store.putIdentityKeyPair(identityKeyPair);

// 生成签名预密钥（中期，30天有效期）

const signedPreKey = await keyHelper.generateSignedPreKey(

identityKeyPair,

Math.floor(Date.now() / 1000) // 时间戳

);

store.signedPreKey = signedPreKey;

// 生成100个预密钥（短期）

for (let i = 0; i < 100; i++) {

const preKey = await keyHelper.generatePreKey(i);

store.storePreKey(preKey.keyId, preKey);

}

// 上传公钥到Signal服务器（私钥不上传）

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;

}

// 3. 发起单聊会话（A→B）

async function initSignalChat(store, targetUserId) {

const keyHelper = signal.KeyHelper;

const address = new signal.SignalProtocolAddress(targetUserId, 1); // 设备ID默认1

// 从服务器获取B的公钥（身份公钥、签名预密钥、预密钥）

const targetPubKeys = await axios.get(`/api/signal/user/${targetUserId}/keys`);

// 生成临时密钥对

const ephemeralKeyPair = await keyHelper.generateEphemeralKeyPair();

// 创建会话构建器

const sessionBuilder = new signal.SessionBuilder(store, address);

// 用B的预密钥建立会话

await sessionBuilder.processPreKey({

registrationId: 1, // 注册ID

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")

);

// 发送密文（包含类型、密钥ID、密文）

socket.emit("signalMessage", {

toUserId: targetUserId,

ciphertext: {

type: ciphertext.type,

ephemeralKeyId: ciphertext.ephemeralKeyId,

ciphertext: Buffer.from(ciphertext.body).toString("base64")

}

});

// 接收B的消息并解密

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 是高效消息认证码，两者组合提供轻量级认证加密，适合低性能设备（如旧手机 WebView、嵌入式设备）—— 无需 AES 硬件加速，纯软件实现速度比 AES-GCM 快 30%~50%，且安全性与 AES-256 相当。

2.5.2 核心原理

1. ChaCha20 流密码：

• 输入：256 位密钥、96 位 nonce（随机且不重复）、32 位计数器（初始为 0）；
• 运算：通过 “四轮双混合函数”（Double Round）生成 64 字节密钥流块，计数器递增生成后续块；
• 加密：密钥流与明文异或得到密文（流密码特性：相同密钥流 + 明文 = 密文，密文 + 密钥流 = 明文）。

1. Poly1305 认证码：

• 用 32 位密钥（从 ChaCha20 密钥派生）对 “nonce + 密文 + 附加数据” 计算 128 位认证标签，验证密文完整性。

2.5.3 实现步骤（单聊场景）

1. 密钥生成：用crypto.getRandomValues()生成 32 字节（256 位）ChaCha20 密钥；
2. 加密流程：

• 生成 96 位 nonce（crypto.getRandomValues(new Uint8Array(12))）；
• 用 ChaCha20 生成密钥流，加密明文得到密文；
• 用 Poly1305 计算认证标签；
• 发送 “nonce（12 字节）+ 密文 + 标签（16 字节）”；

1. 解密流程：

• 拆分 nonce、密文、标签；
• 生成密钥流解密得到明文；
• 重新计算标签并验证，不一致则拒绝。

2.5.4 代码实现（前端 libsodium）

import sodium from "libsodium-wrappers";

await sodium.ready;

// 1. 生成ChaCha20密钥（32字节）

function generateChaChaKey() {

return sodium.to_base64(sodium.randombytes_buf(sodium.crypto_aead_chacha20poly1305_ietf_KEYBYTES));

}

// 2. ChaCha20-Poly1305加密

function chachaEncrypt(plaintext, keyBase64,) {

const key = sodium.from_base64(keyBase64);

const nonce = sodium.randombytes_buf(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES); // 12字节

const ad = sodium.encode_utf8(additionalData);

// 加密：返回密文+标签（合并）

const ciphertext = sodium.crypto_aead_chacha20poly1305_ietf_encrypt(

sodium.encode_utf8(plaintext),

ad,

null,

nonce,

key

);

// 拼接nonce+密文+标签

const combined = sodium.concat([nonce, ciphertext]);

return sodium.to_base64(combined);

}

// 3. ChaCha20-Poly1305解密

function chachaDecrypt(encryptedBase64, keyBase64,) {

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 优劣分析