1. 项目概述与核心价值

最近在重构一个前后端分离的管理系统，用户登录模块的安全问题成了我首要关注的焦点。传统的用户名密码明文传输，或者简单做个Base64编码，在如今这个网络环境下，基本等于“裸奔”。一旦请求被拦截，用户凭证就完全暴露了。为了解决这个问题，我决定在前端（Vue）和后端（Spring Boot）之间，引入一套基于RSA非对称加密的用户身份认证加密机制。简单来说，就是让前端用公钥加密敏感信息（比如密码），后端用私钥解密，确保传输过程中的机密性。这不仅仅是加个密那么简单，它关乎到整个系统安全基线的建立，是任何一个对用户负责的线上项目都必须认真对待的环节。

这个方案特别适合采用Spring Boot + Vue这种经典前后端分离架构的团队。无论你是正在开发一个新的企业级应用，还是觉得老项目的登录模块不够安全想升级，这套实现思路都能给你一个清晰、可落地的参考。我会从原理、到前后端的具体代码实现、再到部署和调试中的各种“坑”，完整地走一遍。你会发现，引入RSA加密后，你的登录接口在面对常见的中间人攻击时，会从容很多。

2. 整体架构设计与核心思路拆解

2.1 为什么选择RSA而非其他加密方式？

在用户登录场景下，我们主要解决的是“传输安全”问题。常见的方案有对称加密（如AES）、非对称加密（如RSA）以及HTTPS。HTTPS（SSL/TLS）当然是终极解决方案，它提供了端到端的完整安全通道。但在某些内部系统、开发测试环境，或者想在前端就对密码进行不可逆混淆的场景下，在应用层再叠加一层RSA加密作为补充，是一个性价比很高的安全增强手段。

RSA的核心优势在于 公钥加密、私钥解密 。私钥永远不用离开服务器，这完美解决了对称加密中“密钥如何安全分发给客户端”的难题。前端可以放心大胆地持有公钥，用它来加密数据，而只有持有私钥的后端才能解开。这个过程是单向的，即使公钥泄露，攻击者也无法解密已加密的信息。相比之下，虽然HTTPS已经普及，但在其握手阶段也可能用到RSA来交换对称密钥。我们在应用层再做一次RSA加密，相当于在HTTPS通道内又加了一把锁，形成了纵深防御。

注意 ：绝对不要试图用RSA加密大量数据。RSA算法本身速度较慢，且加密的数据长度受密钥长度限制。我们的策略是： 仅用RSA加密关键信息（如密码），或者加密一个临时生成的对称密钥（如AES密钥） 。后者是更通用的做法，即“RSA加密AES密钥，AES加密业务数据”。本文为聚焦登录场景，我们先实现直接用RSA加密密码的方案。

2.2 核心交互流程与组件职责

整个机制的运行，围绕着一次登录请求展开，涉及四个关键角色：

  1. 前端 (Vue) ：负责向后台获取RSA公钥，使用公钥加密用户输入的密码，并将加密后的密文连同用户名一起提交给登录接口。
  2. 后端控制器 (Spring Boot Controller) ：提供获取公钥的接口，并接收前端提交的登录请求。
  3. RSA密钥对管理器 (Key Pair Manager) ：后端服务中的一个组件，负责生成、存储和在内存中管理RSA密钥对（公钥+私钥）。这是安全的核心，必须确保私钥的绝对安全。
  4. 认证处理器 (Authentication Processor) ：后端服务中处理登录逻辑的组件（可能是Spring Security的过滤器，或自定义的Service）。它从控制器拿到加密后的密码，向密钥管理器请求私钥进行解密，还原出明文密码，再进行后续的数据库校验等操作。

具体的交互时序可以这样理解：用户打开登录页，前端自动调用后端接口拿到公钥；用户输入信息点击登录，前端用公钥加密密码并发起请求；后端用对应的私钥解密，验证用户身份。整个过程，密码明文从未在网络上出现过。

3. 后端实现：Spring Boot侧的密钥管理与接口

