等保 2.0 合规架构：分布式系统全链路落地实战指南

殷紫川
0 阅读16分钟

随着数字化转型的深入，分布式微服务架构已成为企业系统建设的主流选择，而《网络安全等级保护条例》的落地，让等保2.0成为所有非涉密信息系统的强制合规要求。分布式系统节点分散、链路复杂、边界动态变化的特性，与等保2.0“一个中心、三重防护”的纵深防御体系存在天然的适配难点，很多企业在合规落地中出现“表面过审、实际裸奔”的问题，甚至因为合规不达标面临行政处罚。

一、等保2.0核心框架与分布式系统合规痛点

1.1 等保2.0核心技术体系

等保2.0的核心技术体系是“一个中心、三重防护”的纵深防御模型，所有合规要求均围绕该模型展开：

  • 安全管理中心：对全系统的安全策略、审计日志、安全事件、风险状况进行统一管控，是整个安全体系的大脑
  • 安全通信网络：保障数据在传输过程中的保密性、完整性，防止传输链路中的窃听、篡改、重放攻击
  • 安全区域边界：明确系统安全边界，对跨边界的访问进行精准管控，阻断非法入侵与越权访问
  • 安全计算环境：保障服务器、应用、数据等计算资源的安全，是等保合规的核心控制点，覆盖70%以上的测评项

1.2 分布式系统的合规核心痛点

相比单体系统，分布式架构在等保合规落地中面临四大核心挑战：

  • 安全边界模糊化：微服务多节点、跨集群、跨云部署，传统基于物理边界的防护模式完全失效，横向渗透风险大幅提升
  • 身份链路碎片化：用户请求从终端到网关、再到多个微服务、最终到数据库，经过多跳节点，身份传递过程易出现伪造、冒用问题
  • 审计日志分散化：每个微服务、中间件、数据库都有独立的日志体系，无法实现全链路操作的可追溯、不可篡改，无法满足审计要求
  • 防护规则静态化：容器化、云原生环境下，服务实例动态扩缩容，传统静态的IP、端口防护规则无法适配动态的架构变化

二、分布式等保2.0合规架构核心设计原则

基于等保2.0的标准要求，结合分布式架构的特性，合规架构设计需遵循五大核心原则：

  1. 纵深防御原则：构建从网络边界到应用、再到数据的多层防护体系，单点防护失效不会导致整个系统被突破
  2. 最小权限原则：对每个服务账号、用户账号、运维账号，仅授予完成业务所需的最小权限，严格禁止超权限分配
  3. 全链路可审计原则：所有用户操作、服务调用、系统事件都必须有完整的审计记录，记录可追溯、不可篡改，保存时间不少于6个月
  4. 内生安全原则：将安全能力嵌入分布式架构的设计阶段，而非业务上线后的补丁式防护，实现安全与业务的深度融合
  5. 零信任动态防护原则：默认不信任任何内部或外部的访问请求，所有访问都必须经过身份认证、权限校验、加密传输，适配分布式架构的动态变化

三、分布式系统等保2.0合规架构分层落地

3.1 安全通信网络层：全链路传输安全防护

安全通信网络层是等保2.0的第一道防线，核心目标是保障数据在整个传输链路中的保密性与完整性，防止传输过程中的安全风险。

3.1.1 合规核心要求

GB/T 22239-2019对通信网络的核心合规要求包括：

  • 通信双方必须经过双向身份鉴别，防止身份伪造
  • 传输过程中的重要数据必须采用密码技术保证保密性与完整性
  • 必须具备通信会话的抗重放能力，防止重放攻击
  • 必须能够检测到通信过程中的异常行为，并进行告警与阻断

3.1.2 架构设计

全链路加密传输架构如下：

3.1.3 落地实现方案

  1. 外网接入层强制TLS 1.3加密 外网接入必须禁用SSL、TLS 1.0/1.1等不安全协议，强制使用TLS 1.3，配置强加密套件，示例Nginx配置如下：
server {
    listen 443 ssl http2;
    server_name demo.jam.com;
    ssl_protocols TLSv1.3;
    ssl_ciphers TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1d;
    ssl_stapling on;
    ssl_stapling_verify on;
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
}

2. 数据库通信强制加密 MySQL 8.0开启强制SSL连接，配置如下：

SET GLOBAL require_secure_transport = ON;
CREATE USER 'app_user'@'%' IDENTIFIED BY 'Your_Strong_Password_123!' REQUIRE SSL;
GRANT SELECT,INSERT,UPDATE,DELETE ON jam_demo.* TO 'app_user'@'%';
FLUSH PRIVILEGES;

