发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 1.2k | 阅读时长 ≈ 4

资产是安全防守的基石。如果你不知道自己有什么，就不可能保护好它们。在网络安全攻防实战中，企业对自己资产的了解程度往往远低于攻击者。攻击者只需要找到一个入口点，而防守者需要保护所有可能的入口，资产画像就是解决这个问题的核心方法论。

【什么是资产画像？】

资产画像是对网络空间中每一项资产进行全方位、多维度描述的过程。目标是回答三个核心问题：

  1. 这资产是什么？—— 身份与属性
  2. 暴露面有多大？—— 可攻击面
  3. 风险有多少？—— 脆弱性与影响

【资产画像的七大核心维度】

一、身份维度（是谁）

  • 资产标识：IP、MAC、主机名、域名
  • 资产类型：服务器、网络设备、安全设备、终端、IoT、云资源
  • 资产权属：所属业务、所属部门、责任人
  • 生命周期：入网时间、退役时间、状态
  • 实战要点：建立统一命名规范，确保对应关系准确，关注云环境弹性资产

二、暴露面维度（在哪）

  • 网络位置：内网/DMZ/外网/云上
  • 可达性：从互联网是否可直接访问
  • 开放端口与服务：22、80、443、3389、3306等
  • 攻击面：外部暴露点、可被利用的入口
  • 实战要点：互联网暴露资产是重中之重，关注非常规端口，区分主动/被动暴露

三、脆弱性维度（有什么弱点）

  • 系统漏洞：CVE编号、CVSS评分、PoC状态
  • 配置缺陷：弱口令、默认配置、未授权访问
  • 补丁状态：缺失的关键补丁
  • 组件风险：Log4j、Fastjson等高危组件
  • 实战要点：漏洞数量不重要，可利用性才重要，关注N-day漏洞武器化程度

四、价值维度（值不值得保护）

  • 数据敏感度：是否含敏感数据、数据级别
  • 业务重要性：核心系统/一般系统/边缘系统
  • 影响范围：一旦失陷影响面多大
  • 实战要点：核心业务+敏感数据=最高防护优先级，关注低调但重要的资产

五、防护维度（有什么保护）

  • 终端防护：杀软、EDR、HIDS
  • 网络防护：防火墙、WAF、IPS
  • 访问控制：VPN、零信任、多因素认证
  • 监控覆盖：日志审计、流量监控
  • 实战要点：有部署不等于有效防护，关注防护盲区，日志要能支撑溯源

六、行为维度（平时干什么）

  • 通信模式：正常对外连接哪些IP/端口
  • 流量基线：日常流量特征
  • 用户行为：谁在用什么方式访问
  • 实战要点：建立基线需2-4周积累，关注突然出现的行为，可用于威胁狩猎

七、信任关系维度（和谁有联系）

  • 横向关联：和哪些内网资产通信
  • 纵向关联：上下游业务依赖
  • 信任路径：从它出发能到达哪些关键资产
  • 实战要点：关注枢纽型资产，横向移动目标是域控/核心数据库，打破内网即信任假设

【实施优先级】

  • 第一阶段（1-2月）：身份+暴露面+脆弱性 —— 摸清家底，识别高风险资产
  • 第二阶段（1-2月）：价值+信任关系 —— 建立业务视角，识别关键资产
  • 第三阶段（持续）：防护+行为 —— 完善监控，支撑威胁检测

【资产画像数据来源】

  • 自动化采集：nmap/masscan资产发现、Nessus/OpenVAS漏洞扫描、NDR流量分析、SIEM日志平台
  • 人工维护：CMDB资产流程、业务调研访谈、数据分类分级项目

【应用场景】

  1. 资产清点与合规
  2. 漏洞管理优先级
  3. 攻防演练与红队评估
  4. 应急响应与溯源
  5. 安全运营与威胁狩猎

【常见挑战与对策】

  • 挑战1：资产数量庞大 → 分阶段推进，优先覆盖核心资产
  • 挑战2：数据质量差 → 多源数据交叉验证，建立校验机制
  • 挑战3：云环境动态变化 → 接入云API实时同步，缩短扫描周期
  • 挑战4：跨部门协作困难 → 建立统一资产平台，明确维护责任

【结语】

资产画像不是一次性项目，而是持续演进的过程。最终目标：知己知彼，百战不殆。
当攻击来临时，你能比攻击者更快地回答：

  • 哪些资产暴露在互联网上？
  • 哪些资产存在高危漏洞？
  • 哪些资产存储敏感数据？
  • 攻击者可能通过什么路径横向移动？

做到这些，你就拥有了防守的主动权。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 7.6k | 阅读时长 ≈ 35

摘要

手头上有几台服务器，经常要对服务器进行健康检查、安全检查等。这几天让ClaudeCode自己写了个Skill这样就一句话活就让AI给干了。本文详细介绍了如何使用Claude Code AI辅助开发工具，从零开始构建一个生产级运维健康检查的Skill。重点阐述了整体架构设计、核心功能实现细节以及实际应用效果。该系统采用模块化设计，提供三大检查模块（基础健康检查、深度安全审计、Docker容器监控），支持双格式输出（Markdown人工可读 + JSON机器可处理），具有良好的可扩展性和兼容性。

一、背景与设计目标

1.1 实际需求

在日常运维工作中，我们需要对多台服务器进行健康检查，涵盖系统资源、Docker容器状态、安全指标等多个维度。虽然市面上有很多成熟的监控方案（如Prometheus、Grafana、Zabbix等），但在以下场景中，我们需要一个轻量级、快速部署的检查工具：

  • 日常巡检：每天对服务器进行快速健康扫描
  • 安全审计：定期检查异常进程、可疑网络连接、文件系统安全
  • 容器监控：检查Docker容器运行状态、资源使用情况
  • 问题排查：当系统出现问题时，快速获取当前状态信息

1.2 设计目标

基于上述需求，我设定了以下设计目标交给了Claude Code：

核心特性：

  • ✅ 轻量级部署：基于Bash脚本，无需额外依赖，远程执行无需安装
  • ✅ 双格式输出：同时生成Markdown（人工阅读）和JSON（机器处理）格式
  • ✅ 模块化架构：三大检查模块独立运行，可按需组合
  • ✅ 状态可视化：使用emoji（✅正常/⚠️警告/❌严重）直观展示
  • ✅ 广泛兼容性：支持bash 3.2+（macOS默认版本），适配主流Linux发行版

技术亮点：

  • 统一的输出库设计，实现代码复用
  • JSON三层结构（summary/details/metadata），满足不同使用场景
  • 完善的错误处理和兼容性方案
  • 清晰的扩展接口，便于添加新的检查类型

二、整体架构设计

2.1 系统架构

Claude Code自动帮我设计了整体架构
运维健康检查系统采用模块化设计，包含三个独立的检查模块：

模块名称 脚本文件 功能定位 核心检查项
基础健康检查 health-check.sh 日常巡检、快速评估 系统资源、内存、磁盘、网络、服务状态、基础安全
深度安全检查 security-check.sh 安全审计、威胁检测 异常进程、可疑连接、文件安全、账户安全、系统完整性
Docker容器监控 docker-check.sh 容器环境管理 容器状态、资源使用、镜像管理、存储空间

设计原则：

  • 独立性：每个脚本可单独运行，互不依赖
  • 一致性：统一的输出格式和状态指示
  • 可扩展性：易于添加新的检查项或模块
  • 远程友好：支持SSH管道执行，无需远程安装

2.2 文件结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
host-manage/
├── skills/ops-health-check/
│   ├── SKILL.md                    # Skill定义和使用文档
│   └── scripts/
│       ├── health-check.sh         # 基础健康检查脚本
│       ├── security-check.sh       # 深度安全检查脚本
│       ├── docker-check.sh         # Docker监控脚本
│       └── lib/
│           └── output.sh           # 输出格式化库（核心）
├── docs/plans/
│   ├── 2025-01-17-ops-health-check-design.md     # 整体设计文档
│   └── 2025-01-18-json-output-design.md          # JSON输出设计
└── health-reports/                 # 检查报告输出目录
    ├── health-check-*.md           # Markdown格式报告
    ├── health-check-*.json         # JSON格式数据
    ├── security-check-*.md
    ├── security-check-*.json
    ├── docker-check-*.md
    └── docker-check-*.json

三、核心功能实现

Claude Code自动帮我实现了所有的功能

3.1 基础健康检查模块（health-check.sh）

这是日常运维使用最频繁的模块，专注于快速评估系统整体健康状况。

3.1.1 系统运行时间和负载检查

检查目的：了解系统运行时长和当前负载压力

实现逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 获取系统运行时间
uptime_output=$(uptime)
uptime_clean=$(echo "$uptime_output" | sed 's/^ *//g')

# 兼容不同系统的uptime输出格式
uptime_str=$(uptime -p 2>/dev/null || \
    echo "$uptime_clean" | awk -F'up ' '{print $2}' | awk -F',' '{print $1}')

# 提取负载平均值（1分钟、5分钟、15分钟）
load_str=$(echo "$uptime_clean" | awk -F'load average:' '{print $2}' | sed 's/^ *//g')
load_1min=$(echo $load_str | awk '{print $1}' | sed 's/,//')
load_5min=$(echo $load_str | awk '{print $2}' | sed 's/,//')
load_15min=$(echo $load_str | awk '{print $3}')

# 判断负载状态
load_status=$(check_load_status "$load_1min" "$CPU_WARNING" "$CPU_CRITICAL")

状态判断函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
check_load_status() {
    local load=$1
    local warning=$2
    local critical=$3

    # 使用bc进行浮点数比较
    if (( $(echo "$load >= $critical" | bc -l) )); then
        echo "critical"
    elif (( $(echo "$load >= $warning" | bc -l) )); then
        echo "warning"
    else
        echo "ok"
    fi
}

关键点：

  • 使用bc -l进行浮点数比较，兼容不同系统
  • 兼容uptime -p命令（human-readable格式）不可用的情况
  • 同时收集三个时间维度的负载数据，用于趋势分析

3.1.2 内存使用检查

检查目的：监控内存和swap使用情况，防止内存耗尽

实现逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 获取内存信息（单位：MB）
memory_info=$(free -m | grep Mem)
mem_total=$(echo $memory_info | awk '{print $2}')
mem_used=$(echo $memory_info | awk '{print $3}')
mem_avail=$(echo $memory_info | awk '{print $7}')  # available列更准确
mem_percent=$(awk "BEGIN {printf \"%.1f\", $mem_used * 100 / $mem_total}")

# Swap检查
swap_info=$(free -m | grep Swap)
swap_total=$(echo $swap_info | awk '{print $2}')
swap_used=$(echo $swap_info | awk '{print $3}')

if [ "$swap_total" -gt 0 ]; then
    swap_percent=$(awk "BEGIN {printf \"%.1f\", $swap_used * 100 / $swap_total}")
else
    swap_percent=0
fi

# 状态判断
if (( $(echo "$mem_percent >= $MEMORY_CRITICAL" | bc -l) )); then
    mem_status="critical"
elif (( $(echo "$mem_percent >= $MEMORY_WARNING" | bc -l) )); then
    mem_status="warning"
else
    mem_status="ok"
fi

输出示例：

1
2
3
4
5
6
### 内存使用
- **总内存**: 16384MB
- **已使用**: 12500MB (76.3%)
- **可用**: 3884MB
- **Swap**: 256MB / 2048MB (12.5%)
- **状态**: ⚠️ 警告

