| from __future__ import annotations |
|
|
| from typing import Any |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| from src.domain import ( |
| BURST_WINDOW_MINUTES, |
| FEATURE_COLUMNS, |
| SENSITIVE_TYPES, |
| Split, |
| TEST_START_ISO, |
| ) |
| from src.mapper import normalize_event |
| from src.parsers import parse_timestamp |
| from src.ruleset import maintenance_match, severity_for |
|
|
|
|
| def events_frame(rows: list[dict[str, Any]] | pd.DataFrame) -> pd.DataFrame: |
| if isinstance(rows, pd.DataFrame): |
| records = rows.to_dict(orient="records") |
| else: |
| records = list(rows) |
| cleaned = [normalize_event(row) for row in records] |
| frame = pd.DataFrame(cleaned) |
| if frame.empty: |
| return frame |
| frame["ts"] = [parse_timestamp(value) for value in frame["timestamp"]] |
| valid = frame["ts"].notna() & frame["event_name"].astype(str).ne("") |
| frame = frame.loc[valid].copy().reset_index(drop=True) |
| if frame.empty: |
| return frame |
| test_start = pd.Timestamp(TEST_START_ISO) |
| existing = frame["split"].replace("", Split.DEVELOPMENT.value) |
| frame["split"] = np.where(pd.to_datetime(frame["ts"], utc=True) >= test_start, Split.TEST.value, existing) |
| frame["hour"] = pd.to_datetime(frame["ts"], utc=True).dt.hour |
| frame["weekday"] = pd.to_datetime(frame["ts"], utc=True).dt.weekday |
| frame["weekend"] = frame["weekday"].isin([5, 6]).astype(float) |
| human = frame["actor_kind"].eq("human") |
| unusual = human & ((frame["hour"] < 6) | (frame["hour"] >= 22) | frame["weekday"].eq(6)) |
| frame["unusual_hour"] = unusual.astype(float) |
| frame["in_window"] = frame["weekday"].eq(6) & frame["hour"].between(2, 5) |
| flags = frame.apply( |
| lambda row: { |
| "cidr_open": bool(row.get("cidr_open")), |
| "policy_public": bool(row.get("policy_public")), |
| "admin_policy": bool(row.get("admin_policy")), |
| "logging_off": bool(row.get("logging_off")), |
| "detector_off": bool(row.get("detector_off")), |
| "wildcard_trust": bool(row.get("wildcard_trust")), |
| "is_root": row.get("actor_kind") == "root", |
| "hardening": bool(row.get("hardening")), |
| }, |
| axis=1, |
| ) |
| frame["severity"] = [ |
| severity_for(str(row.change_type), flags.iloc[idx]).value for idx, row in enumerate(frame.itertuples(index=False)) |
| ] |
| frame["in_maintenance"] = [ |
| maintenance_match( |
| str(row.account_alias), |
| str(row.actor_alias), |
| str(row.change_type), |
| flags.iloc[idx], |
| str(row.change_ticket or ""), |
| bool(row.in_window), |
| ) |
| for idx, row in enumerate(frame.itertuples(index=False)) |
| ] |
| frame["approval_status"] = np.where(frame["in_maintenance"], "approved_window", "none") |
| frame["approval_status"] = np.where( |
| frame["change_ticket"].astype(str).ne("") & ~frame["in_maintenance"], |
| "unknown", |
| frame["approval_status"], |
| ) |
| frame = _pair_before_after(frame) |
| frame = _burst_counts(frame) |
| frame["is_root"] = frame["actor_kind"].eq("root").astype(float) |
| frame["is_service"] = frame["actor_kind"].eq("service").astype(float) |
| frame["is_human"] = frame["actor_kind"].eq("human").astype(float) |
| frame["error_event"] = frame["error_code"].astype(str).ne("").astype(float) |
| frame["sensitive"] = frame["change_type"].isin(SENSITIVE_TYPES) & ~frame["hardening"].astype(bool) |
| return frame.sort_values(["ts", "event_id"]).reset_index(drop=True) |
|
|
|
|
| def _pair_before_after(frame: pd.DataFrame) -> pd.DataFrame: |
| work = frame.sort_values("ts").copy() |
| before_ids: list[str] = [] |
| before_known: list[bool] = [] |
| after_known: list[bool] = [] |
| for idx, row in work.iterrows(): |
| if row["change_type"] not in SENSITIVE_TYPES or row["hardening"]: |
| before_ids.append("") |
| before_known.append(False) |
| after_known.append(False) |
| continue |
| prior = work.loc[ |
| (work["ts"] < row["ts"]) |
| & (work["account_alias"] == row["account_alias"]) |
| & (work["resource_alias"] == row["resource_alias"]) |
| & (work["resource_alias"].astype(str).ne("res_unknown")) |
| ] |
| if prior.empty: |
| before_ids.append("") |
| before_known.append(False) |
| after_known.append(not bool(row.get("incomplete"))) |
| continue |
| before_ids.append(str(prior.iloc[-1]["event_id"])) |
| before_known.append(True) |
| after_known.append(not bool(row.get("incomplete"))) |
| work["before_event_id"] = before_ids |
| work["after_event_id"] = np.where(work["event_id"].astype(str).ne(""), work["event_id"], "") |
| work["has_before"] = np.array(before_known, dtype=float) |
| work["has_after"] = np.array(after_known, dtype=float) |
| work["before_state"] = np.where(work["has_before"] >= 1, "known", "unknown") |
| work["after_state"] = np.where(work["has_after"] >= 1, "known", "unknown") |
| return work |
|
|
|
|
| def _burst_counts(frame: pd.DataFrame) -> pd.DataFrame: |
| work = frame.sort_values("ts").copy() |
| counts = [] |
| window = pd.Timedelta(minutes=BURST_WINDOW_MINUTES) |
| sensitive = work["change_type"].isin(SENSITIVE_TYPES) & ~work["hardening"].astype(bool) |
| for _, row in work.iterrows(): |
| if not bool(sensitive.loc[row.name] if row.name in sensitive.index else False): |
| counts.append(0) |
| continue |
| mask = ( |
| (work["actor_alias"] == row["actor_alias"]) |
| & (work["ts"] <= row["ts"]) |
| & (work["ts"] >= row["ts"] - window) |
| & sensitive |
| ) |
| counts.append(int(mask.sum())) |
| work["burst_count"] = counts |
| return work |
|
|
|
|
| def feature_matrix(frame: pd.DataFrame) -> pd.DataFrame: |
| if frame.empty: |
| return pd.DataFrame(columns=list(FEATURE_COLUMNS)) |
| data = {} |
| for column in FEATURE_COLUMNS: |
| if column == "severity_weight": |
| data[column] = frame["severity"].map({"high": 4.0, "medium": 3.2, "low": 1.8}).fillna(0.0) |
| elif column in frame.columns: |
| data[column] = pd.to_numeric(frame[column], errors="coerce").fillna(0.0) |
| else: |
| data[column] = 0.0 |
| return pd.DataFrame(data, index=frame.index) |
|
|
|
|
| def attach_gold(frame: pd.DataFrame, gold: pd.DataFrame | list[dict[str, Any]] | None) -> pd.DataFrame: |
| out = frame.copy() |
| out["gold_event_ids"] = "" |
| out["gold_family"] = "" |
| out["detect_delay_min"] = np.nan |
| if gold is None: |
| return out |
| gold_frame = gold if isinstance(gold, pd.DataFrame) else pd.DataFrame(gold) |
| if gold_frame.empty: |
| return out |
| gold_frame = gold_frame.copy() |
| gold_frame["start_ts"] = [parse_timestamp(value) for value in gold_frame["start"]] |
| gold_frame["end_ts"] = [parse_timestamp(value) for value in gold_frame["end"]] |
| for event in gold_frame.itertuples(index=False): |
| lab_id = str(event.event_id) |
| direct = out["lab_event_id"].astype(str).eq(lab_id) | out["event_id"].astype(str).eq(lab_id) |
| if event.start_ts and event.end_ts: |
| overlap = (out["ts"] >= event.start_ts) & (out["ts"] <= event.end_ts) |
| if getattr(event, "account_alias", ""): |
| overlap = overlap & out["account_alias"].astype(str).eq(str(event.account_alias)) |
| if getattr(event, "actor_alias", ""): |
| overlap = overlap & out["actor_alias"].astype(str).eq(str(event.actor_alias)) |
| else: |
| overlap = pd.Series(False, index=out.index) |
| hit = direct | overlap |
| if not hit.any(): |
| continue |
| current = out.loc[hit, "gold_event_ids"].astype(str) |
| out.loc[hit, "gold_event_ids"] = np.where(current.eq("") | current.eq("nan"), lab_id, current + "," + lab_id) |
| out.loc[hit, "gold_family"] = str(event.family) |
| delay = (pd.to_datetime(out.loc[hit, "ts"], utc=True) - pd.Timestamp(event.start_ts)).dt.total_seconds() / 60.0 |
| out.loc[hit, "detect_delay_min"] = delay |
| return out |
|
|
|
|
| def change_view(frame: pd.DataFrame) -> pd.DataFrame: |
| if frame.empty: |
| return frame |
| return frame.loc[frame["change_type"].isin(SENSITIVE_TYPES)].copy() |
|
|