Spring Boot项目中MySQL连接配置如下：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/jam_demo?useSSL=true&requireSSL=true&verifyServerCertificate=true
    username: app_user
    password: Your_Strong_Password_123!
    driver-class-name: com.mysql.cj.jdbc.Driver

3. 服务间通信mTLS双向认证 微服务间通信采用mTLS双向认证，防止服务间的身份伪造，Spring Boot服务TLS配置示例如下：

server:
  ssl:
    enabled: true
    key-store: classpath:server.p12
    key-store-password: ${KEY_STORE_PASSWORD}
    key-store-type: PKCS12
    key-alias: server
    trust-store: classpath:truststore.p12
    trust-store-password: ${TRUST_STORE_PASSWORD}
    trust-store-type: PKCS12
    client-auth: need

4. 通信会话抗重放保护 基于请求签名、时间戳、nonce随机数实现抗重放攻击，请求签名工具类实现如下：

package com.jam.demo.common.utils;

import com.alibaba.fastjson2.JSON;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;
import org.springframework.util.StringUtils;
import com.jam.demo.common.exception.BusinessException;

import java.nio.charset.StandardCharsets;
import java.security.Security;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * 请求签名工具类
 * @author ken
 */
public class SignUtils {

    static {
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    private static final long VALID_TIME_WINDOW = 5 * 60 * 1000L;

    /**
     * 生成请求签名
     * @param params 请求参数
     * @param timestamp 时间戳
     * @param nonce 随机数
     * @param appSecret 应用密钥
     * @return 签名值
     */
    public static String generateSign(SortedMap<String, Object> params, long timestamp, String nonce, String appSecret) {
        if (!StringUtils.hasText(nonce)) {
            throw new BusinessException("nonce不能为空");
        }
        if (!StringUtils.hasText(appSecret)) {
            throw new BusinessException("appSecret不能为空");
        }
        SortedMap<String, Object> sortedMap = new TreeMap<>(params);
        sortedMap.put("timestamp", timestamp);
        sortedMap.put("nonce", nonce);
        StringBuilder signContent = new StringBuilder();
        for (SortedMap.Entry<String, Object> entry : sortedMap.entrySet()) {
            if (!StringUtils.hasText(entry.getKey()) || entry.getValue() == null) {
                continue;
            }
            signContent.append(entry.getKey()).append("=");
            if (entry.getValue() instanceof String) {
                signContent.append(entry.getValue());
            } else {
                signContent.append(JSON.toJSONString(entry.getValue()));
            }
            signContent.append("&");
        }
        signContent.append("appSecret=").append(appSecret);
        return sm3Hash(signContent.toString());
    }

    /**
     * 校验请求签名
     * @param params 请求参数
     * @param timestamp 时间戳
     * @param nonce 随机数
     * @param appSecret 应用密钥
     * @param sign 待校验的签名
     * @return 校验结果
     */
    public static boolean verifySign(SortedMap<String, Object> params, long timestamp, String nonce, String appSecret, String sign) {
        long currentTime = System.currentTimeMillis();
        if (Math.abs(currentTime - timestamp) > VALID_TIME_WINDOW) {
            return false;
        }
        String generateSign = generateSign(params, timestamp, nonce, appSecret);
        return generateSign.equalsIgnoreCase(sign);
    }

    /**
     * 国密SM3哈希算法
     * @param content 待哈希内容
     * @return 哈希结果
     */
    private static String sm3Hash(String content) {
        try {
            org.bouncycastle.crypto.digests.SM3Digest digest = new org.bouncycastle.crypto.digests.SM3Digest();
            byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
            digest.update(bytes, 0, bytes.length);
            byte[] hashResult = new byte[digest.getDigestSize()];
            digest.doFinal(hashResult, 0);
            return Hex.toHexString(hashResult);
        } catch (Exception e) {
            throw new BusinessException("SM3哈希计算失败", e);
        }
    }
}

3.2 安全区域边界层：精准访问控制与入侵防护

安全区域边界层是分布式系统的第二道防线，核心目标是明确系统的安全边界，对所有跨边界的访问进行严格管控，阻断非法入侵与越权访问。

3.2.1 合规核心要求

GB/T 22239-2019对区域边界的核心合规要求包括：