关键点：

  • 使用free命令的available列而非free列，更准确反映可用内存
  • 同时检查swap使用率，高swap使用率通常意味着内存压力
  • 支持自定义阈值配置（通过环境变量MEMORY_WARNING、MEMORY_CRITICAL）

3.1.3 磁盘空间检查

检查目的：监控所有挂载点的磁盘使用情况，防止磁盘空间不足

实现逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
echo "### 磁盘空间"
echo "| 挂载点 | 设备 | 容量 | 已用 | 可用 | 使用率 | 状态 |"
echo "|--------|------|------|------|------|--------|------|"

# 遍历所有挂载点（排除临时文件系统）
df -h | grep -vE '^Filesystem|tmpfs|overlay|none' | while read -r line; do
    device=$(echo $line | awk '{print $1}')
    size=$(echo $line | awk '{print $2}')
    used=$(echo $line | awk '{print $3}')
    avail=$(echo $line | awk '{print $4}')
    use_percent=$(echo $line | awk '{print $5}' | sed 's/%//')
    mount=$(echo $line | awk '{print $6}')

    # 判断状态
    if [ "$use_percent" -ge "$DISK_CRITICAL" ]; then
        status="critical"
        emoji="❌"
    elif [ "$use_percent" -ge "$DISK_WARNING" ]; then
        status="warning"
        emoji="⚠️"
    else
        status="ok"
        emoji="✅"
    fi

    # 输出Markdown表格行
    echo "| $mount | $device | $size | $used | $avail | ${use_percent}% | $emoji |"

    # 收集JSON数据
    add_disk_data "$mount" "device" "$device"
    add_disk_data "$mount" "total_gb" "$size"
    add_disk_data "$mount" "used_gb" "$used"
    add_disk_data "$mount" "available_gb" "$avail"
    add_disk_data "$mount" "used_percent" "$use_percent"
    add_disk_data "$mount" "status" "$status"
done

输出示例：

1
2
3
4
5
6
### 磁盘空间
| 挂载点 | 设备 | 容量 | 已用 | 可用 | 使用率 | 状态 |
|--------|------|------|------|------|--------|------|
| / | /dev/sda1 | 100G | 45G | 55G | 45.0% | ✅ 正常 |
| /data | /dev/sdb1 | 500G | 425G | 75G | 85.0% | ⚠️ 警告 |
| /boot | /dev/sda2 | 1G | 250M | 750M | 25.0% | ✅ 正常 |

关键点：

  • 自动过滤tmpfs、overlay等临时文件系统
  • 支持多个挂载点，每个挂载点独立判断状态
  • 使用整数比较（已去除百分号），提高性能
  • 同时生成Markdown表格和JSON数组数据

3.1.4 网络连接统计

检查目的：了解当前网络连接数量，快速发现异常连接

实现逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 使用ss命令替代netstat（更现代）
if command -v ss >/dev/null 2>&1; then
    # 总连接数
    total_connections=$(ss -tn | wc -l)

    # 外部连接数（排除本地回环）
    external_connections=$(ss -tn | awk '{print $5}' | \
        grep -v '127.0.0.1' | \
        grep -v '::1' | \
        cut -d':' -f1 | \
        sort -u | \
        wc -l)

    # 监听端口数
    listening_ports=$(ss -tln | wc -l)
else
    # 降级到netstat
    total_connections=$(netstat -tn 2>/dev/null | wc -l)
    external_connections=$(netstat -tn 2>/dev/null | awk '{print $5}' | \
        grep -v '127.0.0.1' | \
        grep -v '::1' | \
        cut -d':' -f1 | \
        sort -u | \
        wc -l)
    listening_ports=$(netstat -tln 2>/dev/null | wc -l)
fi

add_system_data "network_total_connections" "$total_connections"
add_system_data "network_external_connections" "$external_connections"
add_system_data "network_listening_ports" "$listening_ports"

关键点：

  • 优先使用ss命令（现代Linux推荐），降级到netstat
  • 统计外部独立IP连接数，而非连接总数（更准确反映异常）
  • 包含监听端口数量，便于发现未授权监听

3.1.5 systemd服务状态检查

检查目的：检查系统服务运行状态，发现失败服务

实现逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 检查systemd是否可用
if command -v systemctl >/dev/null 2>&1; then
    # 统计服务状态
    running_services=$(systemctl list-units --type=service --state=running 2>/dev/null | \
        grep 'loaded loaded' | wc -l)

    failed_services=$(systemctl list-units --type=service --state=failed 2>/dev/null | \
        grep 'loaded loaded' | wc -l)

    enabled_services=$(systemctl list-unit-files --type=service --state=enabled 2>/dev/null | \
        grep 'enabled' | wc -l)

    # 获取失败服务列表
    if [ "$failed_services" -gt 0 ]; then
        failed_list=$(systemctl list-units --type=service --state=failed 2>/dev/null | \
            grep 'loaded loaded' | awk '{print $1}')

        echo "### 失败的服务"
        echo "$failed_list" | while read -r service; do
            echo "- ❌ $service"
        done
    fi

    # 常用关键服务检查
    critical_services=("ssh" "docker" "cron" "rsyslog")
    for svc in "${critical_services[@]}"; do
        if systemctl is-active --quiet "${svc}.service" 2>/dev/null; then
            echo "- ✅ ${svc}.service: 运行中"
        else
            echo "- ⚠️ ${svc}.service: 未运行或不存在"
        fi
    done
else
    echo "⚠️ 系统不使用systemd"
fi

输出示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
### 服务状态
- **运行中**: 23个
- **失败**: 2个
- **启用**: 15个

#### 关键服务状态
- ✅ ssh.service: 运行中
- ✅ docker.service: 运行中
- ✅ cron.service: 运行中
- ❌ postfix.service: 已停止

#### 失败的服务列表
- ❌ postfix.service
- ❌ ufw.service

关键点：

  • 兼容非systemd系统（如SysV init）
  • 区分”运行中”、”失败”、”启用”三种状态
  • 单独检查关键服务（SSH、Docker等），便于快速定位问题
  • 列出所有失败服务，方便管理员进一步排查

3.1.6 基础安全检查

虽然主要的安全检查在security-check.sh中，但基础健康检查也包含几个关键的安全指标：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
echo "### 基础安全"

# 1. 检查挖矿进程
MINING_PROCESSES=("xmrig" "minerd" "cpuminer" "ccminer" "Claymore")
mining_found=0

for proc in "${MINING_PROCESSES[@]}"; do
    if pgrep -x "$proc" >/dev/null; then
        echo "- ❌ 发现挖矿进程: $proc"
        mining_found=1
    fi
done

if [ $mining_found -eq 0 ]; then
    echo "- ✅ 未发现挖矿进程"
fi

# 2. 检查/tmp和/dev/shm中的可执行文件
tmp_execs=$(find /tmp /dev/shm -type f -executable 2>/dev/null | wc -l)
if [ "$tmp_execs" -gt 0 ]; then
    echo "- ⚠️ 临时目录中发现 $tmp_execs 个可执行文件"
else
    echo "- ✅ 临时目录无可执行文件"
fi

# 3. 检查失败登录次数（最近）
if [ -f /var/log/auth.log ]; then
    failed_logins=$(grep "Failed password" /var/log/auth.log 2>/dev/null | \
        tail -100 | wc -l)
    echo "- 最近失败登录次数: $failed_logins"
fi

3.2 深度安全检查模块（security-check.sh）

这是最复杂的模块，涵盖了5大类、20+项安全检查，用于全面的安全审计。

3.2.1 异常进程检测

检查目的：发现挖矿程序、高资源占用进程、可疑可执行文件

1. 挖矿进程检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 定义已知挖矿程序名称列表
MINING_PROCESSES=(
    "xmrig" "minerd" "cpuminer" "ccminer" "Claymore"
    "cryptonight" "ethminer" "nbminer" "bminer"
)

suspicious_procs=""
mining_detected="false"

# 遍历检查
for proc in "${MINING_PROCESSES[@]}"; do
    # 使用pgrep查找进程（比ps aux更快）
    found=$(pgrep -ix "$proc" 2>/dev/null)
    if [ -n "$found" ]; then
        # 获取进程详细信息
        proc_info=$(ps -p "$found" -o pid,user,cmd --no-headers 2>/dev/null)
        suspicious_procs="$suspicious_procs\n$proc_info"
        mining_detected="true"

        # 记录到安全数据
        add_security_data "mining_process" "$proc"
        add_security_data "mining_pid" "$found"
    fi
done

if [ "$mining_detected" = "true" ]; then
    echo "❌ 发现挖矿进程："
    echo -e "$suspicious_procs"
else
    echo "✅ 未发现挖矿进程"
fi

2. 高资源占用进程检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
echo "### 高资源占用进程（Top 10）"
echo "| PID | 用户 | CPU% | 内存% | 命令 |"
echo "|-----|------|------|--------|------|"

# CPU占用最高的进程
ps aux --sort=-%cpu | head -n 11 | tail -n 10 | while read -r line; do
    pid=$(echo "$line" | awk '{print $2}')
    user=$(echo "$line" | awk '{print $1}')
    cpu=$(echo "$line" | awk '{print $3}')
    mem=$(echo "$line" | awk '{print $4}')
    cmd=$(echo "$line" | awk '{for(i=11;i<=NF;i++)printf $i" "}' | cut -c1-50)

    # 标记异常高占用
    if (( $(echo "$cpu > 80" | bc -l) )); then
        echo "| $pid | $user | **$cpu** | $mem | $cmd |"
    else
        echo "| $pid | $user | $cpu | $mem | $cmd |"
    fi
done

3. 临时目录可执行文件检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 检查/tmp和/dev/shm中的可执行文件
tmp_dirs=("/tmp" "/dev/shm" "/var/tmp")

for dir in "${tmp_dirs[@]}"; do
    if [ -d "$dir" ]; then
        exec_files=$(find "$dir" -type f -executable 2>/dev/null)
        exec_count=$(echo "$exec_files" | grep -v '^$' | wc -l)

        if [ "$exec_count" -gt 0 ]; then
            echo "⚠️ $dir 中发现 $exec_count 个可执行文件："
            echo "$exec_files" | head -n 10 | while read -r file; do
                perms=$(stat -c "%a" "$file" 2>/dev/null)
                size=$(stat -c "%s" "$file" 2>/dev/null)
                mtime=$(stat -c "%y" "$file" 2>/dev/null | cut -d'.' -f1)
                echo "  - $file (权限:$perms, 大小:$size字节, 修改:$mtime)"
            done
        fi
    fi
done

关键点：

  • 使用pgrep而非ps aux | grep，性能更高且避免误匹配
  • 记录进程的PID、用户、完整命令行，便于追踪
  • 同时检查/tmp、/dev/shm、/var/tmp三个常见临时目录
  • 显示文件的权限、大小、修改时间，帮助判断是否可疑

3.2.2 网络安全检查

检查目的：发现反向shell、可疑端口监听、异常外部连接

1. 反向shell检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 反向shell典型特征：外部IP连接本地高端口（非标准服务端口）
echo "### 反向shell检测"

# 获取所有TCP连接
if command -v ss >/dev/null 2>&1; then
    connections=$(ss -tnp 2>/dev/null)