后端的任务是安全地生成密钥对、暴露公钥接口、并提供解密能力。我们不希望每次请求都重新生成密钥对，那样前端需要频繁获取新公钥，且密钥管理混乱。通常采用“服务启动时生成”或“定时刷新”的策略。

3.1 生成与存储RSA密钥对

首先，我们需要一个工具类来生成RSA密钥对。Java标准库 java.security 提供了完整的支持。我通常会创建一个 RsaUtils 工具类。

import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class RsaUtils {
    // 密钥算法
    private static final String ALGORITHM = "RSA";
    // 密钥长度，2048位是当前安全推荐的最小值
    private static final int KEY_SIZE = 2048;

    /**
     * 生成RSA密钥对
     * @return 包含公钥和私钥的KeyPair对象
     * @throws Exception
     */
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        // 初始化密钥生成器，指定长度
        keyPairGenerator.initialize(KEY_SIZE);
        return keyPairGenerator.generateKeyPair();
    }

    /**
     * 获取公钥字符串（Base64编码）
     * @param keyPair 密钥对
     * @return Base64编码的公钥字符串
     */
    public static String getPublicKeyStr(KeyPair keyPair) {
        PublicKey publicKey = keyPair.getPublic();
        return Base64.getEncoder().encodeToString(publicKey.getEncoded());
    }

    /**
     * 获取私钥字符串（Base64编码）
     * @param keyPair 密钥对
     * @return Base64编码的私钥字符串
     */
    public static String getPrivateKeyStr(KeyPair keyPair) {
        PrivateKey privateKey = keyPair.getPrivate();
        return Base64.getEncoder().encodeToString(privateKey.getEncoded());
    }

    /**
     * 用公钥加密数据
     * @param data 待加密数据（明文）
     * @param publicKeyStr Base64编码的公钥字符串
     * @return Base64编码的加密后数据
     * @throws Exception
     */
    public static String encrypt(String data, String publicKeyStr) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(publicKeyStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);

        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encodedBytes);
    }

    /**
     * 用私钥解密数据
     * @param encryptedData Base64编码的加密数据
     * @param privateKeyStr Base64编码的私钥字符串
     * @return 解密后的原始数据（明文）
     * @throws Exception
     */
    public static String decrypt(String encryptedData, String privateKeyStr) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(privateKeyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] dataBytes = Base64.getDecoder().decode(encryptedData);
        byte[] decryptedBytes = cipher.doFinal(dataBytes);
        return new String(decryptedBytes);
    }
}

有了工具类，接下来需要一个管理器来持有当前有效的密钥对。我倾向于使用一个简单的单例组件，并在应用启动时初始化。

import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.security.KeyPair;

@Component
public class RsaKeyManager {
    // 存储当前的密钥对
    private KeyPair currentKeyPair;
    // 存储Base64编码的公钥字符串，方便直接返回给前端
    private String publicKeyStr;

    @PostConstruct
    public void init() throws Exception {
        refreshKeyPair();
    }

    /**
     * 刷新（生成）新的密钥对
     */
    public synchronized void refreshKeyPair() throws Exception {
        this.currentKeyPair = RsaUtils.generateKeyPair();
        this.publicKeyStr = RsaUtils.getPublicKeyStr(this.currentKeyPair);
        // 在实际生产中，这里可以记录日志，或发送事件通知前端可能需要重新获取公钥
        System.out.println("RSA密钥对已刷新，公钥前50位：" + publicKeyStr.substring(0, Math.min(50, publicKeyStr.length())));
    }

    /**
     * 获取当前公钥字符串
     */
    public String getCurrentPublicKey() {
        return publicKeyStr;
    }

    /**
     * 获取当前私钥字符串（仅供内部解密使用）
     */
    private String getCurrentPrivateKeyStr() throws Exception {
        return RsaUtils.getPrivateKeyStr(currentKeyPair);
    }

