Spring AI 企业级安全防护：密钥管理、内容审核与权限控制

2.2 实战配置：对称加密方案落地

步骤 1：配置 Config Server 的加密密钥

在 Config Server 的 application.yml 中配置对称加密密钥：

server:
  port: 8888
spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/xxx/spring-cloud-config-repo.git
          username: xxx
          password: xxx
        encrypt:
          key: spring-ai-security-key-2024

步骤 2：加密 API 密钥

启动 Config Server 后，通过 POST 请求加密明文密钥：

curl -X POST http://localhost:8888/encrypt -d "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

请求返回的密文格式为 {cipher}密文内容。

步骤 3：将密文写入配置仓库

在配置仓库中创建 spring-ai-dev.yml，写入加密后的 API 密钥：

spring:
  ai:
    openai:
      api-key: "{cipher}AgBC5tGjZ8Xy9L3aQ7fR2tN4uV6wY8xZ0..."
      base-url: https://api.openai.com/v1

步骤 4：配置 Spring AI 应用的解密环境

在 Spring AI 应用的 bootstrap.yml 中配置 Config Client，并确保应用拥有解密密钥：

spring:
  application:
    name: spring-ai-app
  cloud:
    config:
      uri: http://localhost:8888
      profile: dev
      encrypt:
        key: spring-ai-security-key-2024

步骤 5：验证密钥解密

在 Spring AI 应用中注入 API 密钥，验证是否解密成功：

@RestController
public class AiController {
    @Value("${spring.ai.openai.api-key}")
    private String openaiApiKey;

    @GetMapping("/api/key")
    public String getApiKey() {
        // 生产环境禁止返回密钥，此处仅用于验证
        return "密钥解密成功：" + openaiApiKey.startsWith("sk-");
    }
}

2.3 核心注意点

1. 加密密钥的保管：生产环境中，对称加密密钥不能写在配置文件中，应通过环境变量或密钥管理服务（如 KMS）注入；
2. 非对称加密的使用：大规模项目推荐使用非对称加密，公钥用于加密，私钥仅在配置客户端保存，进一步提升安全性；
3. 动态刷新：结合 Spring Cloud Bus 实现配置的动态刷新，无需重启应用即可更新密钥。

3. 内容审核：Moderation 模型与敏感词过滤的双保险机制

内容合规是企业级 AI 应用的核心要求，单一的审核机制难以覆盖所有风险。本文采用 Moderation 模型 + 敏感词过滤的双保险机制，实现对输入和输出内容的全面审核。

3.1 核心原理：双层次内容审核架构

• 第一层：Moderation 模型审核：利用大模型提供的 Moderation API（如 OpenAI 的 Moderation API），对内容进行语义级别的审核，识别仇恨言论、暴力、色情、自我伤害等违规内容；
• 第二层：敏感词过滤审核：基于词典的敏感词过滤（如 AC 自动机算法），对内容进行关键词级别的审核，识别政治敏感词、商业机密、个人隐私等内容。

双层次审核的流程为：输入内容先经过敏感词过滤，再经过 Moderation 模型审核；输出内容先经过 Moderation 模型审核，再经过敏感词过滤，确保内容全面合规。

3.2 实战实现：双保险内容审核

步骤 1：整合 OpenAI Moderation 模型

Spring AI 提供了对 Moderation 模型的原生支持，引入依赖后即可快速集成：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
</dependency>

创建 Moderation 审核服务：

@Service
public class ModerationService {
    private final OpenAiModerationClient moderationClient;

    @Autowired
    public ModerationService(OpenAiModerationClient moderationClient) {
        this.moderationClient = moderationClient;
    }

    /**
     * 审核内容是否合规
     * @param content 待审核内容
     * @return 合规返回 true，不合规返回 false
     */
    public boolean isContentCompliant(String content) {
        ModerationRequest request = new ModerationRequest(List.of(content));
        ModerationResponse response = moderationClient.moderate(request);
        // 只要有一个内容不合规，就返回 false
        return response.results().stream().noneMatch(ModerationResult::flagged);
    }
}

步骤 2：实现敏感词过滤服务

基于 AC 自动机算法实现高效敏感词过滤（AC 自动机适合大规模敏感词库的快速匹配）：

@Service
public class SensitiveWordFilter {
    // 敏感词库，生产环境应从配置中心加载
    private static final Set<String> SENSITIVE_WORDS = Set.of("敏感词 1", "敏感词 2", "敏感词 3");
    private AcAutomaton acAutomaton;

