/proc 攻防演义：从 Linux 进程真相到可观测性实战

ls /proc | head -20

ss -ltnp | grep :8080

netstat -ltnp | grep :8080

ls -la /proc/*/fd/* 2>/dev/null | grep socket
# 找到 socket inode
cat /proc/net/tcp | grep "<inode>"
# 反查到 PID

// 例如 /proc/[pid]/status 的读操作
static int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
                           struct pid *pid, struct task_struct *task) {
    struct mm_struct *mm = get_task_mm(task);
    ...
    seq_printf(m, "Name:\t%s\n", task->comm);
    seq_printf(m, "Pid:\t%d\n", pid_nr_ns(pid, ns));
    ...
}

# 1. 攻击者构建一个含恶意 entrypoint 的镜像
#    entrypoint.sh 做了三件事：
#    a) 在容器内的 /dev/null 上做准备工作
#    b) 在 runc 执行 maskedPaths 挂载前，把 /dev/null 替换成符号链接
#       指向宿主 /proc/sys/kernel/core_pattern
#    c) 等待 runc 完成 bind-mount

# 2. runc 执行 bind-mount 时：
#    它认为自己在挂载 /dev/null（写保护）
#    实际上挂的是宿主 /proc/sys/kernel/core_pattern（读写）

# 3. 攻击者在容器内写入 core_pattern：
echo "|/proc/self/exe" > /proc/sys/kernel/core_pattern
#    core_pattern 写成 "|程序路径" 时，内核执行该程序以 root 身份处理 core dump
#    攻击者让自己的进程 crash，内核以 root 身份执行恶意程序
#    → 容器逃逸成功，宿主机 root

# 攻击者拿到初始访问后：
1. 修改 iptables 规则，把端口 22/80/443 之外的所有出站流量 DROP
2. 修改 /etc/ld.so.preload 加载恶意库，hook 掉 ss/netstat/lsof
3. 把 ss/netstat/lsof 替换成只显示白名单连接的版本
4. 通过 /proc/net/tcp 直接连出（绕过 ss 的 hook）

# 防御侧永远要交叉验证
ss -tnp     # 看到连接 A
cat /proc/net/tcp  # 看到连接 B（ss 漏的）

# 30 秒环境评估
uname -a                              # 内核版本（决定有哪些 CVE 可用）
cat /proc/cpuinfo | grep -c "^processor"  # CPU 核数（决定挖矿收益）
cat /proc/meminfo | head -3           # 内存总量
df -h                                 # 磁盘（决定能不能塞大文件）
cat /proc/net/route                   # 网络（有没有内网）
cat /proc/1/cgroup                    # 是否在容器内
cat /etc/os-release                   # 发行版（决定怎么提权）

# 1. 内核版本（决定可利用 CVE）
cat /proc/version
# 典型输出：Linux version 5.15.0-91-generic (buildd@lcy02-amd64-010) ...

# 2. CPU 信息（决定挖矿程序选型与多线程加速）
cat /proc/cpuinfo | head -25
# 关键字段：model name、cpu MHz、cache size、flags（包括 vmx/svm 决定能不能跑虚拟机）

# 3. 内存（决定挖矿和 DoS 门槛）
cat /proc/meminfo | head -5
# 关键字段：MemTotal、MemAvailable、SwapTotal

# 4. 启动时长（判断机器是新部署还是生产老机器）
cat /proc/uptime
# 输出：12345.67 6789.01（运行秒数 + 空闲秒数）

# 5. 平均负载（判断机器是否空闲，是否适合长期潜伏）
cat /proc/loadavg
# 输出：0.12 0.34 0.56 1/234 5678

# 6. 网络路由（决定有没有内网可扫）
cat /proc/net/route
# 输出表格式：Iface | Destination | Gateway | Flags | RefCnt | Use | Metric | MTU | Window | IRTT

# 7. 是否在容器内（决定攻击路径是不是只到容器边界）
cat /proc/1/cgroup
# 容器内会有 12:devices:/docker/<id> 或 0::/kubepods/... 这种路径

# 检查是否有 config.gz
ls /proc/config.gz 2>/dev/null
zcat /proc/config.gz | grep -E "CONFIG_(SECCOMP|LSM|YAMA|USERLANDER)"
# 关键输出：
# CONFIG_SECCOMP=y
# CONFIG_SECURITY=y
# CONFIG_SECURITY_APPARMOR=y
# CONFIG_SEC_YAMA=y
# CONFIG_USER_NS=y

# 我们需要知道暴露面有多大
zcat /proc/config.gz | grep -E "CONFIG_(KASLR|HARDENED|STATIC_USERMODEHELPER|RANDOMIZE)"
# 输出：
# CONFIG_RANDOMIZE_BASE=y    # KASLR
# CONFIG_STATIC_USERMODEHELPER=y  # 内核调用 usermodehelper 的限制

# 当前加载的内核模块
cat /proc/modules
# 输出格式：模块名 大小 引用计数 依赖列表 [状态] 地址

# 用 modinfo 可以看每个模块的描述（但需要 root）
lsmod

# 在 ps/top 之外，用 /proc 直接抓进程
for pid in /proc/[0-9]*; do
  pid_num=$(basename $pid)
  echo "=== PID $pid_num ==="
  echo "  cmdline: $(tr '\0' ' ' < $pid/cmdline)"
  echo "  comm:    $(cat $pid/comm)"
  echo "  exe:     $(readlink $pid/exe)"
  echo "  cwd:     $(readlink $pid/cwd)"
  echo "  user:    $(grep Uid $pid/status | awk '{print $2}')"
done

# 嗅探某进程的环境变量
cat /proc/$(pidof mysqld)/environ | tr '\0' '\n'
# 典型输出：
# PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
# MYSQL_ROOT_PASSWORD=ProductionP@ssw0rd
# AWS_ACCESS_KEY_ID=AKIA...
# AWS_SECRET_ACCESS_KEY=wJalr...
# DATABASE_URL=postgres://admin:secret@db.internal:5432/app

# 一键找出所有含 "key/token/secret/password" 的环境变量
for pid in /proc/[0-9]*; do
  if [ -r $pid/environ ]; then
    matches=$(cat $pid/environ 2>/dev/null | tr '\0' '\n' | grep -iE "(KEY|TOKEN|SECRET|PASSWORD|CRED)")
    if [ -n "$matches" ]; then
      echo "PID $(basename $pid): $matches"
    fi
  fi
done
# 这条命令一发，能跑出全机的明文凭证清单

# 1. 用 hidepid 限制其他用户读 /proc/[pid]/environ
mount -o remount,hidepid=2 /proc
# 隐藏 PID 后，普通用户看不到其他 PID 的目录

# 2. 让服务进程用专用低权限用户运行（让 environ 只能被该用户读）
# 例如 systemd 的 DynamicUser=yes 或 User=mysql

# 3. 用 secret manager 替代环境变量（HashiCorp Vault、AWS Secrets Manager）
#    让进程在启动时拉密钥，而不是通过环境变量注入

cat /proc/$(pidof nginx)/maps | head -20
# 输出样例：
# 00400000-00401000 r-xp 00000000 fd:01 12345  /usr/sbin/nginx
# 00600000-00601000 r---p 00000000 fd:01 12345  /usr/sbin/nginx
# 00601000-00602000 rw-p 00001000 fd:01 12345  /usr/sbin/nginx
# 7f1234000000-7f1234200000 r-xp 00000000 fd:01 67890  /usr/lib/x86_64-linux-gnu/libssl.so.3
# 7fffabcd0000-7fffabcdf000 rw-p 00000000 00:00 0   [stack]
# ...

# 用 gcore 完整 dump（最常用工具）
gcore $(pidof mysqld)
# 生成 core.<pid> 文件，里面有进程的全部内存

# 手动版本：从 maps 提取所有可读段，然后 lseek+read
gdb -p $(pidof mysqld) -batch -ex "dump memory /tmp/mysql.mem 0x400000 0x401000"
# 注意：dump memory 是 gdb 的内存 dump 命令

# 写内存（需要 ptrace 权限，或与目标进程同 uid）
# 简化示例：往进程的代码段注入 shellcode
gdb -p $(pidof victim) -batch -ex "set *(unsigned char*)0x400000 = 0x90"  # NOP 滑板

# 实际攻击中，攻击者会：
# 1. 关闭 ASLR（如果可能）
# 2. 在堆上分配 RWX 内存
# 3. 写入 shellcode
# 4. 改函数指针（GOT/PLT）指向 shellcode

# 1. kernel.yama.ptrace_scope：限制 ptrace 范围
echo 1 > /proc/sys/kernel/yama/ptrace_scope
# 0 - classic（任何同 uid 进程都可 attach）
# 1 - restricted（仅父子进程）
# 2 - admin only（仅 CAP_SYS_PTRACE）
# 3 - no ptrace（完全禁用）

# 2. 内存 dump 限制（仅 root 可执行）
# 默认就是 root only，普通用户即使能读 /proc/[pid]/maps 也无法 mem read

# 3. 内核硬化的开关
cat /proc/sys/kernel/randomize_va_space  # 2 = 完整 ASLR
cat /proc/sys/kernel/kptr_restrict       # 2 = 隐藏内核符号
cat /proc/sys/kernel/dmesg_restrict      # 1 = 仅 root 可读 dmesg

# 1. 当前所有 TCP 连接（v4）
cat /proc/net/tcp
# 字段：sl | local_address | rem_address | st | tx_queue | rx_queue | ...
# st = 01 = ESTABLISHED
# local_address 和 rem_address 是 hex-encoded:port

# 2. 当前所有 TCP 连接（v6）
cat /proc/net/tcp6

# 3. UDP socket
cat /proc/net/udp

# 4. ARP 表（内网拓扑）
cat /proc/net/arp

# 5. 路由表
cat /proc/net/route

# 6. 设备统计
cat /proc/net/dev

# 攻击者手动从 /proc/net/tcp 还原连接列表
awk '$4 == "01" { 
  split($2, local, ":")
  split($3, rem, ":")
  # 本地地址解码
  l_ip = local[1]
  l_port = strtonum("0x" local[2])
  # 远端地址解码
  r_ip = rem[1]
  r_port = strtonum("0x" rem[2])
  printf "%s:%d -> %s:%d\n", l_ip, l_port, r_ip, r_port
}' /proc/net/tcp
# 输出：5D9CXXXX:01BB -> 3E92XXXX:01BB（建立中的可疑连接）

# 1. 从 /proc/net/tcp 拿到 inode
inode=$(awk '$4 == "01" && /:01BB$/ {print $10}' /proc/net/tcp)

# 2. 在 /proc/*/fd/* 下找指向这个 inode 的符号链接
for pid in /proc/[0-9]*; do
  ls -la $pid/fd/ 2>/dev/null | grep -E "socket:\[$inode\]"
done
# 输出：lrwx... socket:[1234567]
# 即某个 PID 的 fd 4 是这个 socket

# 3. 确认 PID
grep -l "PPid:" /proc/*/status | head
# 然后看 cmdline 确认进程

