硬核實(shí)戰(zhàn)！分布式系統(tǒng)接口安全三板斧：限流、防重放、簽名驗(yàn)證全攻略

作者：路條編程 2025-09-15 07:42:58

限流的目的在于防止資源被過(guò)度消耗，從而避免?DoS/DDoS?攻擊和瞬時(shí)高并發(fā)帶來(lái)的雪崩效應(yīng)。對(duì)于分布式架構(gòu)來(lái)說(shuō)，限流不僅要在?網(wǎng)關(guān)層?生效，還需要深入到?各微服務(wù)節(jié)點(diǎn)，形成多層級(jí)的保護(hù)體系。

在更廣泛的分布式系統(tǒng)場(chǎng)景中，單一的防護(hù)措施遠(yuǎn)遠(yuǎn)不夠。系統(tǒng)需要面對(duì)復(fù)雜的攻擊手法，例如大規(guī)模惡意請(qǐng)求、請(qǐng)求重放以及參數(shù)篡改等。本文將聚焦于通用接口的三大安全防護(hù)手段，并結(jié)合工程實(shí)踐給出詳細(xì)實(shí)現(xiàn)方案：

限流機(jī)制：抵御突發(fā)流量與惡意刷接口，保證系統(tǒng)穩(wěn)定性
防重放策略：避免重復(fù)請(qǐng)求造成業(yè)務(wù)風(fēng)險(xiǎn)
簽名校驗(yàn)：防止請(qǐng)求數(shù)據(jù)被惡意篡改

通過(guò)這一系列措施，分布式系統(tǒng)不僅能在高并發(fā)場(chǎng)景下保持服務(wù)可用，還能有效阻斷潛在的攻擊通道。

限流機(jī)制：系統(tǒng)穩(wěn)定性的第一道防線

限流的核心目標(biāo)

限流的目的在于防止資源被過(guò)度消耗，從而避免 DoS/DDoS 攻擊和瞬時(shí)高并發(fā)帶來(lái)的雪崩效應(yīng)。對(duì)于分布式架構(gòu)來(lái)說(shuō)，限流不僅要在 網(wǎng)關(guān)層 生效，還需要深入到 各微服務(wù)節(jié)點(diǎn)，形成多層級(jí)的保護(hù)體系。

常見(jiàn)的限流算法

在工程實(shí)踐中，通常會(huì)使用以下幾種限流算法：

算法	核心機(jī)制	優(yōu)點(diǎn)	缺點(diǎn)	適用場(chǎng)景
固定窗口	固定時(shí)間段內(nèi)計(jì)數(shù)	實(shí)現(xiàn)簡(jiǎn)單，高效	臨界點(diǎn)突刺問(wèn)題	非關(guān)鍵接口
滑動(dòng)窗口	滑動(dòng)區(qū)間內(nèi)實(shí)時(shí)統(tǒng)計(jì)	精度高，平滑臨界	實(shí)現(xiàn)稍復(fù)雜	API 網(wǎng)關(guān)、分布式限流
漏桶算法	恒定速率處理請(qǐng)求	流量絕對(duì)平滑	無(wú)法應(yīng)對(duì)突發(fā)流量	流量整形、數(shù)據(jù)庫(kù)保護(hù)
令牌桶算法	令牌發(fā)放 + 消耗機(jī)制	支持突發(fā)，靈活性高	實(shí)現(xiàn)復(fù)雜	微服務(wù)、方法級(jí)限流

在本文的實(shí)現(xiàn)方案中，我們采用 Redis + 滑動(dòng)窗口，以滿(mǎn)足分布式環(huán)境下的多節(jié)點(diǎn)限流需求。

Redis 滑動(dòng)窗口限流實(shí)現(xiàn)

Redis 的 有序集合（ZSet） 特性使其非常適合實(shí)現(xiàn)滑動(dòng)窗口算法。核心流程如下：

