linux netstat命令 (network statistics)

# 1. 查看所有连接
netstat -a
# 输出示例：
# Active Internet connections (servers and established)
# Proto Recv-Q Send-Q Local Address           Foreign Address         State
# tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
# tcp        0      0 192.168.1.100:22        192.168.1.50:54321      ESTABLISHED
# tcp6       0      0 :::80                   :::*                    LISTEN
# udp        0      0 0.0.0.0:68              0.0.0.0:*
# Active UNIX domain sockets (servers and established)
# Proto RefCnt Flags       Type       State         I-Node   Path
# unix  2      [ ACC ]     STREAM     LISTENING     12345    /run/systemd/private

# 2. 查看TCP连接
netstat -t
# 或
netstat --tcp
# 只显示TCP连接

# 3. 查看UDP连接
netstat -u
# 或
netstat --udp
# 只显示UDP连接

# 4. 查看监听端口
netstat -l
# 或
netstat --listening
# 显示所有监听端口

# 5. 查看TCP监听端口
netstat -lt
# 显示TCP监听端口

# 6. 查看UDP监听端口
netstat -lu
# 显示UDP监听端口

# 7. 显示数字格式（不解析主机名和端口名）
netstat -n
# 显示IP地址和端口号，而不是主机名和服务名

# 8. 显示进程信息
netstat -p
# 或
netstat --program
# 显示使用每个连接的进程ID和程序名
# 需要root权限查看其他用户的进程

# 9. 显示进程信息和数字格式
netstat -tunp
# 常用组合：显示TCP/UDP连接，数字格式，进程信息
# 注意：需要root权限

# 10. 查看所有TCP连接（包含监听）
netstat -at
# 所有TCP连接

# 11. 查看所有UDP连接
netstat -au
# 所有UDP连接

# 12. 查看所有监听端口（数字格式）
netstat -ln
# 显示监听端口，数字格式

# 13. 查看所有监听TCP端口（数字格式+进程）
sudo netstat -ltnp
# 需要sudo权限查看进程信息

# 14. 查看所有监听UDP端口（数字格式+进程）
sudo netstat -lunp

# 15. 查看UNIX域套接字
netstat -x
# 或
netstat --unix
# 显示UNIX域套接字连接

# 16. 查看RAW套接字
netstat --raw
# 显示RAW套接字连接

# 17. 查看IPv4连接
netstat --inet
# 只显示IPv4连接

# 18. 查看IPv6连接
netstat --inet6
# 只显示IPv6连接

# 19. 显示扩展信息
netstat -e
# 或
netstat --extend
# 显示扩展信息，如用户ID等

# 20. 持续监控
netstat -c
# 或
netstat --continuous
# 每1秒刷新一次显示

# 21. 不截断IP地址
netstat -W
# 或
netstat --wide
# 显示完整的IP地址，不截断

# 22. 显示计时器信息
netstat -o
# 或
netstat --timers
# 显示TCP连接计时器信息

# 23. 查看路由表
netstat -r
# 或
netstat --route
# 显示内核路由表
# 等价于：route -n

# 24. 查看接口统计
netstat -i
# 或
netstat --interfaces
# 显示网络接口统计信息
# 等价于：ifconfig

# 25. 查看协议统计
netstat -s
# 或
netstat --statistics
# 显示协议统计信息（TCP, UDP, ICMP等）

# 26. 查看多播组成员
netstat -g
# 或
netstat --groups
# 显示多播组成员

# 27. 查看伪装连接
netstat -M
# 或
netstat --masquerade
# 显示伪装连接（NAT）

# 28. 查看转发信息库
netstat -F
# 或
netstat --fib
# 显示转发信息库

# 29. 查看路由缓存
netstat -C
# 或
netstat --cache
# 显示路由缓存