    /**
     * 使用当前私钥解密数据
     * @param encryptedData 加密后的数据（Base64格式）
     * @return 解密后的明文
     */
    public String decryptWithCurrentPrivateKey(String encryptedData) throws Exception {
        return RsaUtils.decrypt(encryptedData, getCurrentPrivateKeyStr());
    }
}

实操心得一：密钥存储与生命周期 ：上面的 RsaKeyManager 将密钥对保存在内存中。这意味着服务重启后密钥对会改变。对于登录场景，这会导致重启前获取公钥的前端无法登录。有两种常见处理方式：1) 牺牲一点便利性 ：前端在每次需要加密时（如打开登录页）都先获取一次公钥。这是最安全简单的，推荐在大多数场景使用。2) 持久化密钥 ：将生成的密钥对加密后存入数据库或配置文件，启动时加载。但这引入了密钥存储安全的新问题，复杂度更高。我建议先从内存方案开始，前端配合做好公钥获取。

3.2 提供公钥接口与处理登录请求

接下来，创建两个控制器接口：一个用于获取公钥，一个用于处理登录。

首先，创建一个公钥接口：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/auth")
public class RsaController {

    @Autowired
    private RsaKeyManager rsaKeyManager;

    @GetMapping("/publicKey")
    public ApiResponse<String> getPublicKey() {
        // 包装一个简单的响应对象
        return ApiResponse.success(rsaKeyManager.getCurrentPublicKey());
    }
}

然后，是处理登录的接口。这里假设你已经有一个处理用户认证的 AuthService 。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/auth")
public class LoginController {

    @Autowired
    private RsaKeyManager rsaKeyManager;
    @Autowired
    private AuthService authService; // 你的认证服务

    @PostMapping("/login")
    public ApiResponse<LoginResult> login(@RequestBody LoginRequest loginRequest) {
        try {
            // 1. 使用当前私钥解密前端传过来的加密密码
            String encryptedPassword = loginRequest.getPassword(); // 前端传的是加密后的密文
            String rawPassword = rsaKeyManager.decryptWithCurrentPrivateKey(encryptedPassword);

            // 2. 将解密后的明文密码和用户名交给认证服务处理
            // 注意：这里AuthService内部应该是校验用户名和rawPassword是否匹配
            LoginResult result = authService.authenticate(loginRequest.getUsername(), rawPassword);

            // 3. 认证成功，返回token等信息
            return ApiResponse.success(result);
        } catch (Exception e) {
            // 解密失败或认证失败
            // 解密失败通常意味着数据被篡改或使用了错误的公钥加密，应视为认证失败
            return ApiResponse.error(401, "用户名或密码错误");
        }
    }
}

// 简单的请求和响应对象
@Data // 使用Lombok注解
class LoginRequest {
    private String username;
    private String password; // 这里存储的是RSA加密后的密文字符串
}

@Data
class LoginResult {
    private String token;
    private String username;
    // ... 其他用户信息
}

@Data
class ApiResponse<T> {
    private int code;
    private String message;
    private T data;
    // ... 静态成功/失败方法省略
}

注意 ：在 login 方法中，我直接捕获了 Exception 并返回统一的“用户名或密码错误”。这是出于安全考虑，避免向攻击者泄露过多系统信息（比如，是密码错误还是解密失败）。但在实际调试时，你可能需要更详细的日志来区分问题。

4. 前端实现：Vue侧的加密与请求

前端的工作流很清晰：获取公钥 -> 加密密码 -> 发起登录请求。我们需要一个可靠的RSA加密库。在Web环境中， jsencrypt 是一个广泛使用的选择。

4.1 安装依赖与封装加密工具

首先，在你的Vue项目中安装 jsencrypt ：

npm install jsencrypt --save
# 或
yarn add jsencrypt

然后，创建一个工具文件 src/utils/rsa.js ，封装加密逻辑和公钥获取。

import JSEncrypt from 'jsencrypt'
import axios from 'axios' // 假设你使用axios

// 创建一个JSEncrypt实例
const encryptor = new JSEncrypt()

// 公钥缓存，避免每次加密都请求
let cachedPublicKey = null