請(qǐng)求到達(dá)時(shí)，計(jì)算窗口起始時(shí)間 T - W。
使用 ZREMRANGEBYSCORE 移除過(guò)期時(shí)間戳。
使用 ZCOUNT 統(tǒng)計(jì)當(dāng)前窗口內(nèi)的請(qǐng)求數(shù)量。
若超出閾值，拒絕請(qǐng)求；否則寫(xiě)入當(dāng)前時(shí)間戳。
使用 Lua 腳本封裝，保證原子性。

對(duì)應(yīng)實(shí)現(xiàn)如下：

package com.icoderoad.security.limiter;


import java.util.LinkedList;
import java.util.Queue;


public class SlidingWindowRateLimiter {
    private final int limit; // 限流閾值
    private final long windowSize; // 滑動(dòng)窗口大小
    private final Queue<Long> requestTimestamps;


    public SlidingWindowRateLimiter(int limit, long windowSize) {
        this.limit = limit;
        this.windowSize = windowSize;
        this.requestTimestamps = new LinkedList<>();
    }


    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        while (!requestTimestamps.isEmpty() && now - requestTimestamps.peek() > windowSize) {
            requestTimestamps.poll();
        }
        if (requestTimestamps.size() < limit) {
            requestTimestamps.offer(now);
            return true;
        }
        return false;
    }
}

網(wǎng)關(guān)層限流

在 API 網(wǎng)關(guān)層 進(jìn)行全局流量控制，可有效抵御惡意流量對(duì)下游服務(wù)的沖擊。例如設(shè)置全局 QPS = 100,000，作為兜底防護(hù)。

// 路徑：/src/main/java/com/icoderoad/gateway/filter/GlobalRateLimitFilter.java
package com.icoderoad.gateway.filter;


import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;


import java.util.LinkedList;
import java.util.Queue;


/**
 * 全局限流過(guò)濾器（基于滑動(dòng)窗口）
 * 控制 API 網(wǎng)關(guān)層整體流量，避免惡意請(qǐng)求沖擊下游服務(wù)
 */
@Component
public class GlobalRateLimitFilter implements GlobalFilter, Ordered {


    // 每秒最大請(qǐng)求數(shù)（例如全局 QPS = 100,000）
    private static final int LIMIT = 100000;


    // 窗口大小（毫秒）
    private static final long WINDOW_SIZE = 1000;


    // 請(qǐng)求時(shí)間戳隊(duì)列
    private final Queue<Long> requestTimestamps = new LinkedList<>();


    /**
     * 滑動(dòng)窗口限流核心邏輯
     */
    private synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();


        // 移除過(guò)期的請(qǐng)求時(shí)間
        while (!requestTimestamps.isEmpty() && now - requestTimestamps.peek() > WINDOW_SIZE) {
            requestTimestamps.poll();
        }


        if (requestTimestamps.size() < LIMIT) {
            requestTimestamps.offer(now);
            return true;
        }
        return false;
    }


    @Override
    public Mono<Void> filter(ServerWebExchange exchange, org.springframework.cloud.gateway.filter.GatewayFilterChain chain) {
        if (!tryAcquire()) {
            // 超過(guò)限流閾值，返回 429
            exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
            return exchange.getResponse().setComplete();
        }
        // 放行
        return chain.filter(exchange);
    }


    @Override
    public int getOrder() {
        // 優(yōu)先級(jí)最高，先執(zhí)行限流判斷
        return -1;
    }
}

IP 限流

對(duì)攻擊者常用的 撞庫(kù)、短信轟炸 等行為，可以通過(guò) 單 IP 限制請(qǐng)求頻率 來(lái)攔截。若單 IP 在固定周期內(nèi)多次觸發(fā)限流規(guī)則，可直接拉黑。

// 路徑：/src/main/java/com/icoderoad/gateway/filter/IpRateLimitFilter.java
package com.icoderoad.gateway.filter;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;


import java.util.concurrent.TimeUnit;


/**
 * IP 限流過(guò)濾器（基于 Redis + 黑名單）
 * 攔截異常頻繁的請(qǐng)求，例如撞庫(kù)、短信轟炸
 */