# /proc/net/sockstat - 各协议的 socket 计数
cat /proc/net/sockstat
# TCP: inuse 23 orphan 0 tw 0 alloc 28 mem 4
# UDP: inuse 5 ...

# /proc/net/snmp - SNMP 统计
cat /proc/net/snmp | grep -E "Tcp:" -A 30
# 包含所有 TCP 状态机的计数器

# /proc/net/netstat - 详细网络统计
cat /proc/net/netstat | grep -E "Tcp:" -A 30

# /proc/net/rpc - RPC 状态（NFS 经常暴露）

# /proc/net/ip_conntrack（如果启用） - 连接跟踪表
cat /proc/net/ip_conntrack | head

# 永远交叉验证
ss -tnp 2>/dev/null        # 用户态视角
cat /proc/net/tcp | wc -l   # 内核视角
# 两者差距太大 → 怀疑 ss 被 hook

# 攻击者的进化路径：
# v1.0 - hook getdents（被 ps 工具绕过）
# v2.0 - hook 整个 procfs 的 readdir（被 /proc/[pid]/maps 暴露）
# v3.0 - 不创建 PID（运行在内核线程，嫁接到现有进程）
# v4.0 - 用 eBPF hook 系统调用（连审计都看不到）

# 防御侧的"金标准"检查
ls -la /proc/*/fd/ 2>/dev/null | grep socket | sort -u
# 这条命令的"反隐身"价值：
# - 即使 ps 被 hook，fd 是进程内核结构里直接管理的
# - 即使 rootkit 不创建 PID，它嫁接的宿主进程 fd 一定会异常

# 攻击者用它做什么
grep "commit_creds\|prepare_kernel_cred" /proc/kallsyms
# 找到 root 提权函数的位置

# 防御者用它做什么
grep -E "^[0-9a-f]+ [tT] " /proc/kallsyms | wc -l
# 数量变化 = 内核模块加载/卸载的迹象

# 限制内核符号暴露
echo 2 > /proc/sys/kernel/kptr_restrict
# 0 - 默认，所有人都能读
# 1 - 仅 root（kptr_restrict=1） → %s 地址格式化为 0
# 2 - 永远隐藏

# 查看内核日志（默认需要 root 或 CAP_SYSLOG）
cat /proc/kmsg
# 或 dmesg

# 攻击者用它做什么
# 看自己加载的 LKM 是否有 warning
# 看自己的 syscall hook 是否有 stack trace 泄露

# 防御者用它做什么
# 看任何异常事件（kernel oops、segfault、TCP reset 等）
# 检测异常加载的内核模块

echo 1 > /proc/sys/kernel/dmesg_restrict
# 限制普通用户读 dmesg

# 在容器内执行
ls /proc/1/root/
# 如果 /proc 没有 hidepid，理论上能看到宿主机的根文件系统！

# 查看当前 namespace
ls -la /proc/$$/ns/
# 输出：lrwxrwxrwx ... cgroup -> cgroup:[4026531835]
#       lrwxrwxrwx ... ipc -> ipc:[4026531839]
#       ...
# 每种 namespace 都有自己的 inode（namespace inode）

# 在容器内，/proc/self 指向容器自己的 PID
# 但如果 /proc 没有正确隔离，/proc/1 可能指向宿主机 PID 1

# 检测自己是否在容器内
cat /proc/1/cgroup
cat /proc/1/sched
# sched 文件包含 cgroup 路径，能精确定位

# 1. 容器启动时使用 hidepid
mount -t proc proc /proc -o nosuid,nodev,noexec,relatime,hidepid=2
# hidepid=2 → 其他用户的 PID 不可见
# hidepid=1 → 其他 PID 可见，但 environ/cmdline 不可读

# 2. 容器内禁止访问宿主机 /proc
# 在 K8s 中通过 PodSpec 设置：
#   securityContext:
#     allowPrivilegeEscalation: false
#     capabilities:
#       drop: ["ALL"]

# 3. 检测 namespace 边界
cat /proc/self/status | grep -E "^(NSpid|NStgid|CapEff)"
# NSpid 多个值 = 在多层 namespace 中

mount | grep " /proc "
# 典型输出：
# proc on /proc type proc (rw,nosuid,nodev,noexec,relatime)

mount -o remount,hidepid=2 /proc
# 验证
ls -la /proc | head -20
# → 只能看到自己的 PID 和内核线程

# ❌ 错误的“一行式”写法：ro 选项会被静默忽略
mount --bind,ro /proc /mnt/proc_ro

# ✅ 正确的两步式写法
mount --bind /proc /mnt/proc_ro
mount -o remount,ro /mnt/proc_ro
# 第一步创建镜像入口，第二步单独 remount 才生效

# 在容器内，把 /proc 拆成多个 mount point
mount -t proc proc /proc -o nosuid,nodev,noexec,relatime,hidepid=2

# 然后再覆盖敏感路径为只读
mount --bind /proc/sys /proc/sys
mount -o remount,ro,bind /proc/sys

mount --bind /proc/sysrq-trigger /proc/sysrq-trigger
mount -o remount,ro,bind /proc/sysrq-trigger

mount --bind /proc/sys/kernel/core_pattern /proc/sys/kernel/core_pattern
mount -o remount,ro,bind /proc/sys/kernel/core_pattern

# 在 K8s PodSpec 里启用 pid namespace
apiVersion: v1
kind: Pod
metadata:
  name: secured-pod
spec:
  securityContext:
    hostPID: false    # 关键！禁止共享宿主 PID namespace
  containers:
  - name: app
    image: myapp
    securityContext:
      allowPrivilegeEscalation: false
      capabilities:
        drop: ["ALL"]

# 来自 runc 的 spec.go
/proc/asound
/proc/acpi
/proc/kcore
/proc/keys
/proc/latency_stats
/proc/timer_list
/proc/timer_stats
/proc/sched_debug
/proc/sysrq-trigger
/proc/mag
/sys/firmware

# 1. 修改 systemd 的 /proc 挂载参数
#    文件路径一般是：/etc/systemd/system/proc-fs-namespace.service 或
#    或者在 /etc/fstab 里写一行：
proc /proc proc defaults,nosuid,nodev,noexec,hidepid=2 0 0

# 2. 重启后验证
mount | grep " /proc "
# 应该看到 hidepid=2

# 3. 不要手动 remount（重启会丢）

#!/bin/bash
# /usr/local/bin/proc_exposure_audit.sh
# 审计当前机器 /proc 的暴露面配置

echo "=== 当前 /proc 挂载配置 ==="
mount | grep " /proc "
echo ""

echo "=== hidepid 是否启用 ==="
mount | grep " /proc " | grep -oE "hidepid=[0-9]" || echo "❌ 未启用 hidepid"
echo ""

echo "=== 检查 hostPID（容器场景） ==="
if [ -f /.dockerenv ]; then
  echo "在 Docker 容器内，检查 hostPID"
  cat /proc/1/status | grep -E "^(NSpid|Pid)" | head -5
fi
echo ""

echo "=== 危险文件是否可写 ==="
for f in /proc/sys/kernel/core_pattern /proc/sysrq-trigger /proc/sys/kernel/modprobe; do
  if [ -w "$f" ]; then
    echo "⚠️  $f 可写"
  else
    echo "✅ $f 只读"
  fi
done
echo ""

echo "=== 普通用户能看到的进程数 ==="
su - nobody -s /bin/bash -c "ls /proc/[0-9]* 2>/dev/null | wc -l"
echo ""

echo "=== /proc/net 是否对普通用户可读 ==="
su - nobody -s /bin/bash -c "cat /proc/net/tcp | wc -l"

# 第 1 周：只启用 hidepid=1
mount -o remount,hidepid=1 /proc
# 等所有监控告警系统适配

# 第 2 周：升级到 hidepid=2
mount -o remount,hidepid=2 /proc

# 第 3 周：加固 maskedPaths（升级 runc 或手工 mount bind）

# 第 4 周：增加 read-only bind mount（针对 core_pattern 等）

# 用 stat 看每个文件的权限
for f in cmdline environ status maps fd exe cwd; do
  pid=$$
  ls -la /proc/$pid/$f 2>/dev/null
done
# 典型输出：
# -r-------- 1 axu axu 0 ... cmdline       # 仅本人可读
# -r-------- 1 axu axu 0 ... environ       # 仅本人可读
# -r--r--r-- 1 axu axu 0 ... status        # 所有人可读
# -r--r--r-- 1 axu axu 0 ... maps          # 所有人可读（受 ptrace 限制）
# dr-x------ 2 axu axu 0 ... fd/           # 仅本人可读
# lrwxrwxrwx 1 axu axu 0 ... exe           # 所有人可读
# lrwxrwxrwx 1 axu axu 0 ... cwd           # 所有人可读

# 查看当前进程的 capability 集合
cat /proc/self/status | grep ^Cap
# CapInh: 0000000000000000
# CapPrm: 0000000000000000
# CapEff: 0000000000000000
# CapBnd: 000001ffffffffff
# CapAmb: 0000000000000000

# K8s PodSpec
securityContext:
  capabilities:
    drop: ["ALL"]
    add: ["NET_BIND_SERVICE"]  # 仅 web 服务需要的

# /etc/apparmor.d/local/nginx
#include <tunables/global>

profile nginx-restricted flags=(attach_disconnected,mediate_deleted) {
  #include <abstractions/base>
  #include <abstractions/nameservice>

  # 允许读 /proc/self/status（监控用）
  /proc/self/status r,
  # 允许读 /proc/loadavg
  /proc/loadavg r,
  /proc/meminfo r,
  /proc/stat r,

  # 关键：禁止读其他进程的 /proc/[pid]/*
  deny /proc/[0-9]*/environ r,
  deny /proc/[0-9]*/cmdline r,
  deny /proc/[0-9]*/maps r,
  deny /proc/[0-9]*/mem rw,
  deny /proc/[0-9]*/fd/* r,

  # 关键：禁止写 /proc/sys/*
  deny /proc/sys/** w,
  deny /proc/sysrq-trigger w,
  deny /proc/sys/kernel/core_pattern w,
}

# 禁止 httpd_t 域写 proc sysctl
allow httpd_t proc_t : file { read getattr };
deny  httpd_t sysctl_t : file { write create setattr };

// seccomp 规则示例（用 libseccomp）
#include <seccomp.h>

scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_ALLOW);

// 禁止 openat 调用打开其他进程的 mem
seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EACCES),
    SCMP_SYS(openat), 1,
    SCMP_CSTR(2));  // 第二个参数：路径

// 禁止 ptrace
seccomp_rule_add(ctx, SCMP_ACT_KILL_PROCESS,
    SCMP_SYS(ptrace), 0);

// 禁止 process_vm_readv（跨进程内存读）
seccomp_rule_add(ctx, SCMP_ACT_KILL_PROCESS,
    SCMP_SYS(process_vm_readv), 0);

// 加载
seccomp_load(ctx);

# 查看当前值
cat /proc/sys/kernel/yama/ptrace_scope
# 默认是 0（宽松）→ 1（限制）→ 2（仅 root）→ 3（完全禁用）

# 推荐：1 或 2
echo 1 > /proc/sys/kernel/yama/ptrace_scope

# 1. 隐藏内核符号（攻击者用它定位提权函数）
echo 2 > /proc/sys/kernel/kptr_restrict
# 0 - 所有人都能读（默认）
# 1 - root 才能读
# 2 - 永远隐藏

# 2. 限制 dmesg（隐藏内核日志）
echo 1 > /proc/sys/kernel/dmesg_restrict
# 0 - 所有人都能读
# 1 - 仅 root / CAP_SYSLOG

# 3. 限制 usermodehelper（防止内核调用任意用户态程序）
echo 1 > /proc/sys/kernel/usermodehelper/
# 这个值控制 modprobe 等行为，是 CVE-2025-31133 的一类缓解

# 4. BPF 限制（防止非特权用户用 BPF）
echo 1 > /proc/sys/kernel/unprivileged_bpf_disabled
# 0 - 允许（默认）
# 1 - 仅特权用户
# 2 - 永远禁止

# 5. kexec 限制
echo 1 > /proc/sys/kernel/kexec_load_disabled

# 6. 限制 SysRq（防止攻击者触发系统级动作）
echo 0 > /proc/sys/kernel/sysrq
# 0 - 完全禁用 SysRq（对应 1.3.1 节的 sysrq-trigger 路径）

# 错误的做法：deny 黑名单
deny /proc/[0-9]*/environ r,
# 问题：攻击者用其他文件绕过（maps + status + stat）