  • 必须明确划分安全区域，对跨越边界的数据流进行访问控制
  • 必须对进出边界的网络流量进行攻击检测，阻断常见的网络攻击行为
  • 必须对无线网络、远程接入、第三方接口接入进行专项安全管控
  • 必须对边界的安全事件进行完整审计，实现可追溯

3.2.2 架构设计

分布式系统安全区域划分与边界防护架构如下：

3.2.3 落地实现方案

  1. 安全区域划分与最小权限ACL规则 按照业务功能、数据敏感级别划分安全区域，每个区域之间采用默认拒绝的ACL规则，仅开放业务必需的端口与通信链路：
  • DMZ区域：仅对外开放443端口，仅允许HTTPS流量进入
  • API网关区域：仅允许DMZ区域的443流量进入，仅开放网关服务端口
  • 业务微服务区域：仅允许API网关区域的流量进入，禁止外网直接访问
  • 数据存储区域：仅允许业务微服务区域的对应端口访问，禁止其他区域直接访问
  • 运维管理区域：仅通过堡垒机访问其他区域，禁止直接跨区域访问
  1. API网关边界防护 API网关是分布式系统的核心入口，必须实现全量请求的身份认证、权限校验、攻击检测、流量控制，Spring Cloud Gateway自定义XSS攻击过滤过滤器实现如下：
package com.jam.demo.gateway.filter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.regex.Pattern;

/**
 * XSS攻击检测全局过滤器
 * @author ken
 */
@Slf4j
@Component
public class XssAttackFilter implements GlobalFilter, Ordered {

    private static final Pattern XSS_PATTERN = Pattern.compile(
            "<script.*?>.*?</script>|javascript:|onerror=|onclick=|onload=|alert\(|confirm\(|prompt\(",
            Pattern.CASE_INSENSITIVE
    );

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String requestPath = request.getPath().value();
        if (isWhiteList(requestPath)) {
            return chain.filter(exchange);
        }
        for (String paramName : request.getQueryParams().keySet()) {
            String paramValue = request.getQueryParams().getFirst(paramName);
            if (hasXssRisk(paramValue)) {
                return blockRequest(exchange, "请求参数包含XSS攻击内容");
            }
        }
        if (request.getHeaders().getContentType() != null && request.getHeaders().getContentType().includes(org.springframework.http.MediaType.APPLICATION_JSON)) {
            return DataBufferUtils.join(request.getBody())
                    .flatMap(dataBuffer -> {
                        byte[] content = new byte[dataBuffer.readableByteCount()];
                        dataBuffer.read(content);
                        DataBufferUtils.release(dataBuffer);
                        String bodyContent = new String(content, StandardCharsets.UTF_8);
                        if (hasXssRisk(bodyContent)) {
                            return blockRequest(exchange, "请求体包含XSS攻击内容");
                        }
                        DataBuffer newBuffer = exchange.getResponse().bufferFactory().wrap(content);
                        ServerHttpRequest newRequest = request.mutate().body(Flux.just(newBuffer)).build();
                        return chain.filter(exchange.mutate().request(newRequest).build());
                    });
        }
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE + 1;
    }

    private boolean isWhiteList(String path) {
        return path.startsWith("/health") || path.startsWith("/actuator");
    }

    private boolean hasXssRisk(String content) {
        if (!StringUtils.hasText(content)) {
            return false;
        }
        return XSS_PATTERN.matcher(content).find();
    }

    private Mono<Void> blockRequest(ServerWebExchange exchange, String message) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(HttpStatus.BAD_REQUEST);
        response.getHeaders().setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
        String responseBody = "{"code":400,"message":"" + message + ""}";
        DataBuffer buffer = response.bufferFactory().wrap(responseBody.getBytes(StandardCharsets.UTF_8));
        return response.writeWith(Mono.just(buffer));
    }
}

3. 微服务间零信任访问控制 摒弃“内网即可信”的传统理念，微服务间调用必须进行身份认证与权限校验，基于Spring Security实现服务间调用的Token校验拦截器如下：

package com.jam.demo.common.interceptor;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import com.jam.demo.common.utils.JwtUtils;
import com.jam.demo.common.exception.BusinessException;

/**
 * 服务间调用身份认证拦截器
 * @author ken
 */
@Slf4j
public class ServiceAuthInterceptor implements HandlerInterceptor {

    private final JwtUtils jwtUtils;

    public ServiceAuthInterceptor(JwtUtils jwtUtils) {
        this.jwtUtils = jwtUtils;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String token = request.getHeader("X-Service-Token");
        if (!StringUtils.hasText(token)) {
            throw new BusinessException("服务调用令牌不能为空");
        }
        if (!jwtUtils.validateToken(token)) {
            throw new BusinessException("服务调用令牌无效");
        }
        String serviceId = jwtUtils.getServiceIdFromToken(token);
        request.setAttribute("callerServiceId", serviceId);
        return true;
    }
}