else
    connections=$(netstat -tnp 2>/dev/null)
fi

# 检测可疑模式：外部IP连接到本地50000-65535端口
reverse_shell_detected="false"

echo "$connections" | while read -r line; do
    # 解析本地地址和远程地址
    local_addr=$(echo "$line" | awk '{print $4}')
    remote_addr=$(echo "$line" | awk '{print $5}')

    # 提取端口号
    local_port=$(echo "$local_addr" | cut -d':' -f2 | cut -d':' -f1)
    remote_ip=$(echo "$remote_addr" | cut -d':' -f1)

    # 排除本地回环和标准端口
    if [[ ! "$remote_ip" =~ ^(127\.|::1) ]]; then
        # 检查本地端口是否为高端口（非标准服务）
        if [ "$local_port" -ge 50000 ] 2>/dev/null; then
            # 排除部分合法的高端口号
            if [[ ! "$local_port" =~ ^(50000|50001|50002) ]]; then
                echo "⚠️ 可疑连接：远程 $remote_addr -> 本地端口 $local_port"
                reverse_shell_detected="true"
            fi
        fi
    fi
done

if [ "$reverse_shell_detected" = "false" ]; then
    echo "✅ 未发现反向shell特征"
fi

2. 监听端口分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
echo "### 监听端口分析"

# 获取所有监听端口
if command -v ss >/dev/null 2>&1; then
    listening=$(ss -tulpn 2>/dev/null)
else
    listening=$(netstat -tulpn 2>/dev/null)
fi

echo "| 端口 | 协议 | 进程 | 用户 |"
echo "|------|------|------|------|"

echo "$listening" | grep LISTEN | while read -r line; do
    port=$(echo "$line" | awk '{print $5}' | rev | cut -d':' -f1 | rev)
    protocol=$(echo "$line" | awk '{print $1}')
    process=$(echo "$line" | awk '{print $7}' | cut -d'/' -f2 | cut -d',' -f1)
    user=$(echo "$line" | awk '{print $7}' | cut -d'"' -f2)

    # 标记非标准高端口
    if [ "$port" -ge 10000 ]; then
        echo "| **$port** | $protocol | $process | $user |"
    else
        echo "| $port | $protocol | $process | $user |"
    fi
done

3. 外部连接统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 统计外部连接的独立IP数量
external_ips=$(ss -tn 2>/dev/null | \
    awk '{print $5}' | \
    cut -d':' -f1 | \
    grep -vE '^(127\.|::1|0\.0\.0\.0)' | \
    sort -u | \
    wc -l)

echo "### 外部连接统计"
echo "- 外部连接的独立IP数：$external_ips"

# 列出Top 10外部IP
echo "- 连接最多的外部IP："
ss -tn 2>/dev/null | \
    awk '{print $5}' | \
    cut -d':' -f1 | \
    grep -vE '^(127\.|::1|0\.0\.0\.0)' | \
    sort | uniq -c | sort -rn | head -n 10 | \
    while read -r line; do
        count=$(echo "$line" | awk '{print $1}')
        ip=$(echo "$line" | awk '{print $2}')
        echo "  - $ip: $count 次连接"
    done

关键点：

  • 反向shell检测基于行为特征：外部IP连接本地高端口
  • 排除已知的合法高端口（如某些应用服务）
  • 统计外部连接IP数量和连接频率，异常高值需要关注
  • 显示监听端口对应的进程和用户，便于排查

3.2.3 文件系统安全检查

检查目的：发现最近修改的敏感文件、勒索病毒特征、SUID/SGID文件

1. 关键目录变更检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
echo "### 关键目录最近变更（7天内）"

# 定义需要监控的关键目录
critical_dirs=("/etc" "/home" "/root" "/var/www" "/opt")

for dir in "${critical_dirs[@]}"; do
    if [ -d "$dir" ]; then
        # 查找7天内修改的文件
        recent_files=$(find "$dir" -type f -mtime -7 2>/dev/null)

        if [ -n "$recent_files" ]; then
            file_count=$(echo "$recent_files" | grep -v '^$' | wc -l)
            echo "⚠️ $dir: $file_count 个文件在最近7天被修改"

            # 显示部分关键文件
            echo "$recent_files" | head -n 5 | while read -r file; do
                perms=$(stat -c "%a" "$file" 2>/dev/null)
                echo "  - $file (权限:$perms)"
            done
        fi
    fi
done

2. 勒索病毒特征检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
echo "### 勒索病毒特征检测"

# 定义勒索病毒常用的文件扩展名
ransomware_patterns=(
    "*.encrypted"
    "*.locked"
    "*.crypto"
    "*.crypt"
    "*.crypted"
    "*_README.txt"
    "*_DECRYPT.txt"
    "*_HELP.txt"
    "*_RESTORE.txt"
    "how_to_decrypt.*"
    "recover_files.*"
)

ransomware_found="false"
for pattern in "${ransomware_patterns[@]}"; do
    # 在用户目录中查找
    found_files=$(find /home /root -name "$pattern" 2>/dev/null)
    if [ -n "$found_files" ]; then
        echo "❌ 发现勒索病毒特征文件："
        echo "$found_files" | head -n 10
        ransomware_found="true"
    fi
done

if [ "$ransomware_found" = "false" ]; then
    echo "✅ 未发现勒索病毒特征"
fi

3. SUID/SGID文件检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
echo "### SUID/SGID文件检查"

# 查找所有SUID文件
suid_files=$(find / -type f -perm -4000 2>/dev/null | \
    grep -v -E '^/proc|^/sys|^/dev' | \
    head -n 30)

suid_count=$(echo "$suid_files" | grep -v '^$' | wc -l)

if [ "$suid_count" -gt 0 ]; then
    echo "发现 $suid_count 个SUID文件（部分列表）："
    echo "$suid_files" | while read -r file; do
        perms=$(stat -c "%a" "$file" 2>/dev/null)
        owner=$(stat -c "%U" "$file" 2>/dev/null)
        echo "  - $file (权限:$perms, 所有者:$owner)"
    done
fi

# 查找所有SGID文件
sgid_files=$(find / -type f -perm -2000 2>/dev/null | \
    grep -v -E '^/proc|^/sys|^/dev' | \
    head -n 20)

sgid_count=$(echo "$sgid_files" | grep -v '^$' | wc -l)

if [ "$sgid_count" -gt 0 ]; then
    echo "发现 $sgid_count 个SGID文件（部分列表）："
    echo "$sgid_files" | while read -r file; do
        perms=$(stat -c "%a" "$file" 2>/dev/null)
        owner=$(stat -c "%U" "$file" 2>/dev/null)
        echo "  - $file (权限:$perms, 所有者:$owner)"
    done
fi

关键点：

  • 重点监控/etc、/home、/root等敏感目录
  • 勒索病毒检测基于文件扩展名特征（实际环境中建议结合文件内容分析）
  • SUID/SGID文件是提权漏洞的常见切入点，需要重点关注
  • 限制输出数量，避免报告过长

3.2.4 账户和登录安全检查

检查目的：检测异常登录、新增用户、sudo使用情况

1. 最近登录记录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
echo "### 最近登录记录（最近10次）"

# 使用last命令获取登录记录
recent_logins=$(last -n 10 -a 2>/dev/null | head -n -2)

if [ -n "$recent_logins" ]; then
    echo "| 用户 | 终端 | 来源IP | 登录时间 |"
    echo "|------|------|--------|----------|"

    echo "$recent_logins" | while read -r line; do
        user=$(echo "$line" | awk '{print $1}')
        terminal=$(echo "$line" | awk '{print $2}')
        # IP在最后，主机名倒数第二
        ip=$(echo "$line" | awk '{print $(NF-1)}' | sed 's/(//g')
        # 时间范围在中间部分
        time_range=$(echo "$line" | awk '{for(i=3;i<=NF-2;i++)printf $i" "}')

        echo "| $user | $terminal | $ip | $time_range |"
    done
fi

2. 失败登录统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
echo "### 失败登录统计"

# 统计最近失败的登录次数
if [ -f /var/log/auth.log ]; then
    # Debian/Ubuntu系统
    failed_count=$(grep "Failed password" /var/log/auth.log 2>/dev/null | \
        tail -1000 | wc -l)

    echo "- 最近失败登录次数（最近1000条日志）：$failed_count"

    # 统计失败登录来源IP
    echo "- 失败登录最多的IP："
    grep "Failed password" /var/log/auth.log 2>/dev/null | \
        awk '{print $13}' | \
        sort | uniq -c | sort -rn | head -n 5 | \
        while read -r line; do
            count=$(echo "$line" | awk '{print $1}')
            ip=$(echo "$line" | awk '{print $2}')
            echo "  - $ip: $count 次"
        done

elif [ -f /var/log/secure ]; then
    # CentOS/RHEL系统
    failed_count=$(grep "Failed password" /var/log/secure 2>/dev/null | \
        tail -1000 | wc -l)
    echo "- 最近失败登录次数（最近1000条日志）：$failed_count"
fi

3. 新增用户检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
echo "### 新增用户检测（最近30天）"

# 检查shadow文件中最近修改的用户
if [ -f /etc/shadow ]; then
    # 第4字段是最后修改时间（天数，从1970-01-01起）
    thirty_days_ago=$(($(date +%s) / 86400 - 30))

    new_users=$(awk -F: -v date="$thirty_days_ago" \
        '$4 >= date {print $1}' /etc/shadow 2>/dev/null)

    if [ -n "$new_users" ]; then
        echo "⚠️ 发现最近30天新增的用户："
        echo "$new_users" | while read -r user; do
            # 获取用户详细信息
            user_info=$(grep "^$user:" /etc/passwd)
            uid=$(echo "$user_info" | cut -d':' -f3)
            home=$(echo "$user_info" | cut -d':' -f6)
            shell=$(echo "$user_info" | cut -d':' -f7)
            echo "  - $user (UID:$uid, HOME:$home, SHELL:$shell)"
        done
    else
        echo "✅ 未发现最近30天的新增用户"
    fi
fi

4. Sudo使用审计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
echo "### Sudo使用审计（最近20条）"

# 检查sudo日志
if command -v journalctl >/dev/null 2>&1; then
    # 使用journalctl读取sudo日志
    sudo_logs=$(journalctl -u sudo 2>/dev/null | tail -n 20)

    if [ -n "$sudo_logs" ]; then
        echo "$sudo_logs" | while read -r line; do
            # 提取关键信息：时间、用户、命令
            echo "  - $line"
        done
    fi
elif [ -f /var/log/auth.log ]; then
    # 从auth.log中提取sudo记录
    sudo_logs=$(grep sudo /var/log/auth.log 2>/dev/null | tail -n 20)
    if [ -n "$sudo_logs" ]; then
        echo "$sudo_logs"
    fi
fi

关键点：

  • 兼容不同Linux发行版的日志文件路径
  • 统计失败登录次数和来源IP，高值可能意味着暴力破解
  • 检测新增用户，特别是UID为0（root权限）的用户
  • 审计sudo使用情况，发现权限滥用

3.2.5 系统完整性检查

检查目的：检查关键文件权限、系统二进制文件完整性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
echo "### 系统完整性检查"

# 定义关键文件列表
critical_files=(
    "/etc/passwd"
    "/etc/shadow"
    "/etc/sudoers"
    "/etc/ssh/sshd_config"
    "/etc/ssh/ssh_host_*_key"
)