    @PostConstruct
    public void init() {
        // 初始化 AC 自动机
        acAutomaton = new AcAutomaton();
        acAutomaton.buildTrie(SENSITIVE_WORDS);
        acAutomaton.buildFailureLinks();
    }

    /**
     * 检测内容是否包含敏感词
     * @param content 待检测内容
     * @return 包含敏感词返回 true，否则返回 false
     */
    public boolean containsSensitiveWord(String content) {
        return acAutomaton.match(content).size() > 0;
    }

    /**
     * 替换内容中的敏感词
     * @param content 待处理内容
     * @return 替换后的内容
     */
    public String replaceSensitiveWord(String content) {
        return acAutomaton.replace(content, '*');
    }
}

步骤 3：实现双保险审核流程

创建内容审核总服务，整合 Moderation 模型和敏感词过滤：

@Service
public class ContentAuditService {
    private final ModerationService moderationService;
    private final SensitiveWordFilter sensitiveWordFilter;

    @Autowired
    public ContentAuditService(ModerationService moderationService, SensitiveWordFilter sensitiveWordFilter) {
        this.moderationService = moderationService;
        this.sensitiveWordFilter = sensitiveWordFilter;
    }

    /**
     * 输入内容审核：敏感词过滤 → Moderation 模型
     * @param content 输入内容
     * @return 审核结果
     */
    public AuditResult auditInput(String content) {
        // 第一步：敏感词过滤
        if (sensitiveWordFilter.containsSensitiveWord(content)) {
            return AuditResult.fail("输入内容包含敏感词");
        }
        // 第二步：Moderation 模型审核
        if (!moderationService.isContentCompliant(content)) {
            return AuditResult.fail("输入内容不合规");
        }
        return AuditResult.success();
    }

    /**
     * 输出内容审核：Moderation 模型 → 敏感词过滤（替换）
     * @param content 输出内容
     * @return 审核结果
     */
    public AuditResult auditOutput(String content) {
        // 第一步：Moderation 模型审核
        if (!moderationService.isContentCompliant(content)) {
            return AuditResult.fail("输出内容不合规");
        }
        // 第二步：敏感词过滤并替换
        String processedContent = sensitiveWordFilter.replaceSensitiveWord(content);
        return AuditResult.success(processedContent);
    }

    // 审核结果封装类
    public static class AuditResult {
        private final boolean success;
        private final String message;
        private final String content;

        private AuditResult(boolean success, String message, String content) {
            this.success = success;
            this.message = message;
            this.content = content;
        }

        public static AuditResult success() {
            return new AuditResult(true, "审核通过", null);
        }

        public static AuditResult success(String content) {
            return new AuditResult(true, "审核通过", content);
        }

        public static AuditResult fail(String message) {
            return new AuditResult(false, message, null);
        }

        // getter 方法省略
    }
}

步骤 4：在 AI 接口中集成内容审核

@RestController
@RequestMapping("/api/ai")
public class AiChatController {
    private final OpenAiChatClient chatClient;
    private final ContentAuditService contentAuditService;

    @Autowired
    public AiChatController(OpenAiChatClient chatClient, ContentAuditService contentAuditService) {
        this.chatClient = chatClient;
        this.contentAuditService = contentAuditService;
    }

    @PostMapping("/chat")
    public String chat(@RequestParam String message) {
        // 输入内容审核
        ContentAuditService.AuditResult inputResult = contentAuditService.auditInput(message);
        if (!inputResult.isSuccess()) {
            return inputResult.getMessage();
        }

        // 调用 AI 生成内容
        String aiResponse = chatClient.call(message);

        // 输出内容审核
        ContentAuditService.AuditResult outputResult = contentAuditService.auditOutput(aiResponse);
        if (!outputResult.isSuccess()) {
            return outputResult.getMessage();
        }

        return outputResult.getContent();
    }
}

4. 权限控制：Spring Security 整合 AI 服务访问权限

企业级 AI 应用需要对不同角色的用户进行精细化的权限控制，Spring Security 作为 Spring 生态的安全核心，可与 Spring AI 深度整合，实现对 AI 服务的访问权限管控。

4.1 核心原理：Spring Security 整合 AI 服务的权限模型

Spring Security 整合 AI 服务的权限模型基于资源 - 角色 - 权限的三层架构：