/**
 * 从后端获取RSA公钥
 * @returns {Promise<string>} 公钥字符串
 */
export async function fetchPublicKey() {
  // 如果已有缓存，直接返回（注意：如果后端重启，缓存会失效，需要处理）
  if (cachedPublicKey) {
    return cachedPublicKey
  }
  try {
    const response = await axios.get('/api/auth/publicKey') // 根据你的后端地址调整
    if (response.data && response.data.code === 200) {
      cachedPublicKey = response.data.data
      return cachedPublicKey
    } else {
      throw new Error('获取公钥失败')
    }
  } catch (error) {
    console.error('获取RSA公钥失败:', error)
    // 可以在这里进行重试或提示用户
    throw error
  }
}

/**
 * 使用RSA公钥加密数据
 * @param {string} data 待加密的明文
 * @returns {Promise<string>} 加密后的Base64字符串
 */
export async function rsaEncrypt(data) {
  try {
    const publicKey = await fetchPublicKey()
    encryptor.setPublicKey(publicKey)
    const encrypted = encryptor.encrypt(data)
    if (!encrypted) {
      throw new Error('加密失败，请检查公钥格式或数据')
    }
    return encrypted
  } catch (error) {
    console.error('RSA加密失败:', error)
    throw error
  }
}

/**
 * 清除缓存的公钥（例如，在登出或检测到解密错误时调用）
 */
export function clearPublicKeyCache() {
  cachedPublicKey = null
}

4.2 在登录组件中集成加密

现在，在你的登录组件（如 Login.vue ）中，使用封装好的工具。

<template>
  <div class="login-container">
    <form @submit.prevent="handleLogin">
      <input v-model="form.username" type="text" placeholder="用户名" />
      <input v-model="form.password" type="password" placeholder="密码" />
      <button type="submit" :disabled="loading">{{ loading ? '登录中...' : '登录' }}</button>
    </form>
  </div>
</template>

<script>
import { rsaEncrypt } from '@/utils/rsa'
import axios from 'axios'

export default {
  name: 'Login',
  data() {
    return {
      form: {
        username: '',
        password: ''
      },
      loading: false
    }
  },
  methods: {
    async handleLogin() {
      // 简单的前端校验
      if (!this.form.username || !this.form.password) {
        this.$message.error('请输入用户名和密码')
        return
      }

      this.loading = true
      try {
        // 关键步骤：加密密码
        const encryptedPassword = await rsaEncrypt(this.form.password)

        // 构造请求参数
        const loginData = {
          username: this.form.username,
          password: encryptedPassword // 发送加密后的密码
        }

        // 发起登录请求
        const response = await axios.post('/api/auth/login', loginData)

        if (response.data.code === 200) {
          // 登录成功，处理token和跳转
          const { token } = response.data.data
          localStorage.setItem('access_token', token) // 示例：存储token
          this.$router.push('/dashboard')
          this.$message.success('登录成功')
        } else {
          this.$message.error(response.data.message || '登录失败')
        }
      } catch (error) {
        console.error('登录过程出错:', error)
        // 可以根据错误类型细化提示
        if (error.response && error.response.status === 401) {
          this.$message.error('用户名或密码错误')
        } else if (error.message.includes('获取RSA公钥失败')) {
          this.$message.error('系统安全组件初始化失败，请刷新页面重试')
          // 可以在这里强制清除公钥缓存，触发重新获取
          // clearPublicKeyCache()
        } else {
          this.$message.error('网络错误或服务异常，请稍后重试')
        }
      } finally {
        this.loading = false
      }
    }
  }
}
</script>

实操心得二：前端加密的时机与用户体验 ：加密操作是异步的（因为可能涉及网络请求获取公钥）。这会导致用户点击登录后有一个短暂的延迟。为了更好的用户体验，我通常会在页面加载时（ mounted 钩子）就预获取公钥。这样用户输入完密码点击登录时，加密几乎是瞬间完成的。同时，要做好错误处理，如果预获取失败，在用户点击登录时再尝试一次，并给出明确的提示。