3.3 安全计算环境层：核心合规控制点落地

安全计算环境层是等保2.0合规的核心，覆盖70%以上的测评项，核心目标是保障服务器、应用、数据等计算资源的全生命周期安全。

3.3.1 合规核心要求

GB/T 22239-2019对安全计算环境的核心控制点包括：身份鉴别、访问控制、安全审计、入侵防范、数据完整性、数据保密性、数据备份恢复、剩余信息保护、资源控制。

3.3.2 身份鉴别落地实现

身份鉴别是安全计算环境的第一道关卡，等保2.0要求必须实现用户身份的唯一性标识、强密码策略、登录失败处理、多因素认证。

  1. 数据库表设计
CREATE TABLE sys_user (
    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '用户ID',
    username VARCHAR(64) NOT NULL COMMENT '用户名',
    password VARCHAR(128) NOT NULL COMMENT '密码哈希',
    full_name VARCHAR(64) NOT NULL COMMENT '用户姓名',
    phone VARCHAR(32) COMMENT '手机号',
    email VARCHAR(64) COMMENT '邮箱',
    status TINYINT NOT NULL DEFAULT 1 COMMENT '状态 0-禁用 1-正常',
    login_fail_count INT NOT NULL DEFAULT 0 COMMENT '登录失败次数',
    lock_time DATETIME COMMENT '锁定时间',
    last_login_time DATETIME COMMENT '最后登录时间',
    last_login_ip VARCHAR(64) COMMENT '最后登录IP',
    pwd_update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '密码更新时间',
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (id),
    UNIQUE INDEX uk_username (username)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='系统用户表';

2. 用户登录服务实现

package com.jam.demo.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jam.demo.system.entity.SysUser;
import com.jam.demo.system.mapper.SysUserMapper;
import com.jam.demo.system.service.SysUserService;
import com.jam.demo.common.utils.PasswordUtils;
import com.jam.demo.common.utils.JwtUtils;
import com.jam.demo.common.exception.BusinessException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

/**
 * 系统用户服务实现类
 * @author ken
 */
@Slf4j
@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserService {

    private static final int MAX_LOGIN_FAIL_COUNT = 5;
    private static final int LOCK_DURATION_MINUTES = 30;
    private static final int PWD_VALID_DAYS = 90;

    private final TransactionTemplate transactionTemplate;
    private final PasswordUtils passwordUtils;
    private final JwtUtils jwtUtils;

    public SysUserServiceImpl(TransactionTemplate transactionTemplate, PasswordUtils passwordUtils, JwtUtils jwtUtils) {
        this.transactionTemplate = transactionTemplate;
        this.passwordUtils = passwordUtils;
        this.jwtUtils = jwtUtils;
    }

    /**
     * 用户登录
     * @param username 用户名
     * @param password 密码
     * @param ipAddress 登录IP地址
     * @return 登录结果，包含token与用户信息
     */
    @Override
    public Map<String, Object> login(String username, String password, String ipAddress) {
        if (!StringUtils.hasText(username)) {
            throw new BusinessException("用户名不能为空");
        }
        if (!StringUtils.hasText(password)) {
            throw new BusinessException("密码不能为空");
        }
        SysUser user = this.getOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUsername, username));
        if (ObjectUtils.isEmpty(user)) {
            throw new BusinessException("用户名或密码错误");
        }
        if (user.getStatus() == 0) {
            throw new BusinessException("账号已被禁用");
        }
        if (user.getLockTime() != null && user.getLockTime().isAfter(LocalDateTime.now())) {
            throw new BusinessException("账号已被锁定，请" + LOCK_DURATION_MINUTES + "分钟后重试");
        }
        if (!passwordUtils.matches(password, user.getPassword())) {
            handleLoginFail(user);
            throw new BusinessException("用户名或密码错误，连续错误" + MAX_LOGIN_FAIL_COUNT + "次将锁定账号");
        }
        if (user.getPwdUpdateTime().plusDays(PWD_VALID_DAYS).isBefore(LocalDateTime.now())) {
            throw new BusinessException("密码已过期，请修改密码后重新登录");
        }
        resetLoginFailCount(user);
        updateLoginInfo(user, ipAddress);
        String token = jwtUtils.generateToken(user.getId(), user.getUsername());
        Map<String, Object> result = new HashMap<>();
        result.put("token", token);
        result.put("userId", user.getId());
        result.put("username", user.getUsername());
        result.put("fullName", user.getFullName());
        return result;
    }

    /**
     * 处理登录失败
     * @param user 用户实体
     */
    private void handleLoginFail(SysUser user) {
        transactionTemplate.execute(new TransactionCallback<Void>() {
            @Override
            public Void doInTransaction(TransactionStatus status) {
                int newFailCount = user.getLoginFailCount() + 1;
                user.setLoginFailCount(newFailCount);
                if (newFailCount >= MAX_LOGIN_FAIL_COUNT) {
                    user.setLockTime(LocalDateTime.now().plusMinutes(LOCK_DURATION_MINUTES));
                }
                updateById(user);
                return null;
            }
        });
    }

    /**
     * 重置登录失败次数
     * @param user 用户实体
     */
    private void resetLoginFailCount(SysUser user) {
        if (user.getLoginFailCount() > 0) {
            transactionTemplate.execute(new TransactionCallback<Void>() {
                @Override
                public Void doInTransaction(TransactionStatus status) {
                    user.setLoginFailCount(0);
                    user.setLockTime(null);
                    updateById(user);
                    return null;
                }
            });
        }
    }

    /**
     * 更新登录信息
     * @param user 用户实体
     * @param ipAddress 登录IP地址
     */
    private void updateLoginInfo(SysUser user, String ipAddress) {
        transactionTemplate.execute(new TransactionCallback<Void>() {
            @Override
            public Void doInTransaction(TransactionStatus status) {
                user.setLastLoginTime(LocalDateTime.now());
                user.setLastLoginIp(ipAddress);
                updateById(user);
                return null;
            }
        });
    }
}