• 资源：AI 服务的具体功能，如 chat（对话功能）、embedding（向量生成功能）、fine-tune（模型微调功能）；
• 角色：企业内部的用户角色，如 ADMIN（管理员）、DEVELOPER（开发人员）、USER（普通用户）；
• 权限：角色对资源的访问权限，如 ADMIN 拥有所有资源的访问权限，DEVELOPER 拥有 chat 和 embedding 的权限，USER 仅拥有 chat 的权限。

通过自定义权限表达式和资源处理器，Spring Security 可以实现对 AI 服务资源的精细化权限控制。

4.2 核心配置：Spring Security 与 AI 服务的整合

步骤 1：定义 AI 服务资源和角色权限

创建权限常量类，定义 AI 服务的资源和角色权限：

public class AiSecurityConstants {
    // AI 服务资源
    public static final String RESOURCE_CHAT = "ai:chat";
    public static final String RESOURCE_EMBEDDING = "ai:embedding";
    public static final String RESOURCE_FINE_TUNE = "ai:fine-tune";

    // 角色
    public static final String ROLE_ADMIN = "ROLE_ADMIN";
    public static final String ROLE_DEVELOPER = "ROLE_DEVELOPER";
    public static final String ROLE_USER = "ROLE_USER";

    // 角色 - 权限映射
    public static final Map<String, List<String>> ROLE_PERMISSION_MAP = Map.of(
        ROLE_ADMIN, List.of(RESOURCE_CHAT, RESOURCE_EMBEDDING, RESOURCE_FINE_TUNE),
        ROLE_DEVELOPER, List.of(RESOURCE_CHAT, RESOURCE_EMBEDDING),
        ROLE_USER, List.of(RESOURCE_CHAT)
    );
}

步骤 2：配置 Spring Security 的用户和权限

使用内存用户存储（生产环境推荐使用数据库）配置用户和角色：