# 30. 组合使用示例
# 查看所有TCP连接，数字格式，进程信息，持续监控
sudo netstat -atnp -c
# 查看所有监听端口，数字格式，进程信息
sudo netstat -ltnup
# 查看路由表和接口统计
netstat -ri

#!/bin/bash
# 网络故障排查和监控脚本

# 1. 检查端口占用
check_port_usage() {
    local port=$1

    echo "检查端口 $port 占用情况..."

    # 使用netstat检查
    sudo netstat -tulnp | grep ":$port"

    # 使用lsof检查
    if command -v lsof &> /dev/null; then
        echo "使用lsof检查:"
        sudo lsof -i :$port
    fi

    # 使用fuser检查
    if command -v fuser &> /dev/null; then
        echo "使用fuser检查:"
        sudo fuser $port/tcp
    fi
}

# 2. 检查特定进程的网络连接
check_process_connections() {
    local process_name=$1

    echo "检查进程 '$process_name' 的网络连接..."

    # 获取进程ID
    pids=$(pgrep "$process_name")

    if [ -z "$pids" ]; then
        echo "未找到进程: $process_name"
        return
    fi

    for pid in $pids; do
        echo "进程 $pid 的网络连接:"
        sudo netstat -tunp | grep " $pid/"
    done
}

# 3. 监控网络连接状态
monitor_connections() {
    local interval=${1:-5}  # 默认5秒间隔

    echo "网络连接监控开始 (间隔: ${interval}秒)"
    echo "按 Ctrl+C 停止"
    echo ""

    while true; do
        clear
        echo "=== 网络连接监控 - $(date) ==="
        echo ""

        # 显示总连接数
        total_conn=$(netstat -an | wc -l)
        echo "总连接数: $total_conn"

        # 按状态统计TCP连接
        echo ""
        echo "TCP连接状态统计:"
        netstat -ant | awk '/^tcp/ {print $6}' | sort | uniq -c | sort -rn

        # 显示监听端口
        echo ""
        echo "监听端口:"
        netstat -tuln | grep LISTEN

        # 显示连接最多的IP
        echo ""
        echo "连接最多的远程IP (前10):"
        netstat -ant | awk '{print $5}' | cut -d: -f1 | grep -v Address | sort | uniq -c | sort -rn | head -10

        sleep $interval
    done
}

# 4. 检测异常连接
detect_abnormal_connections() {
    echo "检测异常连接..."

    # 检查到不常见端口的连接
    echo "1. 检查到非常用端口的连接 (<1024 或 >49151):"
    netstat -ant | awk '$5 ~ /:[0-9]+$/ && $5 !~ /:(22|80|443|3306|5432|6379)$/ {print $5}' | cut -d: -f2 | sort -nu

    # 检查大量TIME_WAIT连接
    echo ""
    echo "2. 检查TIME_WAIT连接:"
    time_wait_count=$(netstat -ant | grep TIME_WAIT | wc -l)
    echo "TIME_WAIT连接数: $time_wait_count"

    if [ $time_wait_count -gt 100 ]; then
        echo "警告: TIME_WAIT连接过多!"
    fi

    # 检查SYN_RECV连接 (可能的SYN flood攻击)
    echo ""
    echo "3. 检查SYN_RECV连接:"
    syn_recv_count=$(netstat -ant | grep SYN_RECV | wc -l)
    echo "SYN_RECV连接数: $syn_recv_count"

    if [ $syn_recv_count -gt 10 ]; then
        echo "警告: 可能的SYN flood攻击!"
    fi
}

# 5. 网络性能分析
network_performance_analysis() {
    echo "网络性能分析..."

    # 检查接收/发送队列
    echo "1. 接收/发送队列检查:"
    netstat -i | awk 'NR>2 {print $1, $3, $7}'

    # 检查错误和丢包
    echo ""
    echo "2. 网络错误统计:"
    netstat -i | awk 'NR>2 {if($4>0 || $5>0 || $6>0 || $8>0) print $0}'

    # 协议统计
    echo ""
    echo "3. 协议统计摘要:"
    netstat -s | head -20
}

