AI 에이전트 보안, 커널에서 감시한다 — eBPF 기반 런타임 거버넌스 아키텍처 심층 분석

// 환경: Linux 5.7+, libbpf 0.8+, BTF 지원 커널 필요
// eBPF LSM 훅으로 에이전트의 네트워크 연결 차단 예시
 
// 허용 목적지 IP를 관리하는 BPF 해시 맵
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, __u32);   // IPv4 주소 (네트워크 바이트 오더)
    __type(value, __u8);  // 1 = 허용
    __uint(max_entries, 256);
} allowed_ips SEC(".maps");
 
struct agent_policy {
    __u8 network_restricted;
};
 
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, __u32);             // PID
    __type(value, struct agent_policy);
    __uint(max_entries, 1024);
} agent_policies SEC(".maps");
 
// 허용 IP 조회 헬퍼 함수
static __always_inline int is_allowed_destination(
    struct sockaddr *addr, struct agent_policy *policy)
{
    if (!policy->network_restricted) return 1; // 제한 정책 없으면 통과
    if (addr->sa_family != AF_INET) return 0;  // IPv4만 허용 예시
 
    struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
    __u32 dst_ip = addr4->sin_addr.s_addr;
    // BPF 맵에서 허용 IP 조회
    return bpf_map_lookup_elem(&allowed_ips, &dst_ip) != NULL;
}
 
SEC("lsm/socket_connect")
int BPF_PROG(restrict_agent_connect, struct socket *sock,
             struct sockaddr *address, int addrlen)
{
    u32 pid = bpf_get_current_pid_tgid() >> 32;
 
    struct agent_policy *policy = bpf_map_lookup_elem(&agent_policies, &pid);
    if (!policy) return 0; // 비에이전트 프로세스는 통과
 
    if (!is_allowed_destination(address, policy)) {
        bpf_printk("BLOCKED: agent %d attempted unauthorized connection\n", pid);
        return -EPERM; // 커널 수준 차단
    }
    return 0;
}

┌──────────────────────────────────────────────┐
│              AI 에이전트 프로세스              │
├──────────────────────────────────────────────┤
│  seccomp-BPF  │  허용된 syscall 화이트리스트  │
├──────────────────────────────────────────────┤
│  Landlock LSM │  선언적 파일시스템 접근 제한  │
├──────────────────────────────────────────────┤
│  네트워크 NS  │  에이전트별 독립 네트워크 스택 │
├──────────────────────────────────────────────┤
│  eBPF 감사    │  모든 이벤트 JSONL 로깅 + 차단 │
└──────────────────────────────────────────────┘

// JSONL 감사 로그 형식 (한 줄 = 한 이벤트)
{
  "seq": 1,
  "timestamp": "2026-04-14T09:23:01.234Z",
  "agent_id": "agent-abc123",
  "event_type": "file_open",
  "path": "/etc/passwd",
  "pid": 4821,
  "action": "BLOCKED",
  "policy_rule": "no_sensitive_files",
  "hash_prev": "0000000000000000000000000000000000000000000000000000000000000000",
  "hash_self": "a3f8d2c1e9b47056f3a2d1c8e6b4f9a2c7d3e8f1b5a9c2d6e4f7b3a8c1d5e9f2"
}

# 환경: Python 3.9+
# 해시 체인 검증 유틸리티
 
import hashlib
import json
 
def verify_audit_chain(log_path: str) -> bool:
    """감사 로그의 해시 체인 무결성을 검증합니다."""
    prev_hash = "0" * 64
    line_num = 0  # 빈 파일 처리를 위해 미리 초기화
 
    with open(log_path) as f:
        for line_num, line in enumerate(f, 1):
            event = json.loads(line.strip())
 
            # hash_prev가 직전 이벤트의 hash_self와 일치하는지 확인
            if event["hash_prev"] != prev_hash:
                print(f"체인 무결성 위반: {line_num}번째 이벤트")
                return False
 
            # 현재 이벤트의 hash_self 재계산
            payload = json.dumps(
                {k: v for k, v in event.items() if k != "hash_self"},
                sort_keys=True
            )
            expected_hash = hashlib.sha256(payload.encode()).hexdigest()
 
            if event["hash_self"] != expected_hash:
                print(f"이벤트 위변조 감지: {line_num}번째 이벤트")
                return False
 
            prev_hash = event["hash_self"]
 
    if line_num == 0:
        print("감사 로그가 비어 있습니다.")
        return True
 
    print(f"감사 로그 무결성 확인 완료: {line_num}개 이벤트")
    return True

# 환경: Linux 5.15+, Rust 1.70+, CAP_BPF 권한 필요
# AgentSight 설치 및 에이전트 모니터링 시작
git clone https://github.com/eunomia-bpf/agentsight
cd agentsight
 
# eBPF 데몬 빌드 (Rust + C)
cargo build --release
 