@Component
public class IpRateLimitFilter implements GlobalFilter, Ordered {


    @Autowired
    private RedisTemplate<String, String> redisTemplate;


    // 配置參數(shù)
    private static final int LIMIT = 50;              // 單 IP 在周期內(nèi)最大請(qǐng)求數(shù)
    private static final long PERIOD = 60;            // 限流統(tǒng)計(jì)周期（秒）
    private static final int BLACKLIST_THRESHOLD = 5; // 觸發(fā)限流多少次后拉黑
    private static final long BLACKLIST_TIME = 3600;  // 黑名單時(shí)長(zhǎng)（秒）


    @Override
    public Mono<Void> filter(ServerWebExchange exchange, org.springframework.cloud.gateway.filter.GatewayFilterChain chain) {
        String ip = getClientIp(exchange);


        String blacklistKey = "ip:blacklist:" + ip;
        // 檢查是否在黑名單
        if (Boolean.TRUE.equals(redisTemplate.hasKey(blacklistKey))) {
            exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
            return exchange.getResponse().setComplete();
        }


        String counterKey = "ip:counter:" + ip;
        Long count = redisTemplate.opsForValue().increment(counterKey);
        if (count == 1) {
            // 設(shè)置過(guò)期時(shí)間
            redisTemplate.expire(counterKey, PERIOD, TimeUnit.SECONDS);
        }


        if (count != null && count > LIMIT) {
            // 記錄觸發(fā)次數(shù)
            String triggerKey = "ip:trigger:" + ip;
            Long triggerCount = redisTemplate.opsForValue().increment(triggerKey);
            if (triggerCount == 1) {
                redisTemplate.expire(triggerKey, BLACKLIST_TIME, TimeUnit.SECONDS);
            }


            // 如果觸發(fā)次數(shù)超過(guò)閾值，拉黑
            if (triggerCount != null && triggerCount >= BLACKLIST_THRESHOLD) {
                redisTemplate.opsForValue().set(blacklistKey, "1", BLACKLIST_TIME, TimeUnit.SECONDS);
            }


            exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
            return exchange.getResponse().setComplete();
        }


        return chain.filter(exchange);
    }


    /**
     * 獲取客戶(hù)端真實(shí) IP
     */
    private String getClientIp(ServerWebExchange exchange) {
        String ip = exchange.getRequest().getHeaders().getFirst("X-Forwarded-For");
        if (ip == null || ip.isEmpty()) {
            ip = exchange.getRequest().getRemoteAddress() != null ?
                    exchange.getRequest().getRemoteAddress().getAddress().getHostAddress() : "unknown";
        } else {
            // 取第一個(gè) IP
            ip = ip.split(",")[0];
        }
        return ip;
    }


    @Override
    public int getOrder() {
        // 高優(yōu)先級(jí)執(zhí)行，避免攻擊流量進(jìn)入業(yè)務(wù)邏輯
        return -2;
    }
}

微服務(wù)層限流

服務(wù)級(jí)別的限流側(cè)重 自治能力，例如對(duì)某個(gè)接口設(shè)置 QPS = 200，以避免單服務(wù)過(guò)載影響全局。

// 路徑：/src/main/java/com/icoderoad/service/filter/ResourceLimiterFilter.java
package com.icoderoad.service.filter;


import com.alibaba.nacos.api.config.annotation.NacosValue;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;


import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


/**
 * 微服務(wù)級(jí)別的接口限流過(guò)濾器
 * 支持從 Nacos 動(dòng)態(tài)加載配置，實(shí)現(xiàn)服務(wù)自治
 */
@Component
public class ResourceLimiterFilter extends OncePerRequestFilter {


    // Nacos 動(dòng)態(tài)配置：例如 {"api:/order/create":200,"api:/user/login":100}
    @NacosValue(value = "${service.limiter.config:{}}", autoRefreshed = true)
    private String limiterConfig;