echo "| 文件 | 权限 | 所有者 | 组 | 状态 |"
echo "|------|------|--------|-----|------|"

for file in "${critical_files[@]}"; do
    # 使用通配符展开
    for expanded_file in $file; do
        if [ -e "$expanded_file" ]; then
            perms=$(stat -c "%a" "$expanded_file" 2>/dev/null || stat -f "%OLp" "$expanded_file" 2>/dev/null)
            owner=$(stat -c "%U" "$expanded_file" 2>/dev/null || stat -f "%Su" "$expanded_file" 2>/dev/null)
            group=$(stat -c "%G" "$expanded_file" 2>/dev/null || stat -f "%Sg" "$expanded_file" 2>/dev/null)

            # 检查权限是否合适（简化判断）
            status="✅"
            case "$(basename "$expanded_file")" in
                shadow)
                    if [ "$perms" != "000" ] && [ "$perms" != "640" ]; then
                        status="⚠️"
                    fi
                    ;;
                sudoers)
                    if [ "$perms" != "440" ] && [ "$perms" != "400" ]; then
                        status="⚠️"
                    fi
                    ;;
            esac

            echo "| $expanded_file | $perms | $owner | $group | $status |"
        fi
    done
done

关键点：

  • 重点检查/etc/passwd、/etc/shadow等认证相关文件
  • /etc/shadow应该是000或640权限
  • /etc/sudoers应该是440或400权限
  • SSH私钥文件应该是600或400权限

3.3 Docker容器监控模块（docker-check.sh）

专注于Docker环境的健康检查和资源监控。

3.3.1 Docker服务状态检查

检查目的：确认Docker服务运行正常，获取版本信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
echo "## 🐳 Docker服务状态"

# 检查Docker服务是否运行
if command -v docker >/dev/null 2>&1; then
    docker_status=$(systemctl is-active docker 2>/dev/null)

    if [ "$docker_status" = "active" ]; then
        echo "Docker服务: ✅ 运行中"

        # 获取Docker版本
        docker_version=$(docker --version 2>/dev/null | awk '{print $3}' | sed 's/,//')
        echo "Docker版本: $docker_version"

        add_docker_data "service_status" "running"
        add_docker_data "version" "$docker_version"
    else
        echo "Docker服务: ⚠️ 未运行 (状态: $docker_status)"
        add_docker_data "service_status" "$docker_status"
    fi
else
    echo "Docker: ❌ 未安装"
    add_docker_data "service_status" "not_installed"
    return
fi

3.3.2 容器统计与状态

检查目的：了解容器总数、运行状态、停止状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
echo "## 📦 容器状态概览"

# 统计容器数量
total_containers=$(docker ps -a -q 2>/dev/null | wc -l)
running_containers=$(docker ps -q 2>/dev/null | wc -l)
paused_containers=$(docker ps -q -f status=paused 2>/dev/null | wc -l)
stopped_containers=$((total_containers - running_containers - paused_containers))

echo "- 总容器数: $total_containers"
echo "- 运行中: $running_containers"
echo "- 已暂停: $paused_containers"
echo "- 已停止: $stopped_containers"

# 判断整体状态
if [ "$stopped_containers" -gt 0 ]; then
    echo "- 状态: ⚠️ 有 $stopped_containers 个容器已停止"
    overall_status="warning"
elif [ "$running_containers" -gt 0 ]; then
    echo "- 状态: ✅ 正常"
    overall_status="ok"
else
    echo "- 状态: ⚠️ 无运行中的容器"
    overall_status="warning"
fi

# 记录到JSON
add_docker_data "containers_total" "$total_containers"
add_docker_data "containers_running" "$running_containers"
add_docker_data "containers_paused" "$paused_containers"
add_docker_data "containers_stopped" "$stopped_containers"
add_docker_data "overall_status" "$overall_status"

# 列出停止的容器
if [ "$stopped_containers" -gt 0 ]; then
    echo ""
    echo "### 停止的容器："
    docker ps -a -f status=exited --format "table {{.Names}}\t{{.Status}}\t{{.CreatedAt}}" 2>/dev/null
fi

输出示例：

1
2
3
4
5
6
7
8
9
10
11
## 📦 容器状态概览
- 总容器数: 25
- 运行中: 23
- 已暂停: 0
- 已停止: 2
- 状态: ⚠️ 有 2 个容器已停止

### 停止的容器：
NAMES           STATUS                    CREATEDAT
old-postgres    Exited (0) 2 days ago     2026-01-16 10:30:00
test-mysql      Exited (1) 5 days ago     2026-01-13 14:20:00

3.3.3 容器资源使用分析

检查目的：发现资源占用异常的容器，进行容量规划

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
echo "## 📊 容器资源使用（Top 10）"
echo "| 容器名 | 状态 | CPU% | 内存使用 | 内存% | 网络接收 | 网络发送 |"
echo "|--------|------|------|----------|--------|----------|----------|"

# 获取容器实时资源使用（--no-stream避免持续输出）
docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}\t{{.NetIO}}" 2>/dev/null | \
    tail -n +2 | \
    while read -r line; do
        name=$(echo "$line" | awk '{print $1}')
        cpu=$(echo "$line" | awk '{print $2}' | sed 's/%//')
        mem_usage=$(echo "$line" | awk '{print $3}')
        mem_percent=$(echo "$line" | awk '{print $4}' | sed 's/%//')
        net_rx=$(echo "$line" | awk '{print $5}')
        net_tx=$(echo "$line" | awk '{print $6}')

        # 判断容器状态
        if docker ps --format "{{.Names}}" | grep -q "^${name}$"; then
            status="✅"
        else
            status="❌"
        fi

        # 标记高资源占用
        if (( $(echo "$cpu > 50" | bc -l 2>/dev/null || echo "0") )); then
            cpu="**$cpu%**"
        else
            cpu="${cpu}%"
        fi

        if [ "$mem_percent" -gt 80 ] 2>/dev/null; then
            mem_usage="**$mem_usage**"
        fi

        echo "| $name | $status | $cpu | $mem_usage | ${mem_percent}% | $net_rx | $net_tx |"
    done | head -n 11  # 限制Top 10

关键点：

  • 使用--no-stream参数获取当前瞬时数据，而非持续输出
  • 标记CPU>50%和内存>80%的容器，便于快速发现问题
  • 区分运行中和停止的容器
  • 限制输出数量，避免报告过长

3.3.4 镜像管理检查

检查目的：发现悬空镜像，提供清理建议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
echo "## 🖼️ 镜像管理"

# 统计镜像数量
total_images=$(docker images -q 2>/dev/null | wc -l)
dangling_images=$(docker images -f "dangling=true" -q 2>/dev/null | wc -l)

echo "- 总镜像数: $total_images"
echo "- 悬空镜像数: $dangling_images"

# 列出镜像占用空间
if [ "$total_images" -gt 0 ]; then
    echo ""
    echo "### 镜像占用空间（Top 10）："
    echo "| 镜像名 | 标签 | 大小 | 创建时间 |"
    echo "|--------|------|------|----------|"

    docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}\t{{.CreatedAt}}" 2>/dev/null | \
        tail -n +2 | \
        head -n 10 | \
        while read -r line; do
            echo "| $line |"
        done
fi

# 清理建议
if [ "$dangling_images" -gt 0 ]; then
    echo ""
    echo "### 清理建议"
    echo "⚠️ 发现 $dangling_images 个悬空镜像，建议清理："
    echo "\`\`\`bash"
    echo "docker image prune -f"
    echo "\`\`\`"

    # 计算可回收空间
    dangling_size=$(docker images -f "dangling=true" -q 2>/dev/null | \
        xargs docker inspect --format='{{.Size}}' 2>/dev/null | \
        awk '{sum+=$1} END {printf "%.0f", sum/1024/1024}')

    echo "预计可回收空间: ${dangling_size}MB"
fi

3.3.5 存储空间使用

检查目的：了解Docker整体存储占用，发现异常占用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
echo "## 💾 存储空间使用"

docker_info=$(docker system df 2>/dev/null)

if [ -n "$docker_info" ]; then
    echo "$docker_info"

    # 解析存储使用数据
    images_size=$(echo "$docker_info" | grep 'Images' | awk '{print $3}')
    containers_size=$(echo "$docker_info" | grep 'Containers' | awk '{print $3}')
    volumes_size=$(echo "$docker_info" | grep 'Local Volumes' | awk '{print $3}')
    build_cache_size=$(echo "$docker_info" | grep 'Build Cache' | awk '{print $3}')

    add_docker_data "storage_images" "$images_size"
    add_docker_data "storage_containers" "$containers_size"
    add_docker_data "storage_volumes" "$volumes_size"
    add_docker_data "storage_build_cache" "$build_cache_size"

    # 判断是否需要清理
    if [ "$build_cache_size" != "0B" ] && [ "$build_cache_size" != "" ]; then
        echo ""
        echo "### 清理建议"
        echo "⚠️ 构建缓存占用 ${build_cache_size}，建议清理："
        echo "\`\`\`bash"
        echo "docker builder prune -f"
        echo "\`\`\`"
    fi
else
    echo "⚠️ 无法获取存储使用信息"
fi

输出示例：

1
2
3
4
5
6
7
8
9
10
11
## 💾 存储空间使用
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          15        10        3.2GB     1.1GB (34%)
Containers      25        23        1.8GB     256MB (14%)
Local Volumes   8         6         2.5GB     512MB (20%)
Build Cache     0         0         856MB     856MB

### 清理建议
⚠️ 构建缓存占用 856MB，建议清理：
```bash
docker builder prune -f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#### 3.3.6 网络和卷统计

```bash
echo "## 🔌 网络和卷"

# 统计网络
total_networks=$(docker network ls -q 2>/dev/null | wc -l)
echo "- 网络总数: $total_networks"

# 列出网络
if [ "$total_networks" -gt 0 ]; then
    echo ""
    echo "### 网络列表："
    docker network ls --format "table {{.Name}}\t{{.Driver}}\t{{.Scope}}" 2>/dev/null
fi

# 统计卷
total_volumes=$(docker volume ls -q 2>/dev/null | wc -l)
echo ""
echo "- 卷总数: $total_volumes"

# 列出卷
if [ "$total_volumes" -gt 0 ]; then
    echo ""
    echo "### 卷列表："
    docker volume ls --format "table {{.Name}}\t{{.Driver}}\t{{.Scope}}" 2>/dev/null
fi

add_docker_data "networks_total" "$total_networks"
add_docker_data "volumes_total" "$total_volumes"

关键点：

  • 提供清晰的清理建议和命令
  • 统计并显示可回收空间，帮助决策是否清理
  • 列出网络和卷，便于了解整体架构
  • 所有数据同时记录到JSON，便于自动化分析

四、实际应用效果展示

4.1 基础健康检查报告

Markdown报告（人工阅读）

图：健康检查报告

基础健康检查报告