# 에이전트 모니터링 시작
# --capture-tls: libssl SSL_write/SSL_read 함수 진입점 후킹으로 평문 캡처
# --trace-process: sched_process_exec으로 프로세스 트리 구성
sudo ./target/release/agentsight monitor \
  --pid $(pgrep -f "claude") \
  --capture-tls \
  --trace-process \
  --output jsonl \
  --output-file /var/log/agent-audit.jsonl

// 주의: 아래 SDK는 현재 개발 중이며 API가 변경될 수 있습니다.
// 실제 사용 전 저장소에서 최신 설치 방법과 API를 확인하세요.
 
const ALLOWED_ENDPOINTS = ['api.openai.com', 'api.anthropic.com'];
const SENSITIVE_PATHS = ['/etc/', '/root/', '/.ssh/'];
 
// AgentSight 이벤트 핸들러 예시 (실제 SDK API는 저장소 README 참고)
function onAgentEvent(event: AgentEvent): void {
  // 비정상적인 외부 연결 탐지
  if (event.type === 'network_connect' &&
      !ALLOWED_ENDPOINTS.includes(event.destination)) {
    console.warn(`비허가 외부 연결 시도: ${event.destination}`);
    // blockAgent(event.pid);
  }
 
  // 민감 파일 접근 탐지
  if (event.type === 'file_open' &&
      SENSITIVE_PATHS.some(p => event.path.startsWith(p))) {
    console.error(`민감 파일 접근 시도: ${event.path}`);
    // blockAgent(event.pid);
  }
}

# openclaw-policy.yaml — 게이트웨이 위험도 분류 정책
version: "1.0"
agent_id: "finance-agent-v2"
 
policies:
  # 저위험: 자동 허용
  - name: read_internal_docs
    match:
      tool: ["file_read", "search"]
      path_prefix: ["/workspace/docs/"]
    action: ALLOW
    audit: true
 
  # 중위험: 자동 허용 + 상세 로깅
  - name: internal_api_calls
    match:
      tool: ["http_request"]
      destination_domain: ["*.internal.company.com"]
    action: ALLOW
    audit: true
    log_level: VERBOSE
 
  # 고위험: 인간 승인 필요
  - name: production_db_query
    match:
      tool: ["db_query"]
      database: ["prod-*"]
    action: HUMAN_APPROVAL
    approval_channel: "#agent-approvals"   # Slack 알림
    timeout_seconds: 300                   # 5분 내 미승인 시 자동 차단
 
  # 최고위험: 즉시 차단
  - name: block_external_payments
    match:
      tool: ["http_request"]
      destination_domain: ["stripe.com", "paypal.com"]
    action: BLOCK
    alert: true

# 주의: openclaw 패키지는 현재 개발 중이며 API가 변경될 수 있습니다.
# 실제 도입 전 공식 문서와 릴리스 노트를 확인하세요.
# OpenClaw 정책 엔진 Python SDK 활용
 
from openclaw import PolicyEngine, AuditLogger
 
engine = PolicyEngine.from_config("openclaw-policy.yaml")
logger = AuditLogger(
    output="/var/log/openclaw/audit.jsonl",
    hash_chain=True   # SHA-256 해시 체인 활성화
)
 
@engine.intercept
async def handle_tool_call(agent_id: str, tool: str, params: dict):
    """모든 도구 호출이 이 핸들러를 통과합니다."""
    decision = await engine.evaluate(agent_id, tool, params)
 
    # 감사 로그 기록
    await logger.record(
        agent_id=agent_id,
        tool=tool,
        params=params,
        decision=decision
    )
 
    if decision.action == "HUMAN_APPROVAL":
        approved = await request_human_approval(
            channel=decision.channel,
            context={"agent": agent_id, "tool": tool, "params": params},
            timeout=decision.timeout_seconds
        )
        return approved
 
    return decision.action == "ALLOW"

# 환경: Kubernetes 1.24+, KubeArmor 설치 필요
# 1단계: 관찰 모드로 에이전트 실행 (정책 시행 없이 행동만 기록)
kubectl annotate pod my-agent-pod \
  kubearmor-policy=audit \
  kubearmor-visibility=process,file,network
 
# 72시간 관찰 후 생성된 프로파일 확인
kubectl get applicationprofile my-agent-pod -o yaml

# 학습된 Application Profile DNA를 기반으로 생성된 KubeArmor 정책
apiVersion: security.kubearmor.com/v1
kind: KubeArmorPolicy
metadata:
  name: agent-learned-policy
spec:
  selector:
    matchLabels:
      app: my-agent
 
  # 관찰된 정상 프로세스만 허용
  process:
    matchPaths:
      - path: /usr/bin/python3
      - path: /usr/local/bin/node
    action: Allow
 
  # 관찰된 정상 파일 접근만 허용
  file:
    matchDirectories:
      - dir: /workspace/
        recursive: true
    action: Allow
 
  # 민감 경로 차단
  file:
    matchPaths:
      - path: /etc/
      - path: /root/
    action: Block