Web 版 IM 聊天信息加密的三种实现方案

Vue 组件中使用：

<!-- components/Chat.vue -->
<script>
import { encryptMessageWithPublicKey, decryptMessageWithPrivateKey, getPrivateKey } from '@/utils/crypto';
import { apiGetUserPublicKey, apiSendMessage } from '@/api/chat';

export default {
    async sendMessage() {
        if (!this.newMessage.trim()) return;
        try {
            // 1. 获取目标用户公钥
            const publicKeyResponse = await apiGetUserPublicKey(this.targetUser.id);
            const receiverPublicKey = publicKeyResponse.data;
            
            // 2. 加密消息
            const encryptedContent = encryptMessageWithPublicKey(receiverPublicKey, this.newMessage.trim());
            
            // 3. 发送密文
            const messagePayload = {
                receiverId: this.targetUser.id,
                type: 'text',
                content: encryptedContent,
                isEncrypted: true,
                timestamp: new Date().toISOString(),
            };
            this.websocket.send(JSON.stringify(messagePayload));
            this.newMessage = '';
        } catch (error) {
            console.error('发送失败:', error);
        }
    },
    async decryptMessage(message) {
        if (message.decryptedContent) return;
        try {
            const privateKey = getPrivateKey(this.currentUser.id);
            if (!privateKey) throw new Error('未找到解密密钥');
            const decryptedContent = decryptMessageWithPrivateKey(privateKey, message.encryptedContent);
            message.decryptedContent = decryptedContent;
        } catch (error) {
            console.error('解密失败:', error);
        }
    }
};
</script>

后端 Java 实现

后端主要负责公钥存储和消息转发，不接触明文。

实体类增加公钥字段：

@Entity
@Table(name = "im_users")
public class User {
    @Id
    private Long id;
    private String username;
    @Column(columnDefinition = "TEXT")
    private String rsaPublicKey; // PEM 格式
}

Controller 层处理公钥查询和消息转发：

@RestController
@RequestMapping("/api/chat")
public class ChatController {
    @Autowired private UserRepository userRepository;
    @Autowired private SimpMessagingTemplate messagingTemplate;

    @GetMapping("/user/{userId}/public-key")
    public ResponseEntity<?> getUserPublicKey(@PathVariable Long userId) {
        User user = userRepository.findById(userId).orElseThrow();
        return ResponseEntity.ok().body(Collections.singletonMap("publicKey", user.getRsaPublicKey()));
    }

    @PostMapping("/message")
    public ResponseEntity<Void> sendEncryptedMessage(@RequestBody EncryptedMessageRequest request) {
        // 1. 保存密文到数据库
        ChatMessage message = new ChatMessage();
        message.setSenderId(request.getSenderId());
        message.setReceiverId(request.getReceiverId());
        message.setContent(request.getContent()); // 密文
        messageRepository.save(message);

        // 2. WebSocket 实时转发
        messagingTemplate.convertAndSendToUser(
            request.getReceiverId().toString(),
            "/queue/messages",
            request
        );
        return ResponseEntity.ok().build();
    }
}

优缺点总结

• 优点：概念简单，符合 E2EE 基本定义。
• 缺点：
  • 性能差：RSA 加密慢，影响用户体验。
  • 无前向保密：长期私钥一旦泄露，历史所有通信均可被解密。
  • 密钥管理难：换设备后旧私钥丢失，无法同步解密。

结论：仅适用于学习原理或极低频场景，不建议生产使用。

方案二：非对称加密 + 数字签名

此方案在方案一基础上增加了数字签名，解决身份验证和完整性问题。

流程

1. A 用 B 的公钥加密消息得到密文 C。
2. A 用自己的私钥对消息（或密文）签名得到 S。
3. 发送 { cipherText: C, signature: S }。
4. B 收到后先用 A 的公钥验证签名，再用自己的私钥解密。

前端增强

在 crypto.js 中添加签名函数：

export function signMessageWithPrivateKey(privateKeyPem, message) {
    const privateKey = forge.pki.privateKeyFromPem(privateKeyPem);
    const md = forge.md.sha256.create();
    md.update(message, 'utf8');
    const signature = privateKey.sign(md);
    return forge.util.encode64(signature);
}

export function verifySignatureWithPublicKey(publicKeyPem, message, signatureBase64) {
    const publicKey = forge.pki.publicKeyFromPem(publicKeyPem);
    const md = forge.md.sha256.create();
    md.update(message, 'utf8');
    const signature = forge.util.decode64(signatureBase64);
    return publicKey.verify(md.digest().getBytes(), signature);
}

发送时加入签名字段，接收时先验签再解密。若验签失败，提示用户消息可能不可信。

优缺点总结