# 6. 服务健康检查
service_health_check() {
    local services=("ssh" "http" "https" "mysql" "postgresql" "redis")

    echo "服务健康检查..."
    echo ""

    for service in "${services[@]}"; do
        # 获取服务端口
        case $service in
            ssh) port=22 ;;
            http) port=80 ;;
            https) port=443 ;;
            mysql) port=3306 ;;
            postgresql) port=5432 ;;
            redis) port=6379 ;;
            *) port="" ;;
        esac

        if [ -n "$port" ]; then
            if netstat -tuln | grep -q ":$port "; then
                echo "✓ $service ($port): 正在监听"
            else
                echo "✗ $service ($port): 未监听"
            fi
        fi
    done
}

# 7. 网络连接可视化
visualize_connections() {
    echo "网络连接可视化..."
    echo ""

    # 创建简单的连接图
    echo "本地地址 <- 连接 -> 远程地址"
    echo "=============================="

    netstat -ant | grep ESTABLISHED | head -10 | while read line; do
        local_addr=$(echo $line | awk '{print $4}')
        remote_addr=$(echo $line | awk '{print $5}')
        echo "$local_addr <---> $remote_addr"
    done
}

# 8. 导出网络连接报告
export_network_report() {
    local report_file="/tmp/network-report-$(date +%Y%m%d-%H%M%S).txt"

    echo "生成网络报告: $report_file"

    {
        echo "=== 网络连接报告 ==="
        echo "生成时间: $(date)"
        echo "主机名: $(hostname)"
        echo ""

        echo "1. 监听端口:"
        echo "----------------"
        netstat -tuln
        echo ""

        echo "2. 活动连接:"
        echo "----------------"
        netstat -ant
        echo ""

        echo "3. 路由表:"
        echo "----------------"
        netstat -rn
        echo ""

        echo "4. 接口统计:"
        echo "----------------"
        netstat -i
        echo ""

        echo "5. 协议统计:"
        echo "----------------"
        netstat -s | head -30
        echo ""

        echo "6. 连接统计:"
        echo "----------------"
        echo "总连接数: $(netstat -an | wc -l)"
        echo "TCP连接数: $(netstat -at | wc -l)"
        echo "UDP连接数: $(netstat -au | wc -l)"

    } > "$report_file"

    echo "报告已生成: $report_file"
}

# 9. 主菜单
main_menu() {
    while true; do
        clear
        echo "=== 网络故障排查和监控工具 ==="
        echo ""
        echo "1. 检查端口占用"
        echo "2. 检查进程连接"
        echo "3. 监控网络连接"
        echo "4. 检测异常连接"
        echo "5. 网络性能分析"
        echo "6. 服务健康检查"
        echo "7. 可视化连接"
        echo "8. 导出网络报告"
        echo "9. 实时流量监控"
        echo "0. 退出"
        echo ""

        read -p "请选择操作: " choice

        case $choice in
            1)
                read -p "输入端口号: " port
                check_port_usage "$port"
                ;;
            2)
                read -p "输入进程名: " process
                check_process_connections "$process"
                ;;
            3)
                read -p "监控间隔(秒，默认5): " interval
                monitor_connections "${interval:-5}"
                ;;
            4) detect_abnormal_connections ;;
            5) network_performance_analysis ;;
            6) service_health_check ;;
            7) visualize_connections ;;
            8) export_network_report ;;
            9)
                echo "实时流量监控 (按 Ctrl+C 停止)..."
                sudo iftop
                ;;
            0)
                echo "退出"
                exit 0
                ;;
            *)
                echo "无效选择"
                ;;
        esac

        echo ""
        read -p "按回车键继续..."
    done
}

# 运行主菜单
main_menu

