下面是一个模拟的Java安全防护系统，展示如何在Java应用程序中检测和应对不同类型攻击。

import java.util.*;
import java.util.concurrent.*;
import java.util.logging.*;

public class SecurityDefenseSystem {
    private static final Logger logger = Logger.getLogger(SecurityDefenseSystem.class.getName());
    
    // 系统状态
    private enum SystemStatus { NORMAL, UNDER_ATTACK, LOCKDOWN }
    private SystemStatus currentStatus = SystemStatus.NORMAL;
    
    // 攻击检测器
    private final Map<String, Integer> ipRequestCount = new ConcurrentHashMap<>();
    private final Map<String, Long> ipBlockList = new ConcurrentHashMap<>();
    private final Set<String> knownAttackPatterns = new HashSet<>();
    
    // 防御资源
    private final ExecutorService defenseExecutor = Executors.newFixedThreadPool(5);
    private final ScheduledExecutorService monitoringService = Executors.newScheduledThreadPool(1);
    
    // 系统配置
    private static final int MAX_REQUESTS_PER_MINUTE = 100;
    private static final long BLOCK_DURATION_MINUTES = 30;
    private static final long MONITORING_INTERVAL_SECONDS = 5;

    public SecurityDefenseSystem() {
        initializeKnownAttackPatterns();
        startMonitoringService();
    }
    
    private void initializeKnownAttackPatterns() {
        // 添加已知的攻击模式（实际应用中会从安全数据库加载）
        knownAttackPatterns.add("SELECT * FROM users");
        knownAttackPatterns.add("DROP TABLE");
        knownAttackPatterns.add("<script>alert");
        knownAttackPatterns.add("../../etc/passwd");
        knownAttackPatterns.add("UNION SELECT");
        knownAttackPatterns.add("; DROP");
        knownAttackPatterns.add("<?php system");
    }
    
    private void startMonitoringService() {
        monitoringService.scheduleAtFixedRate(() -> {
            if (currentStatus == SystemStatus.UNDER_ATTACK) {
                logger.warning("⚠️ 系统当前处于攻击状态！正在增强防御...");
                activateEnhancedDefenses();
            }
            cleanExpiredBlocks();
        }, 0, MONITORING_INTERVAL_SECONDS, TimeUnit.SECONDS);
    }
    
    public void processRequest(String ipAddress, String requestData) {
        if (isBlocked(ipAddress)) {
            logger.warning("🚫 拦截来自黑名单IP的请求: " + ipAddress);
            counterMeasure("IP_BLOCK", ipAddress, "自动拦截");
            return;
        }
        
        // 检查请求频率
        trackRequestFrequency(ipAddress);
        
        // 分析请求内容
        analyzeRequestContent(ipAddress, requestData);
    }
    
    private void trackRequestFrequency(String ipAddress) {
        ipRequestCount.merge(ipAddress, 1, Integer::sum);
        
        // 检查是否超出阈值
        if (ipRequestCount.get(ipAddress) > MAX_REQUESTS_PER_MINUTE) {
            logger.severe("🚨 检测到洪水攻击来自: " + ipAddress);
            blockIpAddress(ipAddress, "洪水攻击");
            counterMeasure("FLOOD_ATTACK", ipAddress, "IP封锁");
            currentStatus = SystemStatus.UNDER_ATTACK;
        }
    }
    
    private void analyzeRequestContent(String ipAddress, String requestData) {
        // 检查已知攻击模式
        for (String pattern : knownAttackPatterns) {
            if (requestData.contains(pattern)) {
                logger.severe("🚨 检测到恶意请求模式: " + pattern + " 来自: " + ipAddress);
                blockIpAddress(ipAddress, "恶意模式: " + pattern);
                counterMeasure("MALICIOUS_PATTERN", ipAddress, "模式拦截");
                currentStatus = SystemStatus.UNDER_ATTACK;
                return;
            }
        }
        
        // 检查异常行为
        if (detectAnomalousBehavior(requestData)) {
            logger.severe("🚨 检测到异常行为来自: " + ipAddress);
            blockIpAddress(ipAddress, "异常行为");
            counterMeasure("ANOMALOUS_BEHAVIOR", ipAddress, "行为分析拦截");
            currentStatus = SystemStatus.UNDER_ATTACK;
        }
    }
    
    private boolean detectAnomalousBehavior(String requestData) {
        // 这里可以添加更复杂的行为分析算法
        // 例如: 检查请求大小、参数结构、访问路径等
        return requestData.length() > 5000 || 
               requestData.contains("/../") || 
               requestData.matches(".*[|;&`].*");
    }
    
    private void blockIpAddress(String ipAddress, String reason) {
        ipBlockList.put(ipAddress, System.currentTimeMillis());
        logger.warning("🔒 已封锁IP地址: " + ipAddress + " 原因: " + reason);
    }
    
    private boolean isBlocked(String ipAddress) {
        return ipBlockList.containsKey(ipAddress);
    }
    
    private void cleanExpiredBlocks() {
        long currentTime = System.currentTimeMillis();
        Iterator<Map.Entry<String, Long>> iterator = ipBlockList.entrySet().iterator();
        
        while (iterator.hasNext()) {
            Map.Entry<String, Long> entry = iterator.next();
            long blockTime = entry.getValue();
            long minutesBlocked = (currentTime - blockTime) / (60 * 1000);
            
            if (minutesBlocked > BLOCK_DURATION_MINUTES) {
                iterator.remove();
                logger.info("🔓 已解除IP封锁: " + entry.getKey());
            }
        }
    }
    