@Configuration
@EnableWebSecurity
@EnableMethodSecurity // 启用方法级权限控制
public class SecurityConfig {
    @Bean
    public UserDetailsService userDetailsService() {
        // 配置管理员用户
        UserDetails admin = User.withUsername("admin")
                .password(passwordEncoder().encode("admin123"))
                .roles(AiSecurityConstants.ROLE_ADMIN.replace("ROLE_", ""))
                .build();
        // 配置开发人员用户
        UserDetails developer = User.withUsername("dev")
                .password(passwordEncoder().encode("dev123"))
                .roles(AiSecurityConstants.ROLE_DEVELOPER.replace("ROLE_", ""))
                .build();
        // 配置普通用户
        UserDetails user = User.withUsername("user")
                .password(passwordEncoder().encode("user123"))
                .roles(AiSecurityConstants.ROLE_USER.replace("ROLE_", ""))
                .build();
        return new InMemoryUserDetailsManager(admin, developer, user);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/api/ai/**").authenticated() // AI 接口需要认证
                .anyRequest().permitAll()
        ).httpBasic(Customizer.withDefaults()) // 启用 HTTP Basic 认证
        .csrf(csrf -> csrf.disable()); // 测试环境禁用 CSRF，生产环境需启用
        return http.build();
    }
}

步骤 3：自定义权限表达式

创建自定义权限表达式处理器，实现对 AI 服务资源的权限判断：

@Component
public class AiPermissionEvaluator implements PermissionEvaluator {
    @Override
    public boolean hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
        // 获取当前用户的角色
        Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
        List<String> roles = authorities.stream()
                .map(GrantedAuthority::getAuthority)
                .toList();

        // 获取需要的权限（AI 服务资源）
        String requiredPermission = (String) permission;

        // 判断角色是否拥有该权限
        for (String role : roles) {
            List<String> permissions = AiSecurityConstants.ROLE_PERMISSION_MAP.get(role);
            if (permissions != null && permissions.contains(requiredPermission)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
        return false;
    }
}

配置自定义权限表达式：

@Configuration
public class MethodSecurityConfig {
    @Bean
    public MethodSecurityExpressionHandler methodSecurityExpressionHandler(AiPermissionEvaluator permissionEvaluator) {
        DefaultMethodSecurityExpressionHandler handler = new DefaultMethodSecurityExpressionHandler();
        handler.setPermissionEvaluator(permissionEvaluator);
        return handler;
    }
}

5. 实战攻坚：实现多角色的 AI 服务访问控制

本节通过实战案例，实现多角色对 AI 服务的访问控制。

5.1 实战实现：多角色 AI 服务接口

创建不同的 AI 服务接口，使用 @PreAuthorize 注解实现方法级权限控制：

@RestController
@RequestMapping("/api/ai")
public class AiPermissionController {
    private final OpenAiChatClient chatClient;
    private final OpenAiEmbeddingClient embeddingClient;
    private final FineTuneService fineTuneService;

    @Autowired
    public AiPermissionController(OpenAiChatClient chatClient, OpenAiEmbeddingClient embeddingClient, FineTuneService fineTuneService) {
        this.chatClient = chatClient;
        this.embeddingClient = embeddingClient;
        this.fineTuneService = fineTuneService;
    }

    /**
     * 对话功能：所有角色均可访问
     */
    @PostMapping("/chat")
    @PreAuthorize("hasPermission(null, '" + AiSecurityConstants.RESOURCE_CHAT + '")')
    public String chat(@RequestParam String message) {
        return chatClient.call(message);
    }

    /**
     * 向量生成功能：管理员和开发人员可访问
     */
    @PostMapping("/embedding")
    @PreAuthorize("hasPermission(null, '" + AiSecurityConstants.RESOURCE_EMBEDDING + '")')
    public List<Double> embedding(@RequestParam String text) {
        EmbeddingResponse response = embeddingClient.call(new EmbeddingRequest(text));
        return response.getEmbedding();
    }

    /**
     * 模型微调功能：仅管理员可访问
     */
    @PostMapping("/fine-tune")
    @PreAuthorize("hasPermission(null, '" + AiSecurityConstants.RESOURCE_FINE_TUNE + '")')
    public String fineTune(@RequestParam String datasetId) {
        return fineTuneService.fineTuneModel(datasetId);
    }
}

5.2 鉴权流程图

多角色 AI 服务访问控制的鉴权流程如下：

5.3 测试验证

通过不同角色的用户调用接口，验证权限控制是否生效：

1. 普通用户（user/user123）：调用 /api/ai/chat 成功，调用 /api/ai/embedding 返回 403；
2. 开发人员（dev/dev123）：调用 /api/ai/chat 和 /api/ai/embedding 成功，调用 /api/ai/fine-tune 返回 403；
3. 管理员（admin/admin123）：调用所有接口均成功。

6. 避坑指南：Spring AI 安全防护的 5 个核心注意点

6.1 避坑 1：Config Server 加密密钥硬编码

问题：将 Config Server 的加密密钥硬编码在配置文件中，导致密钥泄露风险。 解决方案：生产环境中，通过环境变量或密钥管理服务（如 AWS KMS、阿里云 KMS）注入加密密钥。

6.2 避坑 2：Moderation 模型审核误判

问题：Moderation 模型可能对正常内容产生误判，影响用户体验。 解决方案：建立误判反馈机制，对误判内容进行人工审核，并优化敏感词过滤规则。

6.3 避坑 3：权限表达式配置错误

问题：@PreAuthorize 注解中的权限表达式配置错误，导致权限控制失效。 解决方案：使用常量定义权限表达式，避免硬编码，并编写单元测试验证权限控制逻辑。

6.4 避坑 4：敏感词库静态化

问题：敏感词库硬编码在代码中，无法动态更新。 解决方案：将敏感词库存储在配置中心或数据库中，结合 Spring Cloud Bus 实现动态刷新。

6.5 避坑 5：忽略 AI 服务的访问日志

问题：未记录 AI 服务的访问日志，导致安全事件无法追溯。 解决方案：整合 Spring Security 的审计功能，记录用户对 AI 服务的访问日志，包括用户名、访问时间、访问资源、操作结果等。

7. 总结

企业级 AI 应用的安全防护是一个全链路、多层次的系统工程。本文基于 Spring AI 生态，从三大核心维度构建了完整的风控体系：

• 密钥管理：通过 Spring Cloud Config 的加密存储方案，解决了 API 密钥的泄露风险；
• 内容审核：通过 Moderation 模型与敏感词过滤的双保险机制，实现了输入和输出内容的合规性管控；
• 权限控制：通过 Spring Security 与 AI 服务的深度整合，实现了多角色的精细化权限控制。

这套全链路防护体系不仅解决了 Spring AI 应用的核心安全痛点，还与 Spring 生态无缝整合，具有良好的扩展性和可维护性。未来，随着大模型技术的不断发展，企业级 AI 应用的安全防护将朝着智能化、自动化的方向演进，例如利用大模型自身的能力实现对安全风险的智能识别和预警，以及结合运维自动化工具实现对安全事件的自动响应和处理。