接口添加白名单 IP 地址的作用与价值

┌─────────────────────────────────────────────────────────┐
│                    API 网关层                            │
│  ┌─────────────┐    ┌─────────────┐                   │
│  │  请求来源    │    │  白名单校验  │                   │
│  │ 192.168.1.5 │ →  │  ✓ 在名单中  │ → 放行请求        │
│  └─────────────┘    └─────────────┘                   │
│                                                      │
│  ┌─────────────┐    ┌─────────────┐                   │
│  │  请求来源    │    │  白名单校验  │                   │
│  │  10.20.30.40 │ →  │  ✗ 不在名单  │ → 返回 403        │
│  └─────────────┘    └─────────────┘                   │
└─────────────────────────────────────────────────────────┘

无白名单：恶意请求 → 进入应用层 → 鉴权校验 → 业务处理 → 返回错误（消耗大量资源）
有白名单：恶意请求 → 网关拦截 → 直接返回 403（几乎零消耗）

import org.springframework.stereotype.Component;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
/**
 * IP 白名单过滤器
 * 拦截所有请求，仅允许白名单中的 IP 访问
 */
@Component
public class IpWhitelistFilter implements Filter {
    
    // 白名单 IP 集合（生产环境建议从配置中心或数据库读取）
    private static final Set<String> WHITELIST = new HashSet<>(Arrays.asList(
        "192.168.1.100",      // 应用服务器 A
        "192.168.1.101",      // 应用服务器 B
        "10.0.0.50",          // 办公网络网关
        "203.0.113.10"        // 合作伙伴服务器
    ));
    
    // 支持 CIDR 网段（如 192.168.1.0/24）
    private static final Set<String> WHITELIST_CIDRS = new HashSet<>(Arrays.asList(
        "192.168.10.0/24",
        "10.0.0.0/8"
    ));
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        
        // 获取客户端真实 IP（考虑反向代理场景）
        String clientIp = getClientIp(httpRequest);
        
        // 校验 IP 是否在白名单中
        if (!isIpAllowed(clientIp)) {
            httpResponse.setStatus(HttpServletResponse.SC_FORBIDDEN);
            httpResponse.setContentType("application/json;charset=UTF-8");
            httpResponse.getWriter().write(
                "{\"code\":403,\"message\":\"IP不在白名单中: " + clientIp + "\"}"
            );
            return;
        }
        
        // IP 校验通过，继续后续处理
        chain.doFilter(request, response);
    }
    
    /**
     * 获取客户端真实 IP（处理 X-Forwarded-For 等代理头）
     */
    private String getClientIp(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        // 多个 IP 取第一个
        if (ip != null && ip.contains(",")) {
            ip = ip.split(",")[0].trim();
        }
        return ip;
    }
    
    /**
     * 判断 IP 是否在白名单中
     */
    private boolean isIpAllowed(String ip) {
        // 精确匹配
        if (WHITELIST.contains(ip)) {
            return true;
        }
        // CIDR 网段匹配
        for (String cidr : WHITELIST_CIDRS) {
            if (isIpInCidr(ip, cidr)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 判断 IP 是否在 CIDR 网段内
     */
    private boolean isIpInCidr(String ip, String cidr) {
        try {
            String[] parts = cidr.split("/");
            String network = parts[0];
            int prefixLength = Integer.parseInt(parts[1]);
            
            byte[] ipBytes = ipToBytes(ip);
            byte[] networkBytes = ipToBytes(network);
            
            int mask = 0xFFFFFFFF << (32 - prefixLength);
            int ipInt = bytesToInt(ipBytes);
            int networkInt = bytesToInt(networkBytes);
            
            return (ipInt & mask) == (networkInt & mask);
        } catch (Exception e) {
            return false;
        }
    }
    
    private byte[] ipToBytes(String ip) {
        String[] parts = ip.split("\\.");
        byte[] bytes = new byte[4];
        for (int i = 0; i < 4; i++) {
            bytes[i] = (byte) Integer.parseInt(parts[i]);
        }
        return bytes;
    }
    
    private int bytesToInt(byte[] bytes) {
        return ((bytes[0] & 0xFF) << 24) | 
               ((bytes[1] & 0xFF) << 16) | 
               ((bytes[2] & 0xFF) << 8) | 
               (bytes[3] & 0xFF);
    }
}

# 仅允许指定 IP 访问 /api/admin 路径
location /api/admin {
    allow 192.168.1.0/24;
    allow 10.0.0.50;
    deny all;
    
    proxy_pass http://backend;
}

┌─────────────────────────────────────────┐
│  第一层：网络层防火墙（云安全组）          │
│  → 限制端口开放范围                       │
├─────────────────────────────────────────┤
│  第二层：API 网关 IP 白名单               │
│  → 限制接口调用来源                       │
├─────────────────────────────────────────┤
│  第三层：应用层认证（OAuth2/JWT/签名）     │
│  → 验证调用者身份                         │
├─────────────────────────────────────────┤
│  第四层：接口限流与熔断                   │
│  → 防止合法用户的异常高频调用              │
├─────────────────────────────────────────┤
│  第五层：数据加密与审计日志                │
│  → 保护传输与存储安全，记录操作痕迹        │
└─────────────────────────────────────────┘