JSON报告（机器处理）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
{
  "summary": {
    "host": {
      "hostname": "pve-ubuntu-pandawiki",
      "ip": "192.168.0.55",
      "check_time": "2026-01-18T08:40:43+0000"
    },
    "overall_status": "warning",
    "status_counts": {
      "ok": 8,
      "warning": 3,
      "critical": 0
    },
    "check_types": ["health"]
  },
  "details": {
    "system": {
      "uptime": "15 days, 3:24",
      "load_1min": 0.15,
      "load_5min": 0.30,
      "load_15min": 0.35,
      "network_total_connections": 45,
      "network_external_connections": 8,
      "network_listening_ports": 12
    },
    "memory": {
      "total_mb": 16384,
      "used_mb": 12500,
      "available_mb": 3884,
      "used_percent": 76.3,
      "swap_total_mb": 2048,
      "swap_used_mb": 256,
      "swap_percent": 12.5,
      "status": "warning"
    },
    "disk": [
      {
        "mount": "/",
        "device": "/dev/sda1",
        "total_gb": "100G",
        "used_gb": "45G",
        "available_gb": "55G",
        "used_percent": 45.0,
        "status": "ok"
      },
      {
        "mount": "/data",
        "device": "/dev/sdb1",
        "total_gb": "500G",
        "used_gb": "425G",
        "available_gb": "75G",
        "used_percent": 85.0,
        "status": "warning"
      }
    ],
    "services": {
      "systemd_running": 23,
      "systemd_failed": 0
    },
    "security": {
      "mining_detected": false,
      "tmp_executables": 0,
      "failed_logins": 3
    }
  },
  "metadata": {
    "check_version": "1.0",
    "tool_version": "ops-health-check v1.0",
    "check_script": "health-check.sh",
    "thresholds": {
      "disk_warning": 50,
      "disk_critical": 80,
      "memory_warning": 70,
      "memory_critical": 90
    }
  }
}

实际价值：

  • Markdown报告便于运维人员快速了解系统状态
  • JSON数据可被监控系统自动采集和分析
  • 清晰的emoji状态指示，一眼就能看出问题所在
  • 详细的阈值配置，便于追溯和调整

五、总结与展望

5.1 实现成果

本次开发成功构建了一个生产级运维健康检查系统：

✅ 三大核心模块

  • 基础健康检查：涵盖系统资源、服务状态、基础安全
  • 深度安全检查：5大类20+项安全检查
  • Docker监控：容器、镜像、存储全方位监控

✅ 双格式输出

  • Markdown：人工可读，便于快速决策
  • JSON：机器可处理，易于自动化集成

✅ 广泛兼容性

  • bash 3.2+兼容（macOS默认版本）
  • 支持主流Linux发行版（Ubuntu、CentOS、Debian）
  • 适配systemd和SysV init系统

✅ 完整文档

  • SKILL.md：使用指南
  • 设计文档：架构和实现思路
  • 博客文章：实战经验分享

5.2 技术亮点

  1. 模块化设计：三个检查模块独立运行，互不依赖
  2. 统一输出库：封装数据收集和格式化逻辑
  3. 阈值可配置：支持通过环境变量自定义阈值
  4. 兼容性处理：优雅降级，兼容不同版本工具
  5. 清理建议：不仅发现问题，还提供解决建议

5.3 实际应用价值

效率提升：

  • 批量检查10台主机仅需2分钟
  • 自动生成双格式报告，无需手工整理
  • JSON数据可直接导入监控系统

安全增强：

  • 发现并阻止挖矿程序
  • 检测异常登录和未授权访问
  • 及时发现文件系统异常变更

成本节约：

  • 无需部署复杂监控系统
  • 基于现有SSH连接，无需额外代理
  • 轻量级脚本，资源占用极低

5.4 开发体会

通过Claude Code的AI辅助开发，整个过程非常高效：

  1. 快速迭代：从需求到实现不到4小时
  2. 智能提示：Claude主动发现兼容性问题并给出解决方案
  3. 代码质量：生成的代码结构清晰，符合最佳实践
  4. 文档完善：自动生成详细的使用文档和示例

AI辅助开发不仅提高了效率，更重要的是让开发者可以专注于业务逻辑和架构设计，而将具体的编码工作交给AI完成。这种人机协作模式，是未来软件开发的重要趋势。

项目地址：https://github.com/xiejava/ops-health-check

博客地址：http://xiejava.ishareread.com

🤖 本文由Claude Code辅助编写


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 957 | 阅读时长 ≈ 3

通常，网络或系统管理员会使用一个电子表格来记录IP地址的分配信息，然而，随着网络中的设备越来越多依赖于电子表格并不方便，十分容易出错，想管理好这些加入网络中的设备，就得有个更方便的工具。就我家里的网络而言，接入的设备就已经接近40个了，亟需找这么一个工具来记录和管理这些IP，目前找到的比较好用又轻量化的IP管理工具就是phpIPAM。

一、什么是phpIPAM

phpIPAM（PHP IP Address Manager）是一个开源的网络 IP 地址管理工具，其目标是提供轻松，现代和有用的IP地址管理。它是基于php的应用程序，带有MySQL数据库后端，使用jQuery库，ajax和HTML5 / CSS3功能。主要用于企业级 IP 地址空间的规划、管理和跟踪。

为什么要用phpIPAM

问题场景 无 phpIPAM 有 phpIPAM
IP分配冲突 人工记录 Excel，容易重复 系统自动管理，避免冲突
查找可用 IP 手动测试多个 IP 一键查找空闲 IP
网络规划 凭经验划分，不精确 可视化规划，最优利用
故障排查 不知道 IP 使用者 快速定位设备负责人

phpIPAM核心功能如下：
\[图片\]

官网：
https://www.phpipam.net/
https://hub.docker.com/r/phpipam/phpipam-www/

二、安装phpIPAM

安装phpIPAM可以用docker方式快速安装，根据官网的docker-compose.yml稍微做了优化，主要是加了mysql的健康检查，因为在安装的过程中数据库没有就绪或容器启动顺序有问题会导致安装失败。
docker-compose.yml文件内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
version: '3.8'
services:
  phpipam-web:
    image: phpipam/phpipam-www:latest
    ports:
      - "8488:80"
    environment:
      - TZ=Asia/Shanghai
      - IPAM_DATABASE_HOST=phpipam-db
      - IPAM_DATABASE_PASS=12345678
    depends_on:
      - phpipam-db
    restart: unless-stopped

  phpipam-cron:
    image: phpipam/phpipam-cron:latest
    environment:
      - TZ=Asia/Shanghai
      - IPAM_DATABASE_HOST=phpipam-db
      - IPAM_DATABASE_PASS=12345678
      - SCAN_INTERVAL=1h
    depends_on:
      phpipam-db:
        condition: service_healthy
    restart: unless-stopped

  phpipam-db:
    image: mariadb:10.5
    environment:
      - MYSQL_ROOT_PASSWORD=12345678
      - MYSQL_DATABASE=phpipam
      - MYSQL_USER=phpipam
      - MYSQL_PASSWORD=12345678
    volumes:
      - db_data:/var/lib/mysql
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  db_data:

将docker-compose.yml文件考到安装目录如/home/app/phpipam
执行docker compose up -d 就可以顺利安装完成
安装完成后通过 docker compose ps 查看 phpipam的几个容器是否都正常启动了。
docker-compose

可以通过docker compose logs查看日志

三、初始化phpIPAM

因为在docker-compose.yml文件中映射的宿主机的端口是8488
在浏览器中输入 http://服务器IP：8488/
1.选择新的phpipam安装
新的phpipam安装

2.安装pfpipam数据库
安装pfpipam数据库

3.设置数据库
设置数据库

4.提示数据库安装成功
数据库安装成功

5.设置管理员密码
设置管理员密码

6.用前面设置的管理员密码进行登录
用户名密码登录

7.可以在用户的账户详情中选择语言为“Chinese(zh_CN.UTF-8)”切换成中文
设置成中文

四、使用phpIPAM

典型的IP管理流程如下：
IP管理流程

1.添加子网添加子网

2.添加子网信息，注意可以将Check hosts status、Discover new hosts、Resolve DNS name都打开。
添加子网信息

3.在子网管理界面点击“Scan subnet for new hosts” 扫描子网的主机
扫描子网

4.点击“Scan subnet”
phpIPAM就会通过Ping scan的方式探测子网内存活的主机
扫描子网

在子网的管理界面就可以看到子网内存活的IP和空闲的IP
子网管理界面

IP列表
IP列表

子网的可视化界面，可以很直观的看到子网内在用的IP和空闲的IP
子网可视化界面

总的来说，phpIPAM安装简单使用方便，是个不错的IP管理工具。phpIPAM 本质上是一个 “网络的 CMDB”，让无形的 IP 地址变得可视、可控、可管理。对于任何有一定规模网络环境，它都是提升管理效率和规范性的重要工具。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 2.1k | 阅读时长 ≈ 7

一直以来都想把我的文档都集中起来建一套知识库，方便统一的搜索查询和调用。我用过很多的文档编写管理工具有在线的、离线的，包括有有道云笔记、语雀、飞书、Notion、Obsidian等。这些工具编写管理文档还可以但是要做为一个知识库还远远不够。我认为知识库不但要解决“知识存哪里” 的问题，更要解决 “知识怎么用” 的痛点，能够将多源的知识内容进行聚合，方便检索查询和使用。

我需要的知识库系统能够具备以下能力：

  • 多源内容聚合的能力：能够将我的博客网站、飞书、语雀、离线的文档等都能导入到知识库中。
  • 方便快捷的搜索能力：AI辅助搜索，能够随时快速找到我想要的东西，AI辅助问答，能够基于已有的知识快速给出比较靠谱的答案。
  • 便捷强大的编辑能力：能够通过富文本、Markdown随时记录文本，通过AI来辅助创作。

几番比较找到了PandaWiki，这款开源AI大模型驱动的知识库搭建系统，我觉得满足了目前我对知识库的要求，其安装方便、使用便捷、免费开源，零成本就能拥有自己的AI知识库，目前在github上斩获了8.4K的Star说明了受欢迎的程度。

一、什么是PandaWiki

PandaWiki 是一款 AI 大模型驱动的开源知识库搭建系统，帮助你快速构建智能化的 产品文档、技术文档、FAQ、博客系统，借助大模型的力量为你提供 AI 创作、AI 问答、AI 搜索等能力，具备富文本编辑、第三方集成和内容导入能力，采用AGPL-3.0开源协议。

它的核心价值在于将 AI 能力与知识库深度融合，不仅解决了 “知识存哪里” 的问题，更攻克了 “知识怎么用” 的痛点。
PandaWiki
PandaWiki 的功能设计围绕 “智能化” 与 “便捷性” 展开，核心可概括为三大 AI 功能与五大实用特性，覆盖知识库从搭建到使用的全场景需求：

类别 具体功能 价值说明
AI 核心功能 AI 创作 辅助生成、优化文档内容，降低内容生产门槛，提升写作效率
AI 问答 支持用户以自然语言提问，AI 基于知识库内容精准作答，而非返回杂乱链接
AI 搜索 依托 AI 大模型实现语义化搜索，精准匹配用户需求，解决传统关键词搜索的局限性
实用特性 富文本编辑 支持 Markdown 与 HTML 语法，满足不同用户编辑习惯；文档可导出为 Word、PDF、Markdown 格式
多渠道内容导入 支持通过飞书文档、Notion、URL、Sitemap、RSS 及离线文件导入内容，省去重复复制粘贴操作
第三方平台集成 可接入钉钉、飞书、企业微信、Discord 等平台的聊天机器人，实现 “随处查知识”
高度自定义 支持配置 Wiki 网站配色、背景图、水印、页脚（企业名称、ICP 备案、品牌 Logo 等），打造专属风格
数据统计与反馈 管理后台可实时查看 Wiki 网站的访问次数、用户分布、问答记录及反馈信息，便于优化内容