#!/bin/bash
# 高级网络分析和安全审计

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 1. 安全审计检查
security_audit() {
    echo -e "${BLUE}=== 网络安全审计 ===${NC}"
    echo ""

    # 检查开放的危险端口
    echo -e "${YELLOW}1. 检查危险端口:${NC}"
    dangerous_ports=(21 23 25 135 139 445 1433 3306 3389 5432 5900 6379 27017)

    for port in "${dangerous_ports[@]}"; do
        if netstat -tuln | grep -q ":$port "; then
            service=$(netstat -tuln | grep ":$port " | awk '{print $1, $4}')
            echo -e "${RED}警告: 端口 $port 开放 ($service)${NC}"
        fi
    done

    # 检查外部连接
    echo -e "\n${YELLOW}2. 检查外部连接:${NC}"
    netstat -ant | grep ESTABLISHED | while read line; do
        remote_ip=$(echo $line | awk '{print $5}' | cut -d: -f1)

        # 检查是否为内网IP
        if [[ ! $remote_ip =~ ^(10\.|172\.(1[6-9]|2[0-9]|3[0-1])\.|192\.168\.|127\.) ]]; then
            local_port=$(echo $line | awk '{print $4}' | cut -d: -f2)
            echo -e "${RED}外部连接: $remote_ip -> 本地端口 $local_port${NC}"
        fi
    done

    # 检查隐藏进程
    echo -e "\n${YELLOW}3. 检查隐藏进程连接:${NC}"
    sudo netstat -tunp 2>/dev/null | grep -v "-" | while read line; do
        pid=$(echo $line | awk '{print $7}' | cut -d'/' -f1)
        if [ -n "$pid" ] && [ ! -d "/proc/$pid" ]; then
            echo -e "${RED}隐藏进程连接: PID $pid 不存在于/proc${NC}"
        fi
    done
}

# 2. 网络基线分析
network_baseline_analysis() {
    local baseline_file="/etc/network-baseline.conf"

    echo -e "${BLUE}=== 网络基线分析 ===${NC}"

    if [ ! -f "$baseline_file" ]; then
        echo "创建网络基线..."

        # 保存当前监听端口
        netstat -tuln | grep LISTEN > "$baseline_file"

        # 保存活动连接模式
        netstat -ant | awk '{print $5}' | cut -d: -f1 | sort | uniq -c > "$baseline_file.ips"

        echo -e "${GREEN}基线已创建${NC}"
    else
        echo "对比当前状态与基线..."

        # 检查新开放的端口
        echo -e "\n${YELLOW}新增监听端口:${NC}"
        current_listen=$(netstat -tuln | grep LISTEN)
        added=$(diff <(cat "$baseline_file") <(echo "$current_listen") | grep "^>")

        if [ -n "$added" ]; then
            echo -e "${RED}$added${NC}"
        else
            echo -e "${GREEN}无新增端口${NC}"
        fi

        # 检查IP连接模式变化
        echo -e "\n${YELLOW}IP连接模式变化:${NC}"
        current_ips=$(netstat -ant | awk '{print $5}' | cut -d: -f1 | sort | uniq -c)
        ip_changes=$(diff "$baseline_file.ips" <(echo "$current_ips"))

        if [ -n "$ip_changes" ]; then
            echo -e "${YELLOW}连接模式有变化${NC}"
        fi
    fi
}