3.3.3 访问控制落地实现

等保2.0要求必须实现最小权限的访问控制，采用RBAC+ABAC的访问控制模型，实现功能权限与数据权限的精准管控。

  1. RBAC模型数据库表设计
CREATE TABLE sys_role (
    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '角色ID',
    role_name VARCHAR(64) NOT NULL COMMENT '角色名称',
    role_code VARCHAR(64) NOT NULL COMMENT '角色编码',
    status TINYINT NOT NULL DEFAULT 1 COMMENT '状态 0-禁用 1-正常',
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (id),
    UNIQUE INDEX uk_role_code (role_code)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='系统角色表';

CREATE TABLE sys_permission (
    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '权限ID',
    parent_id BIGINT NOT NULL DEFAULT 0 COMMENT '父权限ID',
    permission_name VARCHAR(64) NOT NULL COMMENT '权限名称',
    permission_code VARCHAR(128) NOT NULL COMMENT '权限编码',
    permission_type TINYINT NOT NULL COMMENT '权限类型 1-菜单 2-按钮 3-接口',
    url VARCHAR(256) COMMENT '接口URL',
    method VARCHAR(16) COMMENT '请求方法',
    sort INT NOT NULL DEFAULT 0 COMMENT '排序',
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (id),
    UNIQUE INDEX uk_permission_code (permission_code),
    INDEX idx_parent_id (parent_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='系统权限表';

CREATE TABLE sys_user_role (
    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
    user_id BIGINT NOT NULL COMMENT '用户ID',
    role_id BIGINT NOT NULL COMMENT '角色ID',
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    PRIMARY KEY (id),
    UNIQUE INDEX uk_user_role (user_id, role_id),
    INDEX idx_user_id (user_id),
    INDEX idx_role_id (role_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='用户角色关联表';

CREATE TABLE sys_role_permission (
    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
    role_id BIGINT NOT NULL COMMENT '角色ID',
    permission_id BIGINT NOT NULL COMMENT '权限ID',
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    PRIMARY KEY (id),
    UNIQUE INDEX uk_role_permission (role_id, permission_id),
    INDEX idx_role_id (role_id),
    INDEX idx_permission_id (permission_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='角色权限关联表';

2. 权限校验拦截器实现

package com.jam.demo.common.interceptor;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import com.jam.demo.common.utils.JwtUtils;
import com.jam.demo.system.service.SysPermissionService;
import com.jam.demo.common.exception.BusinessException;

/**
 * 权限校验拦截器
 * @author ken
 */
@Slf4j
public class PermissionInterceptor implements HandlerInterceptor {

    private final JwtUtils jwtUtils;
    private final SysPermissionService sysPermissionService;

    public PermissionInterceptor(JwtUtils jwtUtils, SysPermissionService sysPermissionService) {
        this.jwtUtils = jwtUtils;
        this.sysPermissionService = sysPermissionService;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String token = request.getHeader("Authorization");
        if (!StringUtils.hasText(token) || !token.startsWith("Bearer ")) {
            throw new BusinessException("用户未登录");
        }
        token = token.substring(7);
        if (!jwtUtils.validateToken(token)) {
            throw new BusinessException("登录令牌无效");
        }
        Long userId = jwtUtils.getUserIdFromToken(token);
        request.setAttribute("userId", userId);
        String requestUrl = request.getRequestURI();
        String requestMethod = request.getMethod();
        boolean hasPermission = sysPermissionService.hasPermission(userId, requestUrl, requestMethod);
        if (!hasPermission) {
            throw new BusinessException("无操作权限");
        }
        return true;
    }
}

3.3.4 安全审计落地实现

等保2.0要求必须实现全量操作的安全审计，审计记录必须可追溯、不可篡改，保存时间不少于6个月。

  1. 审计日志表设计
CREATE TABLE sys_audit_log (
    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
    trace_id VARCHAR(64) NOT NULL COMMENT '全链路追踪ID',
    operator_id BIGINT COMMENT '操作人ID',
    operator_name VARCHAR(64) COMMENT '操作人姓名',
    operation_type VARCHAR(32) NOT NULL COMMENT '操作类型',
    operation_desc VARCHAR(256) NOT NULL COMMENT '操作描述',
    request_url VARCHAR(512) NOT NULL COMMENT '请求URL',
    request_method VARCHAR(16) NOT NULL COMMENT '请求方法',
    request_params TEXT COMMENT '请求参数',
    response_result TEXT COMMENT '响应结果',
    ip_address VARCHAR(64) NOT NULL COMMENT '操作IP地址',
    operation_status TINYINT NOT NULL COMMENT '操作状态 0-失败 1-成功',
    error_message TEXT COMMENT '错误信息',
    operation_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '操作时间',
    PRIMARY KEY (id),
    INDEX idx_trace_id (trace_id),
    INDEX idx_operator_id (operator_id),
    INDEX idx_operation_time (operation_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='系统审计日志表';

CREATE USER 'audit_user'@'%' IDENTIFIED BY 'Audit_Strong_Password_123!' REQUIRE SSL;
GRANT INSERT ON jam_demo.sys_audit_log TO 'audit_user'@'%';
FLUSH PRIVILEGES;

2. 审计日志AOP切面实现

package com.jam.demo.common.aspect;

import com.alibaba.fastjson2.JSON;
import com.jam.demo.common.annotation.AuditLog;
import com.jam.demo.common.utils.TraceIdUtils;
import com.jam.demo.system.entity.SysAuditLog;
import com.jam.demo.system.service.SysAuditLogService;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.util.Arrays;

/**
 * 审计日志切面
 * @author ken
 */
@Slf4j
@Aspect
@Component
public class AuditLogAspect {

    private final SysAuditLogService sysAuditLogService;

    public AuditLogAspect(SysAuditLogService sysAuditLogService) {
        this.sysAuditLogService = sysAuditLogService;
    }

    @Around("@annotation(auditLog)")
    public Object around(ProceedingJoinPoint joinPoint, AuditLog auditLog) throws Throwable {
        SysAuditLog auditLogEntity = new SysAuditLog();
        auditLogEntity.setTraceId(TraceIdUtils.getTraceId());
        auditLogEntity.setOperationType(auditLog.operationType());
        auditLogEntity.setOperationDesc(auditLog.operationDesc());
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (!ObjectUtils.isEmpty(attributes)) {
            HttpServletRequest request = attributes.getRequest();
            auditLogEntity.setRequestUrl(request.getRequestURI());
            auditLogEntity.setRequestMethod(request.getMethod());
            auditLogEntity.setIpAddress(getIpAddress(request));
            Long userId = (Long) request.getAttribute("userId");
            auditLogEntity.setOperatorId(userId);
            String operatorName = (String) request.getAttribute("username");
            auditLogEntity.setOperatorName(operatorName);
        }
        auditLogEntity.setRequestParams(Arrays.toString(joinPoint.getArgs()));
        long startTime = System.currentTimeMillis();
        Object result = null;
        try {
            result = joinPoint.proceed();
            auditLogEntity.setOperationStatus(1);
            if (!ObjectUtils.isEmpty(result)) {
                auditLogEntity.setResponseResult(JSON.toJSONString(result));
            }
        } catch (Throwable e) {
            auditLogEntity.setOperationStatus(0);
            auditLogEntity.setErrorMessage(e.getMessage());
            throw e;
        } finally {
            long endTime = System.currentTimeMillis();
            log.info("操作:{}, 耗时:{}ms", auditLog.operationDesc(), (endTime - startTime));
            sysAuditLogService.saveAuditLog(auditLogEntity);
        }
        return result;
    }

    private String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        if (StringUtils.hasText(ip) && !"unknown".equalsIgnoreCase(ip)) {
            int index = ip.indexOf(',');
            if (index != -1) {
                return ip.substring(0, index).trim();
            }
            return ip.trim();
        }
        ip = request.getHeader("X-Real-IP");
        if (StringUtils.hasText(ip) && !"unknown".equalsIgnoreCase(ip)) {
            return ip.trim();
        }
        return request.getRemoteAddr();
    }
}

3.3.5 数据保密性落地实现

等保2.0要求必须对敏感数据进行存储加密，采用国密SM4算法实现敏感字段的自动加解密，MyBatisPlus类型处理器实现如下：

  1. 国密SM4加密工具类
package com.jam.demo.common.utils;

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;
import org.springframework.util.StringUtils;
import com.jam.demo.common.exception.BusinessException;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.Security;

/**
 * 国密SM4加密工具类
 * @author ken
 */
public class Sm4Utils {

    static {
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    private static final String ALGORITHM_NAME = "SM4";
    private static final String ALGORITHM_NAME_CBC_PADDING = "SM4/CBC/PKCS7Padding";
    private static final int KEY_SIZE = 128;
    private static final byte[] DEFAULT_IV = new byte[16];

    private static final String SM4_KEY = "${SM4_ENCRYPT_KEY}";

    /**
     * SM4 CBC加密
     * @param plainText 明文
     * @return 加密后的十六进制字符串
     */
    public static String encrypt(String plainText) {
        if (!StringUtils.hasText(plainText)) {
            return plainText;
        }
        try {
            Cipher cipher = Cipher.getInstance(ALGORITHM_NAME_CBC_PADDING, BouncyCastleProvider.PROVIDER_NAME);
            SecretKeySpec secretKeySpec = new SecretKeySpec(Hex.decode(SM4_KEY), ALGORITHM_NAME);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(DEFAULT_IV);
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
            byte[] encrypted = cipher.doFinal(plainText.getBytes(StandardCharsets.UTF_8));
            return Hex.toHexString(encrypted);
        } catch (Exception e) {
            throw new BusinessException("SM4加密失败", e);
        }
    }

    /**
     * SM4 CBC解密
     * @param cipherText 加密后的十六进制字符串
     * @return 解密后的明文
     */
    public static String decrypt(String cipherText) {
        if (!StringUtils.hasText(cipherText)) {
            return cipherText;
        }
        try {
            Cipher cipher = Cipher.getInstance(ALGORITHM_NAME_CBC_PADDING, BouncyCastleProvider.PROVIDER_NAME);
            SecretKeySpec secretKeySpec = new SecretKeySpec(Hex.decode(SM4_KEY), ALGORITHM_NAME);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(DEFAULT_IV);
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
            byte[] decrypted = cipher.doFinal(Hex.decode(cipherText));
            return new String(decrypted, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw new BusinessException("SM4解密失败", e);
        }
    }

    /**
     * 生成SM4密钥
     * @return 十六进制格式的密钥
     */
    public static String generateKey() {
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
            keyGenerator.init(KEY_SIZE);
            SecretKey secretKey = keyGenerator.generateKey();
            return Hex.toHexString(secretKey.getEncoded());
        } catch (Exception e) {
            throw new BusinessException("SM4密钥生成失败", e);
        }
    }
}

2. MyBatisPlus敏感字段类型处理器

package com.jam.demo.common.handler;

import com.jam.demo.common.utils.Sm4Utils;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;
import org.springframework.util.StringUtils;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 敏感字段SM4加解密类型处理器
 * @author ken
 */
@MappedTypes(String.class)
@MappedJdbcTypes(JdbcType.VARCHAR)
public class SensitiveFieldTypeHandler extends BaseTypeHandler<String> {

    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
        String encryptedValue = Sm4Utils.encrypt(parameter);
        ps.setString(i, encryptedValue);
    }

    @Override
    public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
        String cipherText = rs.getString(columnName);
        return Sm4Utils.decrypt(cipherText);
    }

    @Override
    public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        String cipherText = rs.getString(columnIndex);
        return Sm4Utils.decrypt(cipherText);
    }

    @Override
    public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        String cipherText = cs.getString(columnIndex);
        return Sm4Utils.decrypt(cipherText);
    }
}

3.4 安全管理中心：统一安全管控体系

安全管理中心是整个等保2.0合规架构的大脑，核心目标是实现对全系统安全策略、安全事件、审计日志、风险状况的统一管控。

3.4.1 合规核心要求

GB/T 22239-2019对安全管理中心的核心要求包括：

  • 必须实现对全系统安全设备与安全策略的统一管理
  • 必须实现对全系统安全事件的统一收集、分析与告警
  • 必须实现对全系统审计数据的集中管理与关联分析
  • 必须实现对全系统安全风险的统一评估与处置

3.4.2 架构设计

安全管理中心架构如下：

3.4.3 落地实现方案

  1. 安全策略统一管理：建立统一的策略管理平台，实现对防火墙规则、WAF规则、访问控制策略、加密策略的统一配置、下发与生命周期管理，避免策略分散导致的合规漏洞。
  2. 安全事件统一监控：采用SIEM系统实现全系统安全日志的统一收集、关联分析，对异常登录、越权访问、SQL注入、暴力破解等安全事件进行实时告警，告警流程如下：

  1. 统一审计分析：建立统一的审计日志中心，实现全链路审计日志的集中存储、查询、分析，审计日志必须采用不可篡改的存储方式，保存时间不少于6个月。
  2. 风险评估与管控：建立定期的风险评估机制，每季度对系统进行全面的安全风险评估，对发现的高风险漏洞必须在72小时内完成整改，中风险漏洞在15个工作日内完成整改。

四、等保2.0合规验证与常见问题整改

4.1 合规自查核心清单

基于GB/T 22239-2019标准，分布式系统等保2.0合规自查核心清单如下：

  1. 安全通信网络：是否实现全链路传输加密、双向身份认证、抗重放保护
  2. 安全区域边界：是否明确划分安全区域、实现最小权限ACL规则、API网关攻击防护、服务间访问控制
  3. 安全计算环境：是否实现强身份鉴别、最小权限访问控制、全量操作审计、敏感数据加密、数据备份恢复
  4. 安全管理中心：是否实现安全策略统一管理、安全事件统一监控、审计日志集中管理、风险统一管控

4.2 常见测评不符合项整改方案

  1. 不符合项：用户密码复杂度不符合要求，未定期更换 整改方案：强制密码复杂度要求（长度不少于8位，包含大小写字母、数字、特殊字符），密码有效期90天，禁止重复使用最近5次的密码
  2. 不符合项：审计日志保存时间不足6个月 整改方案：建立审计日志集中存储平台，采用不可篡改的存储方式，日志保存时间设置为180天以上
  3. 不符合项：敏感数据明文存储 整改方案：采用国密SM4算法对身份证号、手机号、银行卡号等敏感数据进行存储加密，实现敏感字段的自动加解密
  4. 不符合项：未实现通信过程中的双向身份认证 整改方案：外网接入采用TLS 1.3双向认证，服务间通信采用mTLS双向认证，数据库连接强制SSL加密
  5. 不符合项：访问控制粒度不足，未实现最小权限 整改方案：采用RBAC模型实现功能权限的精准管控，数据权限实现行级管控，数据库账号仅授予业务必需的最小权限

五、项目核心依赖配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.4</version>
        <relativePath/>
    </parent>
    <groupId>com.jam</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>jam-demo</name>
    <description>等保2.0合规分布式系统Demo</description>
    <properties>
        <java.version>17</java.version>
        <mybatis-plus.version>3.5.7</mybatis-plus.version>
        <fastjson2.version>2.0.52</fastjson2.version>
        <bouncycastle.version>1.78.1</bouncycastle.version>
        <springdoc.version>2.6.0</springdoc.version>
        <guava.version>33.1.0-jre</guava.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
            <version>4.1.3</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>8.0.40</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>${fastjson2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk18on</artifactId>
            <version>${bouncycastle.version}</version>
        </dependency>
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcpkix-jdk18on</artifactId>
            <version>${bouncycastle.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>${springdoc.version}</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.30</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

结尾

等保2.0合规不是一次性的测评工作，而是持续的安全建设过程。分布式系统的等保合规落地，必须摒弃“为了过审而合规”的错误理念，基于“一个中心、三重防护”的纵深防御体系，将安全能力嵌入到分布式架构的全生命周期中，构建既符合国家合规要求、又具备实际防护能力的安全架构，真正实现业务与安全的协同发展。

avatar
文章
阅读
粉丝