PandaWiki 的最大优势之一是 “低门槛”—— 无需复杂代码开发，提供了一键部署安装脚本，全程耗时不超过 5 分钟，即使是非技术人员也能轻松上手。

二、PandaWiki的安装部署

1、部署前的准备

PandaWiki的官方文档见 https://pandawiki.docs.baizhi.cloud/node/01971602-bb4e-7c90-99df-6d3c38cfd6d5

PandaWiki安装需Linux系统、x86_64架构，依赖Docker 20.10.14+和Docker Compose 2.0.0+，推荐1核2G内存10G磁盘。
安装 PandaWiki 系统环境要求如下：

  • 操作系统：Linux
  • CPU 指令架构：x86_64、aarch64
  • 软件依赖：Docker 20.10.14 版本以上
  • 软件依赖：Docker Compose 2.0.0 版本以上
  • 推荐配置：2 核 CPU / 4 GB 内存 / 20 GB 磁盘
  • 最低配置：1 核 CPU / 2 GB 内存 / 5 GB 磁盘

我的配置是ubuntu系统2核CPU/4GB内存/100GB磁盘。

2、安装PandaWiki

官方提供了一键自动安装命令，可以非常便捷无脑的就把系统给装上。
使用 root 权限登录你的服务器，然后执行以下命令。

1
bash -c "$(curl -fsSLk https://release.baizhi.cloud/panda-wiki/manager.sh)"

安装界面
选择“安装”，回车
安装
系统检测到没有安装docker，输入“y”,系统自动安装docker
自动安装docker

默认安装路径位于 /data/pandawiki
到显示所有容器安装完成并启动就会显示如下信息

1
2
3
4
5
SUCCESS  控制台信息:
SUCCESS    访问地址(内网): https://*.*.*.*:2443
SUCCESS    访问地址(外网): https://*.*.*.*:2443
SUCCESS    用户名: admin
SUCCESS    密码: **********************

修改默认密码

如果需要修改admin的密码可以修改安装目录下.env文件中的 ADMIN_PASSWORD 后，执行

bash docker compose up -d

即可生效。

使用浏览器打开上述内容中的 “访问地址”，就可以看到 PandaWiki 的控制台登录入口。

Panda登录地址

三、PandaWiki的使用

1、配置 AI 大模型

由于 PandaWiki 的 AI 功能（创作、问答、搜索）均依赖 AI 大模型，首次使用需先完成模型配置，否则相关功能无法正常使用。其支持的模型类型及推荐方案如下：

  • Chat 模型：用于对话与内容生成，如 ChatGPT-4、Deepseek-r1、Deepseek-v3 等
  • Embedding 模型：将文档转化为向量，支撑智能搜索与内容关联，如 BGE-M3
  • Reranker 模型：对搜索结果二次排序，提升检索精准度，如 BGE-Reranker-V2-M3

我这里直接使用PandaWiki默认的模型“自动配置”。自动配置需要点击“获取百智云API Key”来获取API Key，注册登录百智云就可以获取5元的免费额度。当然通过手动配置用其他的模型API也可以。
配置大模型

2、启用创建门户网站

启用创建门户网站PandaWiki会自动帮创建一个门户网站，可以自定义门户网站的模板，“启用HTTP”输入暴露的端口80就可以开启门户网站，注意不要和2443端口重了，2443是后台admin的管理服务。
创建门户网站

通过简单的配置就可以生成一个wiki网站，如果有域名就可以通过域名访问了，没有域名就通过IP访问。
我这里配了域名，可以通过wiki.xiejava.dpdns.org访问。
wiki门户网站

3、导入文档到PandaWiki创建知识库

PandaWiki 支持从第三方文档中导入文档，目前支持以下几种方式

  • 通过离线文件导入
  • 通过 URL 导入
  • 通过 RSS 导入
  • 通过 Sitemap 导入
  • 通过 Notion 导入
  • 通过 Epub 导入
  • 通过 MiniDoc 导入
  • 通过 Wiki.js 导入
  • 通过 Confluence 导入
  • 通过飞书文档导入
  • 通过语雀导入
  • 通过思源笔记导入

官方都有详细的说明文档
我这里将我的博客文档通过离线方式进行导入。
离线导入文件

在离线文件导入界面选择要导入的文件，支持的格式包括.txt、.md、.xlx、.xlsx、.docx、.pdf 。
注意：每个文件的大小不能超过 20 MB。
导入文件

选择要导入的文件后，会对.md文件自动进行解析。
解析文件

解析完了点击“批量导入”，就可以将文件导入到知识库，并且展示的是解析后的富文本形式。
批量导入

批量导入处理中
批量导入中

新导入的文件虽然是可以被可见、被访问、被问答，但是还没有进行增强学习处理需要进一步的学习
发布和学习

PandaWiki的文档处理状态如下图：
文档处理状态

选择需要学习的文档点“确认”进行学习
学习和发布

当学习和发布完成后，可以在web门户网站进行AI检索和AI问答了。
AI问答

AI问答

我们可以将pandawiki直接当一个博客网站来使用，它对markdown的解析和展示还挺好的。
pandawiki博客站点

欢迎访问我的wiki站点 https://wiki.xiejava.dpdns.org 在这里我将和你一起分享IT技术，感受AI带来的便捷。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 1.4k | 阅读时长 ≈ 5

一、什么是Harbor

简单来说，Harbor 是一个开源的企业级私有 Docker 镜像仓库服务。我们可以把它理解成一个 “私有的、安全的、功能强大的 Docker Hub”。

  • 私有： 它部署在你自己的基础设施（如公司的数据中心或私有云）上，你完全掌控其中的所有镜像，不对外公开。
  • 企业级： 这意味着它不仅仅是一个简单的存储服务器。它提供了企业所需的高级功能，如权限控制、安全扫描、镜像复制、图形化操作界面等。
  • 镜像仓库： 它是专门用来存储、管理和分发 Docker 镜像的地方。你可以向 Harbor 中推送（上传）镜像，也可以从 Harbor 中拉取（下载）镜像。

目前国内的上网环境公共的Docker Hub不能直接访问了，对于公司和个人开发者来说有必要搭建私有的Docker镜像仓库，使用 Harbor 几乎是必须的。公司自己开发的应用程序镜像可能包含敏感代码和配置，绝不能放到公共仓库。Harbor 提供了一个安全的私有环境来存放这些资产。Harbor 可以配置为 Docker Hub、Google Container Registry（GCR）等公有仓库的代理缓存。当公司内第一个开发者拉取某个公有镜像（如 nginx:latest）时，Harbor 会从公网下载并缓存到本地。后续所有开发者再拉取这个镜像时，都会直接从内网的 Harbor 服务器高速获取，极大地节省了公网带宽，加快了拉取速度。

Harbor 将一个简单的镜像存储服务，升级为一个安全、高效、可靠的企业级镜像生命周期管理平台，是现代云原生应用开发和运维不可或缺的基础设施组件。

本文介绍如何通过Harbor搭建和使用自己的私有镜像仓库。

二、安装Harbor

准备一台linux的服务器，我这里是ubuntu 24.04 IP地址是192.168.0.49
Harbor的docker安装要求
On a Linux host: docker 20.10.10-ce+ and docker-compose 1.18.0+ .

1、安装docker

执行以下命令一键安装docker 

1
2
sudo curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
service docker start

配置国内镜像加速

1
vim /etc/docker/daemon.json
1
2
3
4
5
{
    "registry-mirrors": [
        "https://docker.1ms.run"
    ]
}
1
service docker restart

2、安装Harbor

下载harbor安装包，下载地址如下：
https://github.com/goharbor/harbor/releases/download/v2.14.1/harbor-offline-installer-v2.14.1.tgz
将下载的harbor安装包上传到安装harbor的目标服务器的目录下
如/home/app/harbor
解压上传的harbor安装包

1
tar -zxvf harbor-offline-installer-v2.14.1.tgz

备份配置文件

1
cp harbor.yml.tmpl harbor.yml

修改配置文件

1
vim harbor.yml

修改harbor.yml配置文件

执行安装脚本

1
./install.sh

安装完成后通过浏览器即可以访问harbor的管理界面
harbor登录界面

默认的用户名和密码是admin/Harbor12345

三、使用Harbor

1、通过Harbor代理拉取镜像

先在仓库管理中建一个目标，目标是从docker的加速镜像站点去拉取镜像，我这里配置目标URL是https://docker.1ms.run，点击测试链接，提示“测试连接成功”表示目标URL站点没有问题，就可以点击确定。
新建目标

这样我们就有了一个目标的加速仓库
新建目标成功

在“项目”中点击“新建项目”，在镜像代理中开启“镜像代理”，选择我们开始在仓库管理中新建的目标仓库。
开启镜像代理

在配置管理生成软件物料清单中勾选“在推送镜像时自动生成软件物料清单”，这样我们在拉取镜像时harbor会自动帮我们缓存镜像到本地的harbor仓库，下次拉取时速度就非常快了。
勾选物料清单

在另外一台需要拉取镜像的机器上配置docker的镜像仓库，将地址配置为Harbor的地址

1
vim /etc/docker/daemon.json
1
2
3
4
5
6
{
    "registry-mirrors": [
        "http://192.168.0.49"
    ],
    "insecure-registries": ["192.168.0.49"]
}

重启docker服务

1
service docker restart

拉取目标镜像，这里要带上harbor中的项目名称，docker1ms/nginx:1.22

1
docker pull docker1ms/nginx:1.22

拉取镜像

在harbor的管理界面可以看到，通过拉取镜像，harbor通过代理镜像源对镜像进行了拉取并缓存到harbor仓库，下次拉取速度更快了。
harbor镜像缓存

2、上传镜像到Harbor仓库

另一个在工作中最常用的场景就是将自己的镜像上传到镜像仓库，以便其他人拉取使用。
下面就以在本地已经存在的docker1ms/busybox:latest为例，上传到自己的harbor仓库。
我的harbor仓库的地址是192.168.0.49,上传到默认的library项目中
为镜像打上带仓库地址和项目名的tag

1
docker tag docker1ms/busybox:latest 192.168.0.49/library/busybox:latest

为镜像打标签

客户端登录到harbor

1
docker login 192.168.0.49

输入harbor的用户名和口令进行登录
登录到harbor仓

登录成功后，通过push命令上传镜像到本地harbor仓库

1
docker push 192.168.0.49/library/busybox:latest

push镜像

到harbor管理界面查看push到仓库中的镜像
push到仓库中的镜像

可以看到busybox镜像已经成功push到harbor的library项目中了。
成功push

在Artifacts中可以看到push上来的镜像物料详情，可看到这个busybox镜像的大小是2.1MB
物料清单

我们可以直接拉取harbor中我们刚push上去的镜像
可以看到如果是默认仓库library项目直接可以docker pull 镜像名就可以拉取

1
docker pull busybox:latest

拉取镜像

至此，我们通过安装自己私有的镜像仓库Harbor，实现了docker镜像代理下载和上传自己的镜像到Harbor仓库，覆盖了我们平时工作中的大部分场景。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 742 | 阅读时长 ≈ 3