    // 保存各接口的限流器
    private final Map<String, SimpleRateLimiter> limiters = new ConcurrentHashMap<>();


    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String uri = request.getRequestURI();
        int qpsLimit = getLimit(uri);


        if (qpsLimit > 0) {
            SimpleRateLimiter limiter = limiters.computeIfAbsent(uri, k -> new SimpleRateLimiter(qpsLimit));
            if (!limiter.tryAcquire()) {
                response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
                response.getWriter().write("Too Many Requests for API: " + uri);
                return;
            }
        }


        filterChain.doFilter(request, response);
    }


    /**
     * 根據(jù) URI 獲取限流閾值（從 Nacos 動(dòng)態(tài)配置加載）
     */
    private int getLimit(String uri) {
        try {
            // 假設(shè)配置格式是 JSON：{"api:/order/create":200,"api:/user/login":100}
            Map<String, Object> configMap = new com.fasterxml.jackson.databind.ObjectMapper()
                    .readValue(limiterConfig, Map.class);
            Object limit = configMap.get("api:" + uri);
            return limit != null ? Integer.parseInt(limit.toString()) : 0;
        } catch (Exception e) {
            return 0;
        }
    }


    /**
     * 簡(jiǎn)單的滑動(dòng)窗口限流器（服務(wù)級(jí)別）
     */
    static class SimpleRateLimiter {
        private final int limit;
        private final long windowSize = 1000L; // 1秒
        private long windowStart = System.currentTimeMillis();
        private int count = 0;


        public SimpleRateLimiter(int limit) {
            this.limit = limit;
        }


        public synchronized boolean tryAcquire() {
            long now = System.currentTimeMillis();
            if (now - windowStart > windowSize) {
                windowStart = now;
                count = 0;
            }
            if (count < limit) {
                count++;
                return true;
            }
            return false;
        }
    }
}

防重放機(jī)制：阻斷重復(fù)提交的風(fēng)險(xiǎn)

重放攻擊的典型手法是 攔截合法請(qǐng)求并重復(fù)發(fā)送，例如重復(fù)支付、重復(fù)下單。防護(hù)策略常用 Nonce + Timestamp，確保請(qǐng)求 唯一且有時(shí)效性。

Nonce（隨機(jī)數(shù)）：保證請(qǐng)求唯一。
Timestamp（時(shí)間戳）：限制請(qǐng)求有效期，例如 5 分鐘內(nèi)有效。
RequestId（唯一標(biāo)識(shí)）：防止同一請(qǐng)求多次提交。

簽名校驗(yàn)：確保請(qǐng)求未被篡改

簽名驗(yàn)證的核心思路是：請(qǐng)求參數(shù) + 隨機(jī)數(shù) + 請(qǐng)求方法 + 加密算法 生成簽名，服務(wù)端對(duì)其進(jìn)行解密和比對(duì)，保證數(shù)據(jù)完整性。

簽名生成流程

生成隨機(jī)數(shù) requestId
使用公鑰加密生成 idSign
隨機(jī)抽取部分字符作為 idSecretIndex
拼接 URL / 方法 / requestId 等數(shù)據(jù)，使用對(duì)稱(chēng)密鑰生成 signature
客戶(hù)端請(qǐng)求時(shí)在 Header 攜帶：

X-Request-ID: idSign
X-Request-Index: idSecretIndex
X-Signature: signature

前端簽名工具（Vue + Axios 示例）

// 路徑：/src/frontend/utils/signature.js
import CryptoJS from 'crypto-js'
import JSEncrypt from 'jsencrypt'


export function generateSignature(url, method, requestId, secretKey) {
  const signContent = [`url=${url}`, `method=${method}`, `requestId=${requestId}`].join('&')
  return CryptoJS.HmacSHA256(signContent, secretKey).toString(CryptoJS.enc.Hex)
}


export function encryptRequestId(requestId, publicKey) {
  const encryptor = new JSEncrypt()
  encryptor.setPublicKey(publicKey)
  return encryptor.encrypt(requestId)
}