5. 进阶优化与安全增强

基础的加密传输实现了，但要让这个机制更健壮、更安全，还需要考虑以下几个层面。

5.1 应对重放攻击

目前的方案，攻击者虽然无法知道密码明文，但他可以截获整个加密后的请求包，然后原封不动地重复发给服务器（重放攻击），服务器会认为是合法用户再次登录。为了防止这种攻击，我们需要让每次登录请求都“唯一”。

常见方案：加入时间戳和随机数（Nonce）

  1. 前端改造 ：在加密前，将密码和一个当前时间戳（timestamp）和一个随机字符串（nonce）拼接起来。例如： encrypt(password + '|' + timestamp + '|' + nonce) 。
  2. 后端改造 ：解密后，拆分出密码、时间戳和nonce。首先检查时间戳是否在合理窗口内（比如，服务器时间前后5分钟），防止请求过期。其次，检查这个 nonce 是否在最近一段时间内被使用过（可以使用缓存，如Redis，存储最近5分钟内使用过的nonce），如果已使用过，则视为重放攻击，拒绝请求。

这样，即使请求被截获，也因为时间戳过期或nonce重复而失效。

5.2 密钥轮换与多版本支持

内存中的密钥对在服务重启后会变。如果希望服务重启不影响已打开登录页的用户，或者想定期主动更换密钥以提升安全性，就需要支持密钥轮换。

思路 ： RsaKeyManager 可以同时维护多组密钥对，每对密钥有一个唯一的ID（如 keyId ）。生成新密钥对时，旧密钥对并不立即删除，而是设定一个过期时间。前端获取公钥时，后端返回 keyId 和对应的 publicKey 。前端登录时，需要在请求体中额外带上这个 keyId 。后端根据 keyId 找到对应的私钥进行解密。

// 简化的多密钥管理器思路
@Component
public class RsaKeyManagerV2 {
    private Map<String, KeyPairWithExpiry> keyPairMap = new ConcurrentHashMap<>();

    public PublicKeyInfo getCurrentPublicKeyInfo() {
        // 返回最新的、未过期的keyId和公钥
    }

    public String decrypt(String keyId, String encryptedData) {
        // 根据keyId找到密钥对，检查是否过期，然后解密
    }
}

5.3 与HTTPS的关系

必须再次强调， RSA加密传输不能替代HTTPS 。HTTPS提供了传输层安全，包括加密、完整性校验和身份认证。我们实现的RSA是在应用层对密码进行的额外加密。两者是互补关系：

  • HTTPS ：保护整个通信链路，防止流量被监听、篡改。
  • 应用层RSA ：在HTTPS的基础上，额外确保密码在离开客户端前就是密文。即使HTTPS的加密在理论上被破解（或配置错误），攻击者拿到的也是RSA密文。

因此，生产环境务必启用HTTPS。在开发环境，如果暂时没有HTTPS，应用层RSA能提供有价值的安全提升。

6. 常见问题排查与调试技巧

在实际集成过程中，你肯定会遇到一些坑。下面是我总结的几个典型问题及其解决方法。

6.1 前端加密成功，后端解密失败

这是最常见的问题，通常由以下原因导致：

  1. 密钥不匹配 ：前端使用的公钥和后端用来解密的私钥不是一对。 排查 ：检查前端 fetchPublicKey 接口返回的公钥，和后端 RsaKeyManager 中 currentKeyPair 生成的公钥是否完全一致（Base64字符串对比）。确保前端没有缓存旧的公钥。
  2. 填充方式不一致 ：RSA加密需要指定填充方案（Padding）。Java默认的 Cipher.getInstance(“RSA”) 使用的可能是 RSA/ECB/PKCS1Padding 。而 jsencrypt 库默认也使用 PKCS1 填充。 确保前后端使用相同的填充方案 。在Java工具类中，可以显式指定： Cipher.getInstance(“RSA/ECB/PKCS1Padding”) 。
  3. 加密数据过长 ：RSA 2048位密钥最多加密245字节（≈ 245个ASCII字符）。如果密码拼接了过长的时间戳和nonce，可能超限。 解决方案 ：严格限制加密源数据的长度，或采用“RSA加密AES密钥，AES加密数据”的混合模式。
  4. Base64编码问题 ：确保前端发送的加密字符串是标准的Base64，没有多余的换行或空格。后端在解码前也需检查。