# 3. 入侵检测
intrusion_detection() {
    echo -e "${BLUE}=== 入侵检测 ===${NC}"

    # 检查异常连接模式
    echo -e "\n${YELLOW}1. 异常连接检测:${NC}"

    # 检查到非常用端口的连接
    suspicious_ports=(31337 6667 12345 54321 27374)
    for port in "${suspicious_ports[@]}"; do
        if netstat -ant | grep -q ":$port"; then
            echo -e "${RED}可疑端口连接: $port${NC}"
        fi
    done

    # 检查来自同一IP的大量连接
    echo -e "\n${YELLOW}2. 检查连接洪水攻击:${NC}"
    netstat -ant | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -5 | while read count ip; do
        if [ $count -gt 50 ]; then
            echo -e "${RED}可能的洪水攻击: $ip 有 $count 个连接${NC}"
        fi
    done

    # 检查反向shell特征
    echo -e "\n${YELLOW}3. 检查反向shell特征:${NC}"
    # 查找从本地到远程高端口的连接
    netstat -ant | grep ESTABLISHED | while read line; do
        local_port=$(echo $line | awk '{print $4}' | cut -d: -f2)
        remote_port=$(echo $line | awk '{print $5}' | cut -d: -f2)

        if [ $remote_port -gt 30000 ] && [ $local_port -lt 1024 ]; then
            echo -e "${RED}可能的反向shell: 本地端口 $local_port -> 远程端口 $remote_port${NC}"
        fi
    done
}

# 4. 网络取证
network_forensics() {
    local output_dir="/var/log/network-forensics-$(date +%Y%m%d-%H%M%S)"

    echo -e "${BLUE}=== 网络取证 ===${NC}"
    echo "保存取证数据到: $output_dir"

    mkdir -p "$output_dir"

    # 保存所有网络状态
    netstat -a > "$output_dir/netstat-all.txt"
    netstat -s > "$output_dir/netstat-stats.txt"
    netstat -rn > "$output_dir/route-table.txt"
    netstat -i > "$output_dir/interface-stats.txt"

    # 保存连接时间线
    for i in {1..5}; do
        date >> "$output_dir/connections-timeline.txt"
        netstat -ant >> "$output_dir/connections-timeline.txt"
        echo "---" >> "$output_dir/connections-timeline.txt"
        sleep 1
    done

    # 创建取证报告
    cat > "$output_dir/forensics-report.txt" << EOF
网络取证报告
============
时间: $(date)
主机: $(hostname)
取证目录: $output_dir

文件列表:
1. netstat-all.txt - 所有网络连接
2. netstat-stats.txt - 协议统计
3. route-table.txt - 路由表
4. interface-stats.txt - 接口统计
5. connections-timeline.txt - 连接时间线

分析结果:
$(netstat -ant | grep -c ESTABLISHED) 个活跃连接
$(netstat -tuln | grep -c LISTEN) 个监听端口
EOF

    echo -e "${GREEN}取证完成${NC}"
}

# 5. 端口扫描检测
port_scan_detection() {
    echo -e "${BLUE}=== 端口扫描检测 ===${NC}"

    # 检查SYN_RECV状态连接
    syn_recv_count=$(netstat -ant | grep -c SYN_RECV)

    if [ $syn_recv_count -gt 20 ]; then
        echo -e "${RED}警告: 检测到可能的端口扫描 (SYN_RECV: $syn_recv_count)${NC}"

        # 显示来源IP
        echo -e "${YELLOW}来源IP:${NC}"
        netstat -ant | grep SYN_RECV | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn
    else
        echo -e "${GREEN}未检测到端口扫描${NC}"
    fi
}

# 6. 网络流量分析
traffic_analysis() {
    echo -e "${BLUE}=== 网络流量分析 ===${NC}"

    # 检查接口流量
    echo -e "\n${YELLOW}接口流量统计:${NC}"
    netstat -i | awk 'NR>2 {print $1 ": RX=" $3 " TX=" $7 " ERR=" $4+$5+$6+$8}'

    # 检查TCP流量
    echo -e "\n${YELLOW}TCP流量统计:${NC}"
    netstat -s | grep -A 10 "Tcp:" | head -10

    # 检查网络错误
    echo -e "\n${YELLOW}网络错误统计:${NC}"
    errors=$(netstat -s | grep -E "(error|fail|drop|discard)" | head -10)
    if [ -n "$errors" ]; then
        echo -e "${YELLOW}$errors${NC}"
    else
        echo -e "${GREEN}无明显网络错误${NC}"
    fi
}