# 正确的做法：deny 全部，allow 白名单
deny /proc/[0-9]*/** rw,
allow /proc/self/status r,
allow /proc/loadavg r,

#!/bin/bash
# /usr/local/bin/proc_access_hardening.sh
# /proc 访问控制一键加固

set -euo pipefail

echo "=== 启用 hidepid ==="
mount -o remount,hidepid=2 /proc

echo "=== 设置 ptrace_scope ==="
echo 1 > /proc/sys/kernel/yama/ptrace_scope

echo "=== 隐藏内核符号 ==="
echo 2 > /proc/sys/kernel/kptr_restrict

echo "=== 限制 dmesg ==="
echo 1 > /proc/sys/kernel/dmesg_restrict

echo "=== 限制 usermodehelper ==="
echo 1 > /proc/sys/kernel/usermodehelper/bset
echo 1 > /proc/sys/kernel/usermodehelper/inheritable

echo "=== 禁用 BPF（普通用户） ==="
echo 1 > /proc/sys/kernel/unprivileged_bpf_disabled

echo "=== 禁用 SysRq ==="
echo 0 > /proc/sys/kernel/sysrq

echo "=== 验证 ==="
mount | grep " /proc "
echo ""

echo "加固完成。建议："
echo "1. 重启前先保持另一个 SSH 会话，验证仍能登录"
echo "2. 业务进程如果使用 strace/gdb，需要单独适配"
echo "3. 监控告警系统可能需要重新适配（hidepid 隐藏了 PID）"

# /etc/apparmor.d/local/myapp-restricted
#include <tunables/global>

profile myapp-restricted flags=(attach_disconnected,mediate_deleted) {
  #include <abstractions/base>
  #include <abstractions/nameservice>

  # 自身 /proc 只读
  /proc/self/status r,
  /proc/self/comm r,
  /proc/self/loginuid r,
  /proc/self/oom_score r,
  /proc/self/cgroup r,

  # 全局只读信号
  /proc/loadavg r,
  /proc/meminfo r,
  /proc/stat r,
  /proc/uptime r,
  /proc/version r,
  /proc/filesystems r,
  /proc/sys/kernel/random/uuid r,    # libuuid 使用

  # 关键：禁止读其他进程的 /proc/[pid]/*
  deny /proc/[0-9]*/** rw,
  deny /proc/[0-9]*/environ r,
  deny /proc/[0-9]*/cmdline r,
  deny /proc/[0-9]*/maps r,
  deny /proc/[0-9]*/mem rw,
  deny /proc/[0-9]*/fd/ r,

  # 禁止写 /proc/sys/**（对应 3.1.5 的防御目标）
  deny /proc/sys/** w,
  deny /proc/sysrq-trigger w,
  deny /proc/sys/kernel/core_pattern w,
  deny /proc/sys/kernel/modprobe w,
  deny /proc/sys/kernel/hotplug w,

  # 禁止 mount/umount（rootkit 常用）
  deny capability sys_admin,

  # 禁止 ptrace 与 process_vm_*（对应 2.3 节内存注入）
  deny capability sys_ptrace,
  deny ptrace,
  deny ptrace_peer,
  deny signal,

  # 业务需要的能力（仅举几个例）
  capability net_bind_service,
  capability dac_read_search,    # 如果需要读 protected config
  capability sys_resource,      # 调整 rlimit
}

# 禁止 httpd 读其他进程的 /proc
allow httpd_t proc_t:dir { getattr search };
deny  httpd_t proc_t:file { read };

# 禁止写 /proc/sys
deny  httpd_t sysctl_t:file { write create setattr };

# 禁止 ptrace
deny  httpu_t process:ptrace;

// BPF LSM 示例：拒绝打开非自身进程的 mem
SEC("lsm/file_open")
int BPF_PROG(restrict_mem_open, struct file *file) {
    struct task_struct *task = bpf_get_current_task();
    // 获取当前进程的 PID
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    // 从 file 获取 inode，检查是否在 /proc/[pid]/mem
    // 如果不是当前 PID 的 mem → 拒绝
    // ...
    return -EPERM;
}

// 简化的 default profile 逻辑
{
    Name:   "ptrace",
    Action: SECCOMP_ACT_ERRNO,  // 拒绝所有 ptrace
},
{
    Name:   "process_vm_readv",
    Action: SECCOMP_ACT_ERRNO,  // 拒绝跨进程内存读
},
{
    Name:   "kexec_load",
    Action: SECCOMP_ACT_ERRNO,
},
{
    Name:   "mount",
    Action: SECCOMP_ACT_ERRNO,  // 容器不能 mount（除非明确允许）
},
{
    Name:   "umount2",
    Action: SECCOMP_ACT_ERRNO,
},
{
    Name:   "clone",
    Args: []argument{
        {
            Index: 0,
            Op:    SECCOMP_ARG_MASK,
            UMask: ^uint64(CLONE_NEWNS|CLONE_NEWUSER|CLONE_NEWPID),
            // 仅允许标准 fork，不允许创建新 namespace
        },
    },
    Action: SECCOMP_ACT_ALLOW,
},

# K8s PodSpec
securityContext:
  seccompProfile:
    type: RuntimeDefault

// landlock 示例：限制进程只能读 /proc/self
#include <linux/landlock.h>

struct landlock_path_beneath_attr attr = {
    .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE,
    .parent_fd = open("/proc/self", O_PATH),
};

int ruleset_fd = landlock_create_ruleset(NULL, 0, LANDLOCK_CTL_FLAGS_NONE);
landlock_add_rule(ruleset_fd, LANDLOCK_KEY_PATH_BENEATH, &attr, sizeof(attr));
landlock_restrict_self(ruleset_fd, LANDLOCK_CTL_FLAGS_NONE);

# 第 1 周：AppArmor enforce 模式（以“违规即拒绝”为主）
aa-enforce /etc/apparmor.d/local/myapp-restricted

# 第 2 周：启用 RuntimeDefault seccomp（K8s 集群级）
kubectl label namespace my-namespace pod-security.kubernetes.io/enforce=restricted

# 第 3 周：上 BPF LSM（需要内核支持）
bpftool prog loadall /usr/share/bpf/restrict-mem.bpf.o /sys/fs/bpf/

# 第 4 周：上 landlock（仅对个别高安全要求服务）

# 默认隐藏所有符号
echo 2 > /proc/sys/kernel/kptr_restrict
# 0 - 默认，所有人都能读
# 1 - 仅 root 能读
# 2 - 永远隐藏（%s 格式化为 0）

# 验证
cat /proc/kallsyms | head -5
# 0x0000000000000000 T startup_64
# 0x0000000000000000 T secondary_startup_64
# 所有地址都是 0 → 攻击者拿不到函数地址

# 如果攻击者拿到 root，可以一键恢复符号可见
echo 0 > /proc/sys/kernel/kptr_restrict
# 然后继续读 /proc/kallsyms

# 限制 /proc/sys 的写权限（root 也需要过能力检查）
# /etc/fstab 加一行
proc /proc/sys proc nosuid,nodev,noexec,remount,hidepid=2 0 0
# 或者用 mount propagation（3.5.4 节详述）

# 查看当前加载的模块
cat /proc/modules
# 输出格式：模块名 大小 引用计数 依赖列表 [状态] 地址

# 可疑模块检测（手工方法）
awk '{print $1}' /proc/modules | while read mod; do
  # 检查模块是否在合法列表中
  if ! grep -q "^$mod$" /etc/allowed-kernel-modules.txt; then
    echo "⚠️  可疑模块: $mod"
  fi
done

# 启用模块签名验证
echo 1 > /proc/sys/kernel/modules_disabled
# 启用后，只有签名过的模块才能被加载

# 验证当前状态
cat /proc/sys/kernel/modules_disabled
# 1 = 完全禁用模块加载
# -1 = 不可逆禁用

# 启用 IMA 度量
echo "ima" > /sys/kernel/security/lsm

# 配置度量规则（/etc/ima/ima-policy）
measure func=BPRM_CHECK mask=MAY_EXEC
measure func=FILE_CHECK mask=MAY_READ
# ↑ 度量所有被执行的二进制和被读取的关键文件

# 查看度量结果
cat /sys/kernel/security/integrity/ima/ascii_runtime_measurements
# 输出示例：
# 10 ... ima-ng sha256:abc... /usr/sbin/sshd
# 10 ... ima-ng sha256:def... /etc/ssh/sshd_config

# 检查进程 maps 是否包含“看起来不像”的内存段
cat /proc/$$/maps | awk '$5 == "---p" {print}' | head
# ---p 00000000 00:00 0
# 这种全零地址 + anonymous private 是常见的注入点

# 1. 启用 ASLR（默认开了）
cat /proc/sys/kernel/randomize_va_space
# 2 = 完整 ASLR（推荐）

# 2. 限制非特权用户执行无主内存页（防止堆栈注入）
echo 2 > /proc/sys/vm/mmap_min_addr
# 0 = 允许映射任何地址（危险）
# 65536 = 推荐起点（64KB）

# 把 /proc/net/tcp 设为 immutable（chattr +i）
chattr +i /proc/net/tcp
# ❌ 这条命令不成立——procfs 文件不能用 chattr

# 正确的做法：用 eBPF 持续监控 /proc/net/tcp 的访问
# 检测“是否有进程读 /proc/net/tcp 但实际并没有真实的 netstat 调用”

# 1. dm-verity 给 rootfs 提供块级完整性
#    /etc/dm-verity.conf 配置每个块的哈希
#    内核启动时验证所有块是否匹配

# 2. read-only rootfs
mount -o remount,ro /
# 整个 rootfs 不可写，攻击者替换任何文件都会失败

# 3. 只读挂载 /proc
mount -o remount,ro,bind /proc/sys
# 节详述过这个二阶段 mount

# 第 1 个月：启用 ASLR（默认在）+ mmap_min_addr
echo 2 > /proc/sys/kernel/randomize_va_space
echo 65536 > /proc/sys/vm/mmap_min_addr

# 第 2 个月：启用 IMA 度量 + 验证
# （在测试环境验证 30 天后再上生产）

# 第 3 个月：dm-verity（仅新机器适用，老机器需要重新制作镜像）

# /etc/audit/rules.d/proc.rules
# 监控所有 /proc/[pid]/* 的读访问
-w /proc/[0-9]*/ -p r -k proc_read