调试步骤 ：

  • 在后端 decrypt 方法开始处，打印接收到的 encryptedData 字符串。
  • 在前端加密后，也打印出加密结果。
  • 对比两者是否一致。如果不一致，问题出在传输或序列化过程。
  • 如果一致，则问题出在密钥或算法配置上。可以写一个单元测试，用后端的密钥对，模拟加密解密全过程。

6.2 性能考量与优化

RSA加解密是CPU密集型操作。在登录这种低频操作上，单次性能开销可以忽略。但如果并发登录量极大，可能会对CPU造成压力。

优化建议 ：

  • 连接池与异步 ：确保你的Web服务器（如Tomcat）和数据库连接池配置合理，避免因加解密导致线程阻塞。
  • 密钥长度 ：非金融级应用，2048位密钥在安全性和性能之间取得了良好平衡。不要盲目使用4096位。
  • 限流与降级 ：在网关层对登录接口实施限流，防止恶意攻击消耗资源。在极端情况下，可以考虑降级（如暂时关闭RSA加密，但必须配合HTTPS），但这需要非常谨慎的设计。

6.3 在Spring Security框架中集成

如果你的项目使用了Spring Security，你可能希望将解密逻辑集成到它的认证流程中，比如自定义一个 AuthenticationFilter 。

public class RsaAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    @Autowired
    private RsaKeyManager rsaKeyManager;

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        try {
            // 从请求中读取加密的密码
            String encryptedPassword = obtainPassword(request); // 需要重写obtainPassword方法或直接解析request
            String username = obtainUsername(request);

            // 解密
            String rawPassword = rsaKeyManager.decryptWithCurrentPrivateKey(encryptedPassword);

            // 使用解密后的密码构造AuthenticationToken
            UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, rawPassword);
            setDetails(request, authRequest);
            return this.getAuthenticationManager().authenticate(authRequest);
        } catch (Exception e) {
            throw new AuthenticationServiceException("RSA解密或认证失败", e);
        }
    }
}

然后，在Spring Security配置中用这个Filter替换掉默认的表单登录Filter。这样，密码的解密就无缝融入了Security的认证链。

6.4 前端公钥的管理策略

前端何时获取、如何缓存公钥，直接影响用户体验和安全性。

  • 策略一（推荐） ：每次打开登录页或需要加密时都获取。简单安全，无状态。用户感知到的延迟可以通过在页面加载时静默预获取来缓解。
  • 策略二 ：获取一次后长期缓存（如存localStorage）。风险是后端密钥轮换后，前端无法感知。可以在登录请求失败（特定错误码）时，强制清除缓存并重试获取。
  • 策略三 ：后端在响应中返回公钥的有效期（Expires），前端根据有效期决定是否重新获取。

我个人更倾向于策略一，配合预获取，实现复杂度和安全性最平衡。

集成这套机制后，最直观的感受就是登录请求的 payload 里再也看不到明文的 password 了，取而代之的是一长串毫无规律的密文。在Chrome开发者工具的Network面板里看到这个，心里会踏实很多。当然，安全是一个持续的过程，这套机制需要配合完善的日志监控（记录解密失败、重放攻击拦截等）、定期的密钥轮换策略以及全站的HTTPS，才能构成一道相对坚固的防线。

Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

一个 API 入口调用多个大模型：AiiOnly客户端 + CC Switch 打通 Codex AI编程流程

avatar AI编程社区
cover

VSCode Claude Code + MiMo 中转免登录完整配置教程（解决原生登录弹窗 + 模型报错）

avatar AI编程社区
cover

从零开始做一个属于自己的 Skill（保姆级教程）

avatar AI编程社区