    private void counterMeasure(String attackType, String source, String action) {
        defenseExecutor.submit(() -> {
            logger.info("🛡️ 正在执行防御措施: " + action + " 针对 " + attackType + " 来自 " + source);
            
            // 根据攻击类型采取不同防御策略
            switch (attackType) {
                case "FLOOD_ATTACK":
                    deployTrafficShaping(source);
                    break;
                case "MALICIOUS_PATTERN":
                    deployHoneypot(source);
                    break;
                case "ANOMALOUS_BEHAVIOR":
                    collectForensicData(source);
                    break;
                case "IP_BLOCK":
                    // 已自动处理
                    break;
            }
            
            // 高级防御: 攻击者溯源
            if (currentStatus == SystemStatus.UNDER_ATTACK) {
                traceAttackSource(source);
            }
        });
    }
    
    private void deployTrafficShaping(String source) {
        // 实现流量整形 - 限制来自特定源的请求速率
        logger.info("🌊 对 " + source + " 实施流量整形策略");
        // 实际实现会使用网络层控制
    }
    
    private void deployHoneypot(String source) {
        // 部署蜜罐系统 - 引导攻击者进入隔离环境
        logger.info("🍯 为 " + source + " 部署蜜罐系统");
        // 实际实现会创建虚假资源
    }
    
    private void collectForensicData(String source) {
        // 收集攻击证据用于法律追究
        logger.info("🔍 收集来自 " + source + " 的攻击取证数据");
        // 实际实现会记录详细日志和网络数据包
    }
    
    private void traceAttackSource(String source) {
        // 尝试追踪攻击源头的真实位置
        logger.info("🕵️ 正在追踪 " + source + " 的真实来源");
        
        // 模拟溯源过程
        try {
            Thread.sleep(2000);
            logger.info("📍 追踪结果: " + source + " 可能来自 AS" + (new Random().nextInt(9000) + 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    private void activateEnhancedDefenses() {
        // 激活增强防御措施
        logger.info("🚀 激活增强型防御系统");
        
        // 1. 启用WAF(Web应用防火墙)规则
        logger.info("🔥 启用高级WAF规则");
        
        // 2. 启动DDoS缓解系统
        logger.info("🌀 启动DDoS防护机制");
        
        // 3. 加强身份验证
        logger.info("🔑 启用多因素身份验证");
        
        // 4. 隔离关键系统
        logger.info("🚧 隔离关键系统组件");
    }
    
    public void lockdownSystem() {
        currentStatus = SystemStatus.LOCKDOWN;
        logger.severe("🔐🔐🔐 系统进入完全锁定状态！");
        
        // 1. 关闭非必要服务
        logger.info("⛔ 关闭非必要服务");
        
        // 2. 启用只读模式
        logger.info("📖 启用系统只读模式");
        
        // 3. 通知安全团队
        logger.info("📢 通知安全响应团队");
    }
    
    public void shutdown() {
        defenseExecutor.shutdown();
        monitoringService.shutdown();
        try {
            if (!defenseExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                defenseExecutor.shutdownNow();
            }
            if (!monitoringService.awaitTermination(5, TimeUnit.SECONDS)) {
                monitoringService.shutdownNow();
            }
        } catch (InterruptedException e) {
            defenseExecutor.shutdownNow();
            monitoringService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
    
    // 模拟攻击生成器
    public static void main(String[] args) throws InterruptedException {
        SecurityDefenseSystem defenseSystem = new SecurityDefenseSystem();
        
        // 模拟正常流量
        for (int i = 0; i < 20; i++) {
            defenseSystem.processRequest("192.168.1." + i, "正常请求数据");
            Thread.sleep(100);
        }
        
        // 模拟洪水攻击
        new Thread(() -> {
            for (int i = 0; i < 500; i++) {
                defenseSystem.processRequest("10.0.0.99", "洪水攻击请求#" + i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();
        
        // 模拟SQL注入攻击
        new Thread(() -> {
            String[] sqlInjections = {
                "SELECT * FROM users",
                "DROP TABLE users",
                "UNION SELECT password FROM users"
            };
            
            for (int i = 0; i < 50; i++) {
                String attack = sqlInjections[new Random().nextInt(sqlInjections.length)];
                defenseSystem.processRequest("172.16.0.55", "恶意请求: " + attack);
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();
        
        // 模拟路径遍历攻击
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                defenseSystem.processRequest("192.168.56.101", "请求文件: ../../etc/passwd");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();
        
        // 运行一段时间后关闭系统
        Thread.sleep(120000);
        defenseSystem.shutdown();
    }
}

如何增强Java应用安全性

除了上述系统，实际应用中还应考虑：

1.安全编码实践：

• 使用预编译语句防止 SQL注入
• 对用户输入进行严格验证和消毒
• 实施最小权限原则

2. 运行时保护：

• 启用Java安全管理器
• 使用字节码加固技术
• 定期更新 JRE/JDK

3. 网络安全：

• 配置 HTTPS和TLS
• 使用Web应用防火墙（WAF）
• 实施网络分段隔离

4. 监控与审计：

• 实现全面的日志记录
• 设置安全信息和事件管理（SIEM）
• 定期进行安全审计

5. 应急响应：

• 制定安全事件响应计划
• 建立备份和恢复机制