jniecko/ebpf-k8s-attack-detection

eBPF Kubernetes Attack Detection — Syscall Aggregation Study

Dataset accompanying the paper:

In progress

Overview

Two experimental runs on a 4-node Kubernetes cluster (Kubernetes 1.35.4, Proxmox VMs, Intel Core i7-8700, 32 GB RAM) running the Online Boutique microservices application (11 services). Kernel events collected with Tracee 0.24 (21 event types). Traffic generated by Locust 2.43.

Two traffic profiles:

• Seasonal (seasonal/) — diurnal load cycle, 20–200 virtual users
• Flat (flat/) — constant 100 virtual users

Each run: 5 cycles (TIME_SCALE=60, one simulated "day" = 24 min). Cycles 1–2: training phase (no attacks). Cycles 3–5: attack phase. 18 attack instances per run (6 types × 3 attack cycles).

Attack Types

Attack	Description
xmrig	Cryptominer — high CPU, intensive sched_yield
revshell	Reverse shell via nc
distroless_revshell	Reverse shell in distroless container (no shell binary)
k8sapi	Kubernetes API abuse via service account token
suid_escalation	Privilege escalation via SUID binary
ld_preload	Shared library injection via LD_PRELOAD env variable

Tracee Events Collected (21 types)

execve, openat, mmap, prctl, clone, sched_yield, socket, connect, dup2, pipe, mprotect, setuid, capset, chmod, stdio_over_socket, illegitimate_shell, mem_prot_alert, dynamic_code_loading, dropped_executable, k8s_api_connection, ld_preload

Repository Structure

seasonal/
  attacks_run01.csv     # Attack log (start/end times, exit codes)
  features_run01.csv    # 5-second windows: syscall counts + entropy
  locust_run01.csv      # Traffic telemetry (users, rps, p50/p95 latency)
  latency_run01.csv     # Detection latency per attack instance and model variant
  metrics_run01.csv     # ROC-AUC, PR-AUC, FPR@R90 per model variant

flat/
  attacks_flat02.csv
  features_flat02.csv
  locust_flat02.csv
  latency_flat02.csv
  metrics_flat02.csv              # Per-pod results
  metrics_flat02_global.csv       # Global aggregation results
  metrics_flat02_perattack.csv    # Per-attack-type breakdown
  comparison_global_vs_perpod_flat02.csv

Key Results

Variant	ROC-AUC
Flat / Global (F/G)	0.881
Flat / per-pod M2 (F/M2)	0.785
Flat / per-pod M1 (F/M1)	0.763
Seasonal / per-pod M2 (S/M2)	0.849
Seasonal / per-pod M1 (S/M1)	0.825
Seasonal / Global (S/G)	0.720

M1 = syscall features only. M2 = M1 + Locust load features (req/s, p95 latency).

Reproducing Results

The full pipeline (notebooks) is in the companion repository. Below is a standalone recipe using only the CSV files in this dataset.

Step 1 — Join features + load + labels → training table

import numpy as np
import pandas as pd

RUN = "run01"          # or "flat02"
WINDOW = 5.0

feat = pd.read_csv(f"seasonal/features_{RUN}.csv")
loc  = pd.read_csv(f"seasonal/locust_{RUN}.csv")
atk  = pd.read_csv(f"seasonal/attacks_{RUN}.csv")

# Downsample Locust (1 s) to 5-s windows
loc["window_start"] = (loc["ts"] // WINDOW) * WINDOW
loc5 = loc.groupby("window_start").agg(
    users_mean=("users", "mean"),
    rps=("current_rps", "mean"),
    p95=("response_time_percentile_0_95", "mean"),
).reset_index()

df = feat.merge(loc5, on="window_start", how="left")

# Label: window overlaps an attack on the same pod
df["label"] = 0
for _, a in atk.iterrows():
    mask = (
        (df["window_start"] < a["end_ts"]) &
        (df["window_start"] + WINDOW > a["start_ts"]) &
        (df["pod_name"].str.contains(a["name"].split("_")[0], na=False))
    )
    df.loc[mask, "label"] = 1

Step 2 — Train M1 (syscalls only)

from sklearn.ensemble import IsolationForest

FEAT_M1 = [c for c in df.columns if c.startswith("count_") or
           c in ("total_syscalls", "unique_syscalls", "entropy")]

# Temporal split: first half clean windows = train
split_ts = df.loc[df["label"] == 0, "window_start"].median()
train = df[(df["label"] == 0) & (df["window_start"] <= split_ts)]
test  = df[~((df["label"] == 0) & (df["window_start"] <= split_ts))]

# Per-pod z-score normalisation
pod_mean = train.groupby("pod_name")[FEAT_M1].mean()
pod_std  = train.groupby("pod_name")[FEAT_M1].std().replace(0, 1)

def normalise(rows, feat_cols):
    out = rows.copy()
    for pod, grp in rows.groupby("pod_name"):
        mu = pod_mean.loc[pod] if pod in pod_mean.index else pod_mean.mean()
        sd = pod_std.loc[pod]  if pod in pod_std.index  else pod_std.mean()
        out.loc[grp.index, feat_cols] = (grp[feat_cols] - mu) / sd
    return out

train_n = normalise(train, FEAT_M1)
test_n  = normalise(test,  FEAT_M1)

contamination = float(test["label"].mean())
m1 = IsolationForest(n_estimators=400, contamination=contamination, random_state=42)
m1.fit(train_n[FEAT_M1])

Step 3 — Train M2 (add load features)

FEAT_M2 = FEAT_M1 + ["rps", "p95"]

train_n2 = normalise(train, FEAT_M2)
test_n2  = normalise(test,  FEAT_M2)

m2 = IsolationForest(n_estimators=400, contamination=contamination, random_state=42)
m2.fit(train_n2[FEAT_M2])

Step 4 — Evaluate

from sklearn.metrics import roc_auc_score

for name, model, feat_cols, data in [
    ("M1", m1, FEAT_M1, test_n),
    ("M2", m2, FEAT_M2, test_n2),
]:
    scores = model.decision_function(data[feat_cols])
    roc = roc_auc_score(data["label"], scores)
    print(f"{name}: ROC-AUC = {roc:.3f}")

Expected output (seasonal run01): M1: ROC-AUC = 0.825, M2: ROC-AUC = 0.849

Detector

Isolation Forest (scikit-learn), temporal train/test split (cycles 1–2 train, cycles 3–5 test). Contamination: 0.042 (per-pod), 0.40 (global). Pre-trained models available at: jniecko/isolation-forest-k8s-ebpf

Feature Schema (features_*.csv)

Column	Description
timestamp	Window start (Unix seconds)
pod_name	Pod identifier (per-pod variants)
count_<event>	Count of each Tracee event in the 5-s window
total_syscalls	Sum of all event counts
unique_syscalls	Number of distinct event types
entropy	Shannon entropy of the event distribution
label	1 = attack window, 0 = normal

Citation

In progress

License

CC BY 4.0