# 监控 /proc/sys/ 写入
-w /proc/sys/ -p wa -k proc_sys_write

# 监控敏感 sysctl
-w /proc/sys/kernel/core_pattern -p wa -k core_pattern
-w /proc/sysrq-trigger -p wa -k sysrq
-w /proc/sys/kernel/modprobe -p wa -k modprobe

# 监控隐藏进程的可能路径
-w /proc/[0-9]*/cmdline -p r -k cmdline_read
-w /proc/[0-9]*/environ -p r -k environ_read
-w /proc/[0-9]*/maps -p r -k maps_read

# 监控系统调用
-a always,exit -F arch=b64 -S ptrace -k ptrace
-a always,exit -F arch=b64 -S process_vm_readv -k proc_mem_read
-a always,exit -F arch=b64 -S init_module -k module_load
-a always,exit -F arch=b64 -S delete_module -k module_unload

# 应用规则
auditctl -R /etc/audit/rules.d/proc.rules

# 查所有读 /proc/[pid]/environ 的事件
ausearch -k environ_read --start recent

# 查所有写入 core_pattern 的事件
ausearch -k core_pattern --start recent

# 查所有 ptrace 事件
ausearch -k ptrace --start recent

# 查所有加载内核模块的事件
ausearch -k module_load --start recent