• 优点：提供身份验证和不可否认性。
• 缺点：性能进一步下降（两次非对称操作），依然没有前向保密性。

结论：解决了身份问题，但未解决性能和长期密钥泄露风险，仍不推荐高频生产环境。

方案三：混合加密系统（推荐生产方案）

这是现代安全通信的标准模型。核心思想：用非对称加密安全交换临时对称密钥，后续消息用对称密钥加密。

核心概念：前向保密 (Forward Secrecy)

每次会话生成独立的临时对称密钥。即使攻击者破解了用户的长期私钥，也无法解密过去的通信记录，因为过去的会话密钥早已丢弃。

流程

1. 会话初始化：A 生成随机对称密钥 SK，用 B 的公钥加密 SK 形成'信封'，发送给 B。
2. 发送消息：A 用 SK 加密消息明文，发送密文。
3. 接收消息：B 用私钥解密信封得 SK，再用 SK 解密消息。

前端 Vue 实现

需要管理会话密钥状态（Vuex Store）。

扩展 crypto.js 支持 AES-CBC：

export function generateSymmetricKey() {
    const key = forge.random.getBytesSync(32); // AES-256
    const iv = forge.random.getBytesSync(16);
    return { key: forge.util.encode64(key), iv: forge.util.encode64(iv) };
}

export function encryptWithSymmetricKey(keyBase64, ivBase64, message) {
    const key = forge.util.decode64(keyBase64);
    const iv = forge.util.decode64(ivBase64);
    const cipher = forge.cipher.createCipher('AES-CBC', key);
    cipher.start({ iv });
    cipher.update(forge.util.createBuffer(message, 'utf8'));
    cipher.finish();
    return forge.util.encode64(cipher.output.data);
}

export function decryptWithSymmetricKey(keyBase64, ivBase64, encryptedMessageBase64) {
    const key = forge.util.decode64(keyBase64);
    const iv = forge.util.decode64(ivBase64);
    const decipher = forge.cipher.createDecipher('AES-CBC', key);
    decipher.start({ iv });
    decipher.update(forge.util.createBuffer(encryptedMessageBase64));
    const result = decipher.finish();
    return result ? decipher.output.toString('utf8') : null;
}

Vuex 管理会话密钥：

// store/modules/chatSession.js
const state = { sessionKeys: {} };
const mutations = {
    SET_SESSION_KEY(state, { userId, keyData }) {
        state.sessionKeys[userId] = { ...keyData, timestamp: Date.now() };
    }
};
const actions = {
    async establishSession({ commit, rootState }, targetUserId) {
        const symmetricKey = generateSymmetricKey();
        const publicKeyResponse = await apiGetUserPublicKey(targetUserId);
        const receiverPublicKey = publicKeyResponse.data.publicKey;
        
        // 用对方公钥加密我们的对称密钥
        const encryptedEnvelope = encryptSymmetricKeyWithPublicKey(receiverPublicKey, symmetricKey);
        
        await apiSendKeyExchange({ receiverId: targetUserId, encryptedEnvelope });
        commit('SET_SESSION_KEY', { userId: targetUserId, keyData: symmetricKey });
        return symmetricKey;
    }
};

聊天组件中优先使用会话密钥加密消息，性能极快。

高级特性：双工密钥协商

更安全的做法是使用 ECDH（椭圆曲线 Diffie-Hellman）协议，双方各自生成临时密钥对，协商出共享密钥。这能实现完全的前向保密。实现较复杂，可借助 libsodium.js。

优缺点总结

• 优点：高性能（对称加密），具备前向保密性，安全性高。
• 缺点：实现复杂度最高，需管理会话状态和密钥生命周期。

结论：唯一推荐用于生产环境的方案，平衡了安全与体验。

部署、测试与安全最佳实践

密钥安全存储

• 长期私钥：严禁明文存储在 localStorage。建议使用用户密码通过 KDF（如 PBKDF2）派生密钥加密后再存储。
• 会话密钥：可暂存内存，页面刷新即丢失以增强前向保密；如需持久化，应加密后存入 IndexedDB。

传输安全

• 必须使用 HTTPS 和 WSS 协议，防止中间人攻击。

后端安全

• 严格身份验证（JWT），权限检查发送者身份。
• 实施速率限制，防止接口滥用。

常见问题

• 无法解密：检查是否密码错误或会话密钥过期。
• 新设备登录：引导用户重新生成密钥对，并明确告知旧消息将无法在新设备解密。

总结与方案选择

对于任何严肃的 Web 版 IM 应用，请务必选择方案三。虽然实现最复杂，但它是唯一能同时满足安全性、性能和用户体验要求的方案。方案一和二仅适用于理解概念或特殊低频场景。