# 7. 恶意软件检测
malware_detection() {
    echo -e "${BLUE}=== 恶意软件检测 ===${NC}"

    # 检查隐藏的监听端口
    echo -e "\n${YELLOW}1. 检查隐藏监听端口:${NC}"
    sudo netstat -tulnp 2>/dev/null | while read line; do
        process=$(echo $line | awk '{print $7}')
        if [[ $process == "-" ]]; then
            echo -e "${RED}无进程信息的监听端口: $line${NC}"
        fi
    done

    # 检查异常出站连接
    echo -e "\n${YELLOW}2. 检查异常出站连接:${NC}"

    # 常见C&C服务器端口
    cnc_ports=(6667 7000 8080 8443 9001 12345 31337)
    for port in "${cnc_ports[@]}"; do
        if netstat -ant | grep -q ":$port" && netstat -ant | grep ":$port" | grep -q ESTABLISHED; then
            echo -e "${RED}连接到可疑端口 $port (可能的C&C服务器)${NC}"
        fi
    done

    # 检查DNS隧道特征
    echo -e "\n${YELLOW}3. 检查DNS隧道特征:${NC}"
    dns_queries=$(netstat -s | grep "packets received" | head -1 | awk '{print $1}')
    if [ $dns_queries -gt 1000 ]; then
        echo -e "${RED}高DNS查询量: $dns_queries (可能的DNS隧道)${NC}"
    fi
}

# 8. 合规性检查
compliance_check() {
    echo -e "${BLUE}=== 网络安全合规性检查 ===${NC}"

    score=0
    total=8

    echo ""

    # 检查1: SSH是否只监听内网
    echo -e "${YELLOW}1. 检查SSH监听配置:${NC}"
    if netstat -tuln | grep ":22 " | grep -q "0.0.0.0"; then
        echo -e "${RED}✗ SSH监听在所有接口 (安全风险)${NC}"
    else
        echo -e "${GREEN}✓ SSH监听范围正确${NC}"
        ((score++))
    fi

    # 检查2: 是否启用防火墙
    echo -e "\n${YELLOW}2. 检查防火墙状态:${NC}"
    if command -v ufw &> /dev/null && ufw status | grep -q "Status: active"; then
        echo -e "${GREEN}✓ 防火墙已启用${NC}"
        ((score++))
    elif command -v firewall-cmd &> /dev/null && firewall-cmd --state 2>/dev/null | grep -q "running"; then
        echo -e "${GREEN}✓ 防火墙已启用${NC}"
        ((score++))
    else
        echo -e "${RED}✗ 防火墙未启用${NC}"
    fi

    # 检查3: 不必要的服务
    echo -e "\n${YELLOW}3. 检查不必要的服务:${NC}"
    unnecessary_ports=(21 23 25 135 139 445)
    found_unnecessary=0

    for port in "${unnecessary_ports[@]}"; do
        if netstat -tuln | grep -q ":$port "; then
            echo -e "${RED}✗ 端口 $port 开放${NC}"
            found_unnecessary=1
        fi
    done

    if [ $found_unnecessary -eq 0 ]; then
        echo -e "${GREEN}✓ 无危险端口开放${NC}"
        ((score++))
    fi

    # 检查4: root用户连接
    echo -e "\n${YELLOW}4. 检查root用户网络活动:${NC}"
    if sudo netstat -tunp 2>/dev/null | grep "/" | grep -q "^root"; then
        echo -e "${YELLOW}⚠ root用户有网络连接${NC}"
    else
        echo -e "${GREEN}✓ 无root用户网络连接${NC}"
        ((score++))
    fi

    # 检查5: 外部连接数量
    echo -e "\n${YELLOW}5. 检查外部连接数量:${NC}"
    external_conn=$(netstat -ant | grep ESTABLISHED | awk '{print $5}' | cut -d: -f1 | grep -vE "^(10\.|172\.(1[6-9]|2[0-9]|3[0-1])\.|192\.168\.|127\.)" | wc -l)

    if [ $external_conn -gt 100 ]; then
        echo -e "${RED}✗ 外部连接过多: $external_conn${NC}"
    else
        echo -e "${GREEN}✓ 外部连接正常: $external_conn${NC}"
        ((score++))
    fi

    # 检查6: TIME_WAIT连接
    echo -e "\n${YELLOW}6. 检查TIME_WAIT连接:${NC}"
    time_wait=$(netstat -ant | grep -c TIME_WAIT)

    if [ $time_wait -gt 1000 ]; then
        echo -e "${RED}✗ TIME_WAIT连接过多: $time_wait${NC}"
    else
        echo -e "${GREEN}✓ TIME_WAIT连接正常: $time_wait${NC}"
        ((score++))
    fi

    # 检查7: 监听端口数量
    echo -e "\n${YELLOW}7. 检查监听端口数量:${NC}"
    listen_ports=$(netstat -tuln | grep -c LISTEN)

    if [ $listen_ports -gt 50 ]; then
        echo -e "${RED}✗ 监听端口过多: $listen_ports${NC}"
    else
        echo -e "${GREEN}✓ 监听端口正常: $listen_ports${NC}"
        ((score++))
    fi

    # 检查8: 网络错误统计
    echo -e "\n${YELLOW}8. 检查网络错误:${NC}"
    errors=$(netstat -i | awk 'NR>2 {sum+=$4+$5+$6+$8} END {print sum}')

    if [ $errors -gt 100 ]; then
        echo -e "${RED}✗ 网络错误过多: $errors${NC}"
    else
        echo -e "${GREEN}✓ 网络错误正常: $errors${NC}"
        ((score++))
    fi

    # 计算结果
    echo -e "\n${BLUE}=== 合规性检查结果 ===${NC}"
    percentage=$((score * 100 / total))
    echo "得分: $score/$total"
    echo "合规率: $percentage%"

    if [ $percentage -ge 80 ]; then
        echo -e "${GREEN}状态: ✓ 合规${NC}"
    elif [ $percentage -ge 60 ]; then
        echo -e "${YELLOW}状态: ⚠ 部分合规${NC}"
    else
        echo -e "${RED}状态: ✗ 不合规${NC}"
    fi
}