# 在生产用更精细的过滤
# 只记录 uid>=1000 的进程读其他进程的 /proc
-a always,exit -F arch=b64 -S openat -F path=/proc/[0-9]*/ -F auid>=1000 -k proc_read_user

// /proc/self/comm 的 eBPF trace
SEC("tracepoint/syscalls/sys_enter_openat")
int trace_openat(struct trace_event_raw_sys_enter *ctx) {
    char filename[256];
    bpf_probe_read_user_str(filename, sizeof(filename), (char *)ctx->args[1]);
    
    // 仅追踪读 /proc/[pid]/* 的事件
    if (strncmp(filename, "/proc/", 6) != 0) return 0;
    if (strncmp(filename + 6, "self", 4) == 0) return 0;  // 跳过自身
    
    // 输出到 perf event
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    bpf_printk("PID %d opened %s\\n", pid, filename);
    return 0;
}

# 编译
clang -O2 -target bpf -c proc_trace.bpf.c -o proc_trace.bpf.o

# 加载
bpftool prog load proc_trace.bpf.o /sys/fs/bpf/proc_trace
bpftool prog attach /sys/fs/bpf/proc_trace tracepoint/syscalls/sys_enter_openat

# 查看追踪输出
cat /sys/kernel/debug/tracing/trace_pipe | grep "PID"