Wazuh是一个功能强大的开源安全平台，它集成了安全信息与事件管理（SIEM）和扩展检测与响应（XDR）的能力，旨在为本地、虚拟化、容器化及云环境中的工作负载提供统一的威胁预防、检测和响应解决方案。

SQL 注入是一种攻击，在这种攻击中，威胁行为者将恶意代码插入传输到数据库服务器的字符串中进行解析和执行。成功的 SQL 注入攻击可以未经授权访问数据库中包含的机密信息。

我们可以使用 Wazuh 从 Web 服务器日志中检测 SQL 注入攻击，这些日志包含 select、union 和其他常见 SQL 注入模式等模式。本文通过POC来验证wazuh检测SQL注入攻击。

一、环境准备

POC测试环境拓扑如下图所示：

POC测试环境拓扑

主机 说明
安全管理平台wazuh-server
(192.168.0.40)		 All in one安装wazuh，监控wazuh-agent上报的告警信息进行威胁检测
DVWA靶机
（192.168.0.43）		 被监控主机安装wazuh-agent，安装DVWA靶机，模拟被攻击

DVWA靶机安装参考《CentOS7+LAMP+DVWA靶机搭建》
首先安装LAMP环境

1
2
apt update
apt install -y apache2 mariadb-server mariadb-client php php-mysqli php-gd libapache2-mod-php

下载DVWA的软件包
进入到默认的web发布目录

1
2
cd /var/www/html
git clone https://github.com/digininja/DVWA.git

将config/config.inc.php.dist复制成config/config.inc.php并配置环境

1
cp config.inc.php.dist config.inc.php

用root用户登录数据库，然后执行以下命令创建dvwa数据库:

1
2
3
4
5
6
7
8
9
10
11
mysql> create database dvwa;
Query OK, 1 row affected (0.00 sec)

mysql> create user dvwa@localhost identified by 'p@ssw0rd';
Query OK, 0 rows affected (0.01 sec)