# 9. 主菜单
main_menu() {
    while true; do
        clear
        echo -e "${BLUE}=== 高级网络分析和安全审计工具 ===${NC}"
        echo ""
        echo "1. 安全审计检查"
        echo "2. 网络基线分析"
        echo "3. 入侵检测"
        echo "4. 网络取证"
        echo "5. 端口扫描检测"
        echo "6. 网络流量分析"
        echo "7. 恶意软件检测"
        echo "8. 合规性检查"
        echo "9. 生成安全报告"
        echo "0. 退出"
        echo ""

        read -p "请选择操作: " choice

        case $choice in
            1) security_audit ;;
            2) network_baseline_analysis ;;
            3) intrusion_detection ;;
            4) network_forensics ;;
            5) port_scan_detection ;;
            6) traffic_analysis ;;
            7) malware_detection ;;
            8) compliance_check ;;
            9)
                output_file="/tmp/security-report-$(date +%Y%m%d-%H%M%S).txt"
                {
                    security_audit
                    echo ""
                    network_baseline_analysis
                    echo ""
                    intrusion_detection
                    echo ""
                    compliance_check
                } > "$output_file" 2>&1
                echo -e "${GREEN}安全报告已生成: $output_file${NC}"
                ;;
            0)
                echo -e "${GREEN}退出${NC}"
                exit 0
                ;;
            *)
                echo -e "${RED}无效选择${NC}"
                ;;
        esac

        echo ""
        read -p "按回车键继续..."
    done
}

# 运行主菜单
main_menu