# Falco 默认规则：检测容器内写 core_pattern
- rule: Container Drift Detected (Modify_core_pattern)
  desc: Detect modification of core_pattern in container
  condition: >
    container and
    fd.name=/proc/sys/kernel/core_pattern and
    evt.type in (write, open, openat) and
    evt.is_open_write=true
  output: >
    Core pattern modified in container
    (user=%user.name command=%proc.cmdline pid=%proc.pid)
  priority: CRITICAL

# Falco 默认规则：检测敏感文件被读
- rule: Read sensitive file trusted after startup
  desc: >
    An attempt to read /proc/self/environ from a non-tty process
  condition: >
    proc.name != sshd and fd.name=/proc/self/environ
  output: >
    Sensitive file read (user=%user.name command=%proc.cmdline)
  priority: WARNING

# Tetragon TracingPolicy：监控所有读 /proc/[pid]/mem 的尝试
apiVersion: cilium.io/v1alpha1
kind: TracingPolicy
metadata:
  name: proc-mem-read-monitor
spec:
  kprobes:
  - call: "sys_openat"
    syscall: true
    args:
    - index: 1
      type: "const_buf"
    selectors:
    - matchArgs:
      - index: 1
        operator: "Contains"
        values:
        - "/proc/"
        - "/mem"
      matchActions:
      - action: Sigkill
        # 真正可疑就杀进程
      - action: Post
        # 同时打日志

# 查看当前 namespace 的 propagation 类型
findmnt -o TARGET,PROPAGATION
# 输出：
# /   shared
# /proc private    # ← 容器内独立
# /sys  private

# 验证 CVE-2025-52881 缓解：宿主 /proc 必须是 private
mount | grep " /proc " | grep -v "private"
# 如果有任何非 private 的输出 → 风险仍存在

# 在容器启动脚本里（runc 的 spec）
"mounts": [
  {
    "destination": "/proc",
    "type": "proc",
    "source": "proc",
    "options": ["nosuid", "nodev", "noexec", "relatime", "hidepid=2"]
  }
]
# propagation 字段默认是 private，runc 1.2.8+ 修复后会强制约束

# 1. 建立业务基线（不要上来就告警）
#    跑 14 天的“观察模式”，记录正常波动范围

# 2. 用“滑动窗口”而非“瞬时值”告警
#    比如“连续 5 分钟 TCP 连接数 > 10000”而非“瞬时 > 10000”

# 3. 区分“系统进程”和“用户进程”
#    容器内的 PID 1-100 是系统进程，101+ 才是用户进程
#    重点关注后者的异常

# 4. 用白名单而非黑名单
#    列出合法进程名（sshd、nginx、postgres）→ 这些不告警
#    未知进程名 → 告警

# 5. 关联多指标
#    单一指标异常不一定告警
#    “TCP 连接数增加 + /proc/[pid]/comm 空 + 内核模块变化”三个一起出现 → 告警

# 第 1 周：部署 Prometheus + node_exporter
# 第 2 周：接入关键指标（进程数、TCP 连接数、CPU、内存）
# 第 3 周：部署 Falco，开启 default 规则集（audit 模式）
# 第 4 周：调参完成后切换到 enforce
# 第 5 周：部署 Grafana dashboard + Alertmanager
# 第 6 周：eBPF 自定义追踪（仅对关键路径）

#!/usr/bin/env bash
# /usr/local/bin/proc_baseline.sh
# 用途：基线盘点脚本，记录全集群 /proc 当前状态

set -euo pipefail
OUTDIR=/var/log/proc-baseline/$(date +%Y%m%d)
mkdir -p "$OUTDIR"

echo "[*] 内核版本与启动参数"
uname -a > "$OUTDIR/uname.txt"
cat /proc/cmdline > "$OUTDIR/cmdline.txt" 2>/dev/null || true

echo "[*] /proc 挂载选项"
findmnt /proc > "$OUTDIR/proc-mount.txt"
findmnt /proc/sys/fs/protected_* >> "$OUTDIR/proc-mount.txt" 2>/dev/null || true

echo "[*] 关键 sysctl"
sysctl -a | grep -E \
  "kernel.yama.ptrace_scope|kernel.randomize_va_space|kernel.kptr_restrict|\
kernel.dmesg_restrict|kernel.unprivileged_bpf_disabled|kernel.modules_disabled|\
kernel.usermodehelper|fs.protected_.*" \
  > "$OUTDIR/sysctl.txt"

echo "[*] AppArmor / SELinux 状态"
apparmor_status > "$OUTDIR/apparmor.txt" 2>/dev/null || echo "not installed"
sestatus > "$OUTDIR/selinux.txt" 2>/dev/null || echo "not installed"

echo "[*] /proc 暴露面：哪些路径对其他用户可读"
find /proc -maxdepth 3 -perm -o+r -type f 2>/dev/null \
  | grep -vE "/proc/(self|kthreadd|kworker|irq|softirq|migration)" \
  | head -200 > "$OUTDIR/world-readable-proc.txt"

echo "[*] 当前可观测组件清单"
systemctl list-unit-files --state=enabled 2>/dev/null \
  | grep -iE "prometheus|node_exporter|falco|auditd|tetragon|\
loki|grafana|alertmanager" \
  > "$OUTDIR/observability.txt" || true