mysql> grant all on dvwa.* to dvwa@localhost;
Query OK, 0 rows affected (0.01 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

默认用户 = admin
默认密码 = password
将安全级别设为 Low（最易注入）

二、wazuh配置

将以下行添加到 Wazuh 代理 /var/ossec/etc/ossec.conf 文件中。允许 Wazuh-agent 代理监控 Apache 服务器的访问日志：

1
2
3
4
5
6
<ossec_config>
  <localfile>
    <log_format>apache</log_format>
    <location>/var/log/apache2/access.log</location>
  </localfile>
</ossec_config>

重新启动 Wazuh 代理以使应用配置更改生效：

1
sudo systemctl restart wazuh-agent

三、模拟攻击

访问DVWA的靶机地址http://192.168.0.43/DVWA/login.php
默认用户 = admin
默认密码 = password
登录后找到SQL Injection 输入例如”1' UNION SELECT database(), version()“ 等SQL注入Payload

DVWA-SQL注入

四、效果验证

在wazuh此处的预期结果是规则 ID 为 31164 SQL injection attempt 的告警，但成功的 SQL 注入尝试会生成规则 ID 为 31106 A web attack returned code 200 (success)的告警。

sql注入检测

我们可以点击详情看到具体的SQL注入攻击日志

SQL注入检测日志详情

至此，我们通过POC验证了wazuh检测SQL注入攻击场景。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 1.1k | 阅读时长 ≈ 4

Wazuh是一个功能强大的开源安全平台，它集成了安全信息与事件管理（SIEM）和扩展检测与响应（XDR）的能力，旨在为本地、虚拟化、容器化及云环境中的工作负载提供统一的威胁预防、检测和响应解决方案。

Wazuh命令监控功能在端点上运行命令并监控命令的输出。通过监控命令来检测是否有非法可疑进程。

本文通过POC展示Wazuh如何通过配置来实现对非法可疑进行的检测及时预警威胁攻击行为。

一、环境准备

POC测试环境拓扑如下图所示：
POC测试环境拓扑

主机 描述
安全管理平台wazuh-server
(192.168.0.40)		 All in one安装wazuh，监控wazuh-agent上报的告警信息进行威胁检测
被监控Kali主机
（192.168.0.65）		 被监控kali主机安装wazuh-agent，运行非法可疑进程。

二、wazuh配置

1、kali检测端点配置

1）按照以下步骤配置命令监控并查询被监控kali主机端点上的所有运行进程。
将以下配置块添加到wazuh-agent的/var/ossec/etc/ossec.conf文件，允许wazuh-agent定期获取运行进程列表：

1
2
3
4
5
6
7
8
<ossec_config>
  <localfile>
    <log_format>full_command</log_format>
    <alias>process list</alias>
    <command>ps -e -o pid,uname,command</command>
    <frequency>30</frequency>
  </localfile>
</ossec_config>

这段配置告诉 Wazuh 代理：

  1. 做什么：​ 每 30 秒执行一次命令 ps -e -o pid,uname,command。
  2. 捕获什么：​ 捕获该命令的完整输出。
  3. 如何标记：​ 在输出的每一行前面添加一个标准化的头部 ossec: output: 'process list: '。
  4. 发送给谁：​ 将处理后的日志行（即带有前缀的进程列表）发送给配置的 Wazuh 服务器。

这个配置让 Wazuh 代理定期（每 30 秒）抓取一次完整的系统进程快照，并格式化后发送给服务器，为基于进程行为的入侵检测提供基础数据。

2）重新启动Wazuh代理以使配置生效：

1
sudo systemctl restart wazuh-agent

3）在kali上安装Netcat等工具：

1
sudo apt install ncat nmap -y

2、wazuh server配置

1）将以下规则添加到Wazuh服务器上的 /var/ossec/etc/rules/local_rules.xml 文件中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<group name="ossec,">
  <rule id="100050" level="0">
    <if_sid>530</if_sid>
    <match>^ossec: output: 'process list'</match>
    <description>List of running processes.</description>
    <group>process_monitor,</group>
  </rule>

  <rule id="100051" level="7" ignore="900">
    <if_sid>100050</if_sid>
    <match>nc -l</match>
    <description>netcat listening for incoming connections.</description>
    <group>process_monitor,</group>
  </rule>
</group>

这个配置片段定义了一个监控逻辑，专门用于在系统进程列表中检测监听模式的 netcat(nc -l)，一旦发现就产生高优先级告警。规则 100050 负责捕获进程列表数据，规则 100051 负责在其中搜索特定的威胁指标 (nc -l)。

2）重新启动Wazuh管理器以使配置生效：

1
sudo systemctl restart wazuh-manager

三、模拟攻击

在被监控的Kali主机（192.168.0.65）端点上，运行nc -l 8000 30秒。

netcat​（网络工具中的“瑞士军刀”）的命令，它的核心作用是：​在你的计算机上启动一个临时的 TCP 服务端，监听端口 8000，等待其他计算机连接并与之通信。

监听模式的 netcat常被用作后门、端口监听器或进行未经授权的文件传输，是攻击者建立持久访问或进行横向移动的常见工具。

四、效果验证

我们可以在Wazuh威胁狩猎模块仪表板中可看到检测到kali主机上有netcat 进行正在监听的告警并可视化展示出来。
非法可疑进程检测告警

我们点开告警详情可以看到日志中显示通过ps -e -o pid,uname,command，检测到有nc -l 8000的非法进程在运行，进行了netcat listening for incoming connections.告警输出。
非法可疑进程检测告警详情

至此，我们通过一个完整的POC实例验证了wuzuh对非法可疑进程的检测，能够有效发现潜在的威胁。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 1.1k | 阅读时长 ≈ 4

Wazuh是一个功能强大的开源安全平台，它集成了安全信息与事件管理（SIEM）和扩展检测与响应（XDR）的能力，旨在为本地、虚拟化、容器化及云环境中的工作负载提供统一的威胁预防、检测和响应解决方案。

Wazuh可以与基于网络的入侵检测系统（NIDS）集成，通过监控和分析网络流量来增强威胁检测。Suricata 是一个开源的高性能网络安全监控工具，由开放信息安全基金会（OISF）开发维护。它被广泛用于实时网络流量分析、威胁检测和防护。Suricata 是现代网络安全架构中的重要组件，特别适合需要高性能实时流量分析的场景，是构建深度防御体系的关键工具。

本文通过POC展示如何将Suricata与Wazuh集成，并模拟对目标主机进行端口扫描，通过Suricata监控和分析网络流量进行威胁检测与Wazuh集成后在Wazuh的威胁狩猎中及时预警威胁攻击行为。

一、环境准备

POC环境拓扑如下图所示：
POC环境拓扑图

主机 描述
安全管理平台wazuh-server
(192.168.0.40)		 All in one安装wazuh，监控wazuh-agent、suricata上报的告警信息进行威胁检测
ubuntu应用服务器
（192.168.0.30）		 ubuntu应用服务器安装wazuh-agent并与Suricata集成 ,模拟被攻击的服务器
Kali Linux模拟攻击机器
（192.168.0.65）		 Kali linux ,模拟攻击机器，模拟发起恶意端口扫描攻击

二、安装Suricata

1、安装Suricata

1
2
3
sudo add-apt-repository ppa:oisf/suricata-stable
sudo apt-get update
sudo apt-get install suricata -y

2、下载Suricata的扩展检测规则集

1
2
3
cd /tmp/ && curl -LO https://rules.emergingthreats.net/open/suricata-6.0.8/emerging.rules.tar.gz
sudo tar -xvzf emerging.rules.tar.gz && sudo mkdir /etc/suricata/rules && sudo mv rules/*.rules /etc/suricata/rules/
sudo chmod 777 /etc/suricata/rules/*.rules

3、配置Surcata

在 /etc/suricata/suricata.yaml 文件中修改 Suricata 设置并设置以下变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
HOME_NET: "<UBUNTU_IP>"
EXTERNAL_NET: "any"

default-rule-path: /etc/suricata/rules
rule-files:
- "*.rules"

# Global stats configuration
stats:
enabled: yes

# Linux high speed capture support
af-packet:
  - interface: ens2

接口表示您想要监控的网络接口。将值替换为 Ubuntu 端点的接口名称。

设置为流量检测的网卡

可以通过ifconfig查看Ubuntu的网络接口，例如，我这里是ens2。
查看网络接口

4、重启Suricata服务

1
sudo systemctl restart suricata

三、wazuh与Suricata集成

将以下配置添加到Wazuh代理的/var/ossec/etc/ossec.conf文件中。这允许Wazuh代理读取Suricata日志文件：

1
2
3
4
5
6
<ossec_config>
  <localfile>
    <log_format>json</log_format>
    <location>/var/log/suricata/eve.json</location>
  </localfile>
</ossec_config>

配置wazuh接受suricata数据

重新启动Wazuh代理以使配置生效

1
sudo systemctl restart wazuh-agent

四、模拟攻击

请注意：本文介绍的模拟攻击仅限于自己搭建测试环境进行POC验证。请不要使用这些工具和方法对其它目标主机进行测试，使用这些工具前，务必获得目标系统的明确书面授权，未经授权的测试属违法行为。

端口扫描是渗透测试的第一步，通过端口扫描可以快速发现目标主机的攻击面。使用 nmap进行端口扫描是网络安全中最基础且关键的操作之一。我们在Kali Linux主机上通过nmap对目标靶机192.168.0.30进行端口扫描看开放有哪些端口。

1
nmap -p- -sV -O -A -T4 -Pn -oX full_scan.xml 192.168.0.30

五、效果验证

在Kali Linux主机上通过nmap对目标靶机192.168.0.30进行端口扫描的过程中，我们在192.168.0.40的wazuh server的威胁狩猎界面可以看到suricata通过流量检测识别到端口扫描的攻击行为，并通过wazuh的可视化界面进行告警的展示。

surcata告警

点击可以查看告警的详情，可以看到是通过suricata发现的来自源IP192.168.0.65的nmap扫描行为。

suricata告警详情

至此，我们通过wasuh与网络入侵检测系统（suricata）进行集成，并模拟对目标主机进行端口扫描，验证了通过Suricata监控和分析网络流量进行威胁检测与Wazuh集成后在Wazuh的威胁狩猎中及时预警威胁攻击行为。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 1.5k | 阅读时长 ≈ 5

Wazuh是一个功能强大的开源安全平台，它集成了安全信息与事件管理（SIEM）和扩展检测与响应（XDR）的能力，旨在为本地、虚拟化、容器化及云环境中的工作负载提供统一的威胁预防、检测和响应解决方案。

暴力破解是网络安全领域一种常见且顽固的威胁，像Linux端点的SSH这样的服务通常容易受到暴力破解攻击，攻击者利用它来非法访问端点和服务。有效应对暴力破解需要“侦测”和“防护”双管齐下。Wazuh通过关联多个认证失败事件来识别暴力破解攻击并可以配置主动响应以阻止攻击者的IP地址。

本文通过POC来验证wazuh对暴力破解检测与响应能力

一、环境准备

POC环境如下图所示：

POC拓扑图

主机 描述
安全管理平台wazuh-server
(192.168.0.40)		 All in one安装wazuh，监控wazuh-agent上报的告警信息进行暴力破解检测并联动wazuh-agent进行封堵响应
ubuntu应用服务器
（192.168.0.30）		 ubuntu应用服务器ssh服务，安装wazuh-agent ,模拟被攻击的服务器
Kali Linux模拟攻击机器
（192.168.0.65）		 Kali linux ,模拟攻击机器

二、wazuh 配置

Wazuh使用主动响应模块在受监控端点上运行脚本或可执行文件，对某些触发器采取行动。在本用例中，我们模拟对ubuntu应用服务器端点的SSH暴力破解攻击，并配置主动响应模块以阻止攻击端点的IP地址。目标是防止SSH暴力破解攻击。

Wazuh附带一套用于主动响应的默认脚本。这些脚本位于Linux/Unix端点的/var/ossec/active-response/bin/目录中。firewall-drop主动响应脚本与Linux/Unix操作系统兼容。它使用iptables来阻止恶意IP地址。

Wazuh server配置

1、打开Wazuh服务器/var/ossec/etc/ossec.conf文件，并验证在<ossec_config>块中存在名为firewall-drop的<command>块，其配置如下：

1
2
3
4
5
<command>
  <name>firewall-drop</name>
  <executable>firewall-drop</executable>
  <timeout_allowed>yes</timeout_allowed>
</command>

<command>块包含有关在Wazuh代理上执行的操作的信息：

  • <name>：为命令设置名称。在本例中，为firewall-drop。
  • <executable>：指定在触发时必须运行的响应脚本或可执行文件。在本例中，是firewall-drop可执行文件。
  • <timeout_allowed>：允许在一段时间后超时。在此处，此标签设置为yes，表示状态性主动响应。

2、将以下 <active-response> 块添加到 Wazuh 服务器 /var/ossec/etc/ossec.conf 配置文件中：

1
2
3
4
5
6
7
8
9
<ossec_config>
  <active-response>
    <disabled>no</disabled>
    <command>firewall-drop</command>
    <location>local</location>
    <rules_id>5763</rules_id>
    <timeout>180</timeout>
  </active-response>
</ossec_config>
  • <comand>：指定要配置的命令。这是在上一步骤中定义的防火墙丢弃命令 firewall-drop。
  • <location>：指定命令执行的位置。使用本地值表示命令在触发事件发生的监控端点处执行。
  • <rules_id>：如果规则ID 5763 - SSHD暴力破解尝试访问系统触发，则活动响应模块将执行该命令。
  • <timeout>：指定活动响应操作必须持续的时间。在本用例中，模块将阻止执行暴力破解攻击的端点IP地址180秒。

3、重新启动Wazuh管理器服务以应用更改：

1
sudo systemctl restart wazuh-manager

三、模拟攻击

我们通过Kali Linux自带的Hydra进行模拟攻击。

请注意：本文介绍的模拟攻击仅限于自己搭建测试环境进行POC验证。请不要使用这些工具和方法对其它目标主机进行测试，使用这些工具前，务必获得目标系统的明确书面授权，未经授权的测试属违法行为。

Hydra 配合 SecLists 工具包，可以显著提升密码破解测试的效率和成功率。
SecLists 是一款在安全测试中非常受欢迎的开源集合项目，提供了各种类型的字典列表，包括但不限于用户名、密码、目录路径、子域名等。Hydra 则是一款强大的网络登录破解工具，支持多种协议。将两者结合，可以针对各种网络服务进行高效的密码暴力破解测试。
在 Kali Linux 中，SecLists 通常位于 /usr/share/seclists目录。如果系统未安装，可以使用以下命令安装：

1
sudo apt update && sudo apt install seclists

在Kali Linux（192.168.0.65）上执行hydra 对 192.168.0.30 进行模拟攻击

1
hydra -L /usr/share/seclists/Usernames/top-usernames-shortlist.txt -P /usr/share/seclists/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt 192.168.0.30 ssh -t 4 -vV

四、效果验证

可以看到触发了wazuh的告警规则，在Wazuh仪表板中看到多次的登录失败的告警数据，并生成了试图暴力破解的攻击告警。
告警

在详情中可以清楚的看到多次尝试暴力破解ssh登录
告警详情

可以看到wazuh检测到有ssh暴力破解的行为并自动调用防火墙对攻击IP进行封堵，封堵180秒。
封堵

在Hydra的攻击日志可以看到，被wazuh进行响应封堵后ssh超时报错，说明已经成功阻断阻止了攻击行为。
阻止效果

至此，我们通过一个实际的POC实例验证了wazuh对ssh暴力破解攻击行为的检测和响应，通过“侦测”和“防护”双管齐下能有效减轻ssh暴力破解威胁攻击风险。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 1.1k | 阅读时长 ≈ 4

Wazuh是一个功能强大的开源安全平台，它集成了安全信息与事件管理（SIEM）和扩展检测与响应（XDR）的能力，旨在为本地、虚拟化、容器化及云环境中的工作负载提供统一的威胁预防、检测和响应解决方案。
文件完整性监控（File integrity monitoring FIM）有助于审计敏感文件和满足合规性要求。Wazuh内置了一个FIM模块，用于监控文件系统变化，以检测文件的创建、修改和删除。
本文通过POC来验证Wazuh的FIM功能，使用Wazuh FIM模块来检测Ubuntu和Windows端点上监控目录的变化。Wazuh FIM模块通过使用who-data审计获取有关更改用户和进程的信息来丰富告警数据。

一、环境准备

POC环境如下图所示：
POC环境拓扑图

主机 描述
安全管理平台wazuh-server
(192.168.0.40)		 All in one安装wazuh，监控wazuh-agent上报的告警信息进行文件完整性监控(FIM)
被监控Windows 11机器
(192.168.0.16)		 安装wazuh-agent，通过Wazuh FIM模块在此端点监控一个目录，以检测文件创建、更改和删除。
被监控Ubuntu主机
(192.168.0.41)		 安装wazuh-agent，通过Wazuh FIM模块在此端点监控一个目录，以检测文件创建、更改和删除。

二、wazuh配置

1、window机器安装wazuh并配置

1）安装wazuh-agent

在wazuh的管理端找到部署agent界面，选择window的agent安装包

wazuh部署agent界面

wazuh会自动生成部署agent的脚本

自动生成部署agent的脚本

在window11（192.168.0.16）机器上以管理员权限运行powershell,在powershell中运行agent安装脚本

1
Invoke-WebRequest -Uri https://packages.wazuh.com/4.x/windows/wazuh-agent-4.13.0-1.msi -OutFile $env:tmp\wazuh-agent; msiexec.exe /i $env:tmp\wazuh-agent /q WAZUH_MANAGER='192.168.0.40' WAZUH_AGENT_NAME='Lenovo-L13-agent'

运行agent安装脚本

运行NET START Wazuh启动wazuh-agent，过一会就可以在wazuh服务端的dashboard中看到window 11的wazuh-agent注册上来了。

注册agent

2） 配置window端点的wazuh-agent

按照以下步骤配置Wazuh代理以监控以下目录的文件系统更改。如监控C:\Users\xiejava\Desktop的文件更改。
在受监控的Windows端点上编辑C:\Program Files (x86)\ossec-agent\ossec.conf配置文件。在<syscheck>块内添加监控目录。配置Wazuh监控C:\Users\xiejava\Desktop目录。

1
<directories check_all="yes" report_changes="yes" realtime="yes">C:\Users\xiejava\Desktop</directories>

配置FIM监控

使用具有管理员权限的PowerShell重新启动Wazuh代理以使配置更改生效。

1
Restart-Service -Name wazuh

2、ubuntu主机的wazuh-agent配置

由于ubuntu主机（192.168.0.41）已经安装了wazuh-agent，只需要对wazuh-agent进行配置就可以了。
执行以下步骤以配置Wazuh代理以监控/root目录中的文件系统更改。
编辑Wazuh代理的/var/ossec/etc/ossec.conf配置文件。在<syscheck>块中添加监控的目录。配置Wazuh监控/root目录。

1
<directories check_all="yes" report_changes="yes" realtime="yes">/root</directories>

配置ubuntu端点的FIM监控

重新启动Wazuh代理以使配置生效

1
sudo systemctl restart wazuh-agent

三、效果验证

1、windows端点文件完整性监控

1）文件增、删、改

在window 11(192.168.0.16)的机器的桌面上新建一个.txt文件，然后重命名为test-win11.txt，再修改test-win11.txt的内容。

2）可视化告警监控

在wazuh的dashboard中可以看到window 11机器的完整性监控告警。
win11的FIM告警

在详情中可以看到window11机器c:\users\xiejava\desktop\下文件变更的详情。
win11的FIM告警详情

2、ubuntu主机文件完整性监控

1）文件增、删、改

在ubuntu(192.168.0.41)的机器的/root新建一个test.txt文件，然后重命名为test-ubuntu.txt，再修改test-ubuntu.txt的内容。

2）可视化告警监控

在wazuh的dashboard中可以看到ubuntu(192.168.0.41)主机的文件完整性监控告警。
ubuntu端点的FIM告警事件

在Dashboard中可以看到FIM的统计信息包括对文件的新增、删除、修改等。
ubuntu端点的FIMDashboard

在Events中可以看到文件被修改触发的事件
ubuntu端点的FIM告警列表

可以查看具体的事件详情
ubuntu端点的FIM告警详情

至此，我们通过POC实例来验证了Wazuh的文件完整性监控FIM功能，使用Wazuh FIM模块来检测Ubuntu和Windows端点上监控目录的变化。

作者博客：http://xiejava.ishareread.com/


“fullbug”微信公众号

关注：微信公众号,一起学习成长！

0%