echo "[*] 输出到 $OUTDIR"

#!/usr/bin/env bash
# /usr/local/bin/rollout-proc-hardening.sh
# 用途：分机房灰度推送 /proc 加固配置

set -euo pipefail
IDC="${1:?用法: $0 <idc-name>}"
CONF="/etc/sysctl.d/99-proc-hardening.conf"

case "$IDC" in
  idc-a) ROLLOUT_PCT=10 ;;   # 灰度起点
  idc-b) ROLLOUT_PCT=30 ;;
  idc-c) ROLLOUT_PCT=60 ;;
  idc-d) ROLLOUT_PCT=100 ;;  # 主要机房全量
  *) echo "unknown idc: $IDC"; exit 1 ;;
esac

echo "[*] 灰度比例: ${ROLLOUT_PCT}%"

# 用 ansible / salt / puppet 都行，这里以 ansible 为例
ansible "idc_${IDC}_*" -m copy \
  -a "src=$CONF dest=$CONF mode=0644 owner=root group=root" \
  --percent "${ROLLOUT_PCT}"

ansible "idc_${IDC}_*" -m shell \
  -a "sysctl -p $CONF && systemctl daemon-reload" \
  --percent "${ROLLOUT_PCT}" --forks 20

# 观察 24h，没异常再推下一波
echo "[*] 等待 24h 后继续推下一波..."

#!/usr/bin/env bash
# /usr/local/bin/rollback-proc-hardening.sh
# 紧急回滚脚本，把加固配置全部还原

set -euo pipefail

echo "[!] 紧急回滚 /proc 加固"

# 1. 卸载所有 read-only bind mount
for mp in $(mount | awk '/\/run\/proc-ro/{print $3}'); do
  umount "$mp" || echo "[!] umount $mp 失败"
done

# 2. 还原 sysctl
rm -f /etc/sysctl.d/99-proc-hardening.conf
sysctl --system

# 3. AppArmor 切回 complain
aa-complain /etc/apparmor.d/* 2>/dev/null || true

# 4. 重启（最稳的回滚方式）
echo "[!] 即将重启以完成回滚（按 Ctrl+C 取消，10 秒后自动执行）"
sleep 10
systemctl reboot

cat /proc/net/tcp

#!/usr/bin/env bash
# /usr/local/bin/proc_observability_readiness.sh
# 用途：评估当前机器 /proc 对可观测性工具的友好度

set -euo pipefail
echo "=== /proc 可观测性准备度评估 ==="
echo ""

score=0
max=0

check() {
  local desc="$1"
  local cmd="$2"
  local expected="$3"
  max=$((max + 1))

  if result=$(bash -c "$cmd" 2>&1); then
    if echo "$result" | grep -qE "$expected"; then
      echo "[✓] $desc"
      score=$((score + 1))
    else
      echo "[✗] $desc"
      echo "    期望匹配: $expected"
      echo "    实际输出: $result"
    fi
  else
    echo "[✗] $desc (命令失败)"
  fi
}

# 1. node_exporter 能读 /proc/*/stat 吗？
check "node_exporter 可读 /proc/1/stat" \
  "sudo -u nobody cat /proc/1/stat 2>&1 | head -c 50" \
  "^[0-9]+"

# 2. node_exporter 能读 /proc/net/tcp 吗？
check "node_exporter 可读 /proc/net/tcp" \
  "sudo -u nobody head -1 /proc/net/tcp 2>&1" \
  "sl.*local_address"

# 3. auditd 能监听 /proc/sys/kernel/core_pattern 吗？
check "audit 规则支持 -w /proc/sys" \
  "auditctl -l 2>/dev/null | grep -E 'core_pattern|/proc/'" \
  ".*"

# 4. 当前 machine-id 存在（Prometheus 标签需要）
check "machine-id 可读" \
  "cat /etc/machine-id 2>/dev/null" \
  "^[a-f0-9]{32}$"

# 5. 当前系统时间同步（Prometheus 抓取需要准确时间）
check "时间同步在 1 秒以内" \
  "chronyc tracking 2>/dev/null | grep 'System time' | awk '{print \$4}' | awk -F'=' '{print \$2}' | awk '{ if (\$1+0 < 1) exit 0; else exit 1 }'" \
  ".*"

echo ""
echo "=== 得分: $score / $max ==="
if [ "$score" -lt 3 ]; then
  echo "[!] 准备度不足，建议先调整权限再上可观测性工具"
fi

# /etc/fstab 里的 proc 行
proc  /proc  proc  defaults,hidepid=2,gid=procmon  0  0

# 建一个组，把所有采集器用户加进去
groupadd -r procmon
usermod -aG procmon node_exporter
usermod -aG procmon prometheus
usermod -aG procmon falco

# /etc/prometheus/node_exporter.yml
--collector.proc
processes:
  - pid: 1
    name: "systemd"
  - pid: "self"
    name: "node_exporter"

#!/usr/bin/env python3
# /usr/local/bin/proc_io_exporter.py
# 把 /proc/[pid]/io 导出为 Prometheus 指标

import os
import time
from prometheus_client import start_http_server, Gauge, Counter

PROC_IO_FIELDS = [
    "rchar", "wchar", "syscr", "syscw",
    "read_bytes", "write_bytes", "cancelled_write_bytes",
]

gauges = {}
for field in PROC_IO_FIELDS:
    gauges[field] = Gauge(
        f"proc_io_{field}_bytes_total",
        f"Per-process {field} from /proc/[pid]/io",
        ["pid", "comm"],
    )

def collect():
    for entry in os.listdir("/proc"):
        if not entry.isdigit():
            continue
        pid = entry
        io_file = f"/proc/{pid}/io"
        try:
            with open(io_file) as f:
                data = {}
                for line in f:
                    k, v = line.strip().split(": ")
                    data[k] = int(v)
            with open(f"/proc/{pid}/comm") as f:
                comm = f.read().strip()
        except (FileNotFoundError, ProcessLookupError, PermissionError):
            continue

        for field in PROC_IO_FIELDS:
            if field in data:
                gauges[field].labels(pid=pid, comm=comm).set(data[field])

if __name__ == "__main__":
    start_http_server(9878)
    while True:
        collect()
        time.sleep(5)

#!/usr/bin/env python3
# /usr/local/bin/proc_tcp_state_exporter.py
# 从 /proc/net/tcp 解析状态，导出 Prometheus 指标

import time
from prometheus_client import start_http_server, Gauge

TCP_STATE = {
    "01": "ESTABLISHED",
    "02": "SYN_SENT",
    "03": "SYN_RECV",
    "04": "FIN_WAIT1",
    "05": "FIN_WAIT2",
    "06": "TIME_WAIT",
    "07": "CLOSE",
    "08": "CLOSE_WAIT",
    "09": "LAST_ACK",
    "0A": "LISTEN",
    "0B": "CLOSING",
}

state_gauges = {
    name: Gauge(f"proc_tcp_state_{name.lower()}", f"Count of TCP in {name}")
    for name in TCP_STATE.values()
}

def parse_proc_net_tcp(path):
    counts = {name: 0 for name in TCP_STATE.values()}
    with open(path) as f:
        next(f)  # skip header
        for line in f:
            parts = line.split()
            if len(parts) < 4:
                continue
            st = parts[3]
            name = TCP_STATE.get(st)
            if name:
                counts[name] += 1
    return counts

def collect():
    for proto, path in [("v4", "/proc/net/tcp"), ("v6", "/proc/net/tcp6")]:
        counts = parse_proc_net_tcp(path)
        for name, count in counts.items():
            state_gauges[name].set(count)

if __name__ == "__main__":
    start_http_server(9879)
    while True:
        collect()
        time.sleep(10)

# 在 exporter 启动时从环境变量读
import os

MACHINE_ID = open("/etc/machine-id").read().strip()
IDC = os.environ.get("IDC", "unknown")
SERVICE = os.environ.get("SERVICE", "unknown")

gauge = Gauge(
    "proc_io_bytes",
    "Per-process I/O",
    ["pid", "comm", "machine_id", "idc", "service"],
)
gauge.labels(pid=pid, comm=comm, machine_id=MACHINE_ID, idc=IDC, service=SERVICE).set(value)

# /etc/audit/rules.d/10-proc-deep.rules

# --- /proc/[pid]/environ 读取（重点：凭证窃取）---
-a always,exit -F arch=b64 -S openat -F a2=0 -F path=/proc/[0-9]*/environ -F key=proc-environ-read

# --- /proc/[pid]/mem 读取（重点：内存取证 / 注入）---
-a always,exit -F arch=b64 -S process_vm_readv -F key=proc-mem-read
-a always,exit -F arch=b64 -S ptrace -F a0=0x4 -F key=proc-ptrace-read

# --- /proc/[pid]/maps 读取（重点：内存布局发现）---
-a always,exit -F arch=b64 -S openat -F path=/proc/[0-9]*/maps -F key=proc-maps-read

# --- /proc/[pid]/fd/ 目录读取（重点：socket 反查）---
-a always,exit -F arch=b64 -S getdents64 -F dir=/proc/[0-9]*/fd -F key=proc-fd-list

# --- /proc/sys/kernel/core_pattern 写入（重点：容器逃逸 CVE-2025-52881 类）---
-w /proc/sys/kernel/core_pattern -p wa -k proc-core-pattern-write

# --- /proc/sys/kernel/modules_disabled 写入（重点：禁用模块加载开关）---
-w /proc/sys/kernel/modules_disabled -p wa -k proc-modules-write

# --- /proc/kallsyms 读取（重点：内核符号探测）---
-a always,exit -F arch=b64 -S openat -F path=/proc/kallsyms -F key=proc-kallsyms-read

# --- /proc/net/tcp 读取（重点：连接发现，但有大量正常读取，需要白名单）---
-a always,exit -F arch=b64 -S openat -F path=/proc/net/tcp -F key=proc-net-tcp-read
-a always,exit -F arch=b64 -S openat -F path=/proc/net/tcp6 -F key=proc-net-tcp-read

# node_exporter 的 PID 是动态的，启动时记录下来
NODE_EXPORTER_PID=$(pgrep -f node_exporter | head -1)

# 把这个 PID 加到排除列表
-a never,exit -F pid=$NODE_EXPORTER_PID

# /etc/audit/auditd.conf
buffer_size = 8192   # 默认 1024 太小
backlog_limit = 8192
failure_mode = 1     # 1 = printk（不阻塞）

# 只监控敏感路径，普通路径不监控
-a always,exit -F path=/proc/[0-9]*/environ
-a always,exit -F path=/proc/[0-9]*/mem
# 不要监控 /proc/[pid]/stat（太频繁，没价值）

# 查所有读 /proc/[pid]/environ 的事件
ausearch -k proc-environ-read --interpret | head -20

# 查所有写 core_pattern 的事件
ausearch -k proc-core-pattern-write --interpret

# 统计昨天的 proc-environ-read 事件数量
aureport --start yesterday --end now --key proc-environ-read

# 按进程统计
ausearch -k proc-environ-read --interpret | \
  awk '/comm=/{comm=$0} /exe=/{print comm, $0}' | \
  sort | uniq -c | sort -rn | head

# /etc/audit/plugins.d/au-remote.conf
active = yes
direction = out
path = /sbin/au-remote
type = always

# /etc/promtail/config.yml
server:
  http_listen_port: 9080

positions:
  filename: /var/lib/promtail/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: auditd
    static_configs:
      - targets:
          - localhost
        labels:
          job: auditd
          __path__: /var/log/audit/audit.log
    pipeline_stages:
      # 1. 解析 auditd 格式
      - match:
          selector: '{job="auditd"}'
          stages:
            - regex:
                expression: 'type=(?P<type>\w+) msg=audit\((?P<ts>\d+.\d+):(?P<seq>\d+)\): (?P<rest>.*)'
            - labels:
                type:

      # 2. 提取 key= 字段
      - match:
          selector: '{job="auditd"}'
          stages:
            - regex:
                expression: 'key="(?P<key>[^"]+)"'
            - labels:
                key:

      # 3. 提交流到 Loki

# Prometheus Alertmanager 例
- alert: ProcEnvironRead
  expr: |
    sum by (exe, uid) (
      rate(audit_proc_environ_read_total[5m])
    ) > 0.1
  for: 5m
  labels:
    severity: warning
  annotations:
    summary: "进程 {{ $labels.exe }} (uid={{ $labels.uid }}) 持续读取 /proc/[pid]/environ"
  # 白名单：node_exporter / prometheus / 备份用户
  # 但通过 alertmanager 的 inhibit_rules 实现

inhibit_rules:
  - source_match:
      exe: 'node_exporter'
    target_match:
      exe: 'node_exporter'
    equal: ['exe']

# 白名单应该基于 exe 的 inode + 校验和
node_exporter_path=$(readlink -f /proc/$(pgrep node_exporter)/exe)
node_exporter_sha256=$(sha256sum "$node_exporter_path" | awk '{print $1}')
echo "白名单: $node_exporter_path ($node_exporter_sha256)"

# /etc/alertmanager/alertmanager.yml
route:
  receiver: 'default'
  group_by: ['alertname', 'idc']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  routes:
    - match:
        severity: critical
      receiver: 'pagerduty'
    - match:
        severity: warning
      receiver: 'wecom'

inhibit_rules:
  # P1 抑制 P2
  - source_match:
      severity: 'critical'
    target_match:
      severity: 'warning'
    equal: ['idc', 'alertname']

  # 同 alertname 在 5 分钟内只发一次
  - source_match:
      alertname: 'ProcEnvironRead'
    target_match:
      alertname: 'ProcEnvironRead'
    equal: ['pid']

# 8 个人轮值，每人一周
receivers:
  - name: 'oncall-rotation'
    webhook_configs:
      - url: 'https://oncall-bot.internal/api/notify'
        send_resolved: true