| from __future__ import annotations |
|
|
| from typing import Any |
|
|
| from src.domain import ActorKind, ChangeType |
| from src.redaction import ( |
| alias_account, |
| alias_actor, |
| alias_ip, |
| alias_resource, |
| compact_json, |
| looks_sensitive, |
| normalize_id, |
| redact_text, |
| ) |
| from src.ruleset import classify_event, flags_from_request |
|
|
|
|
| def _as_dict(value: Any) -> dict[str, Any]: |
| return value if isinstance(value, dict) else {} |
|
|
|
|
| def _identity(row: dict[str, Any]) -> dict[str, Any]: |
| nested = row.get("userIdentity") |
| if isinstance(nested, dict): |
| return nested |
| return { |
| "type": row.get("userIdentity.type") or row.get("user_type") or row.get("actor_kind") or "", |
| "userName": row.get("userIdentity.userName") or row.get("userName") or row.get("user_name") or "", |
| "arn": row.get("userIdentity.arn") or row.get("arn") or "", |
| "accountId": row.get("userIdentity.accountId") or row.get("accountId") or row.get("account_id") or "", |
| "principalId": row.get("userIdentity.principalId") or "", |
| "invokedBy": row.get("userIdentity.invokedBy") or "", |
| "sessionContext": row.get("userIdentity.sessionContext") or {}, |
| } |
|
|
|
|
| def actor_kind_of(identity: dict[str, Any]) -> str: |
| raw = normalize_id(identity.get("type")).lower() |
| if raw == "root": |
| return ActorKind.ROOT.value |
| if raw == "awsservice": |
| return ActorKind.AWS_SERVICE.value |
| if raw == "assumedrole": |
| return ActorKind.SERVICE.value |
| if raw == "iamuser": |
| return ActorKind.HUMAN.value |
| hinted = normalize_id(identity.get("actor_kind") or "").lower() |
| if hinted in {item.value for item in ActorKind}: |
| return hinted |
| return ActorKind.UNKNOWN.value |
|
|
|
|
| def actor_name_of(identity: dict[str, Any]) -> str: |
| session = _as_dict(identity.get("sessionContext")) |
| issuer = _as_dict(session.get("sessionIssuer")) |
| return ( |
| normalize_id(identity.get("userName")) |
| or normalize_id(issuer.get("userName")) |
| or normalize_id(identity.get("invokedBy")) |
| or normalize_id(str(identity.get("arn") or "").rsplit("/", 1)[-1]) |
| or "unknown" |
| ) |
|
|
|
|
| def actor_role_of(kind: str, name: str) -> str: |
| lowered = name.lower() |
| if kind == ActorKind.ROOT.value: |
| return "root" |
| if "terraform" in lowered: |
| return "terraform" |
| if lowered.startswith("ci") or "github" in lowered: |
| return "ci" |
| if "rotator" in lowered or "lambda" in lowered: |
| return "rotator" |
| if lowered in {"alice", "dave"} or "admin" in lowered or "security" in lowered: |
| return "cloud-admin" if lowered == "alice" else ("security" if lowered == "dave" else "operator") |
| if lowered == "bob" or "dev" in lowered: |
| return "developer" |
| if lowered == "carol" or "contract" in lowered: |
| return "contractor" |
| if kind == ActorKind.SERVICE.value: |
| return "service" |
| if kind == ActorKind.HUMAN.value: |
| return "human" |
| return "unknown" |
|
|
|
|
| def _request(row: dict[str, Any]) -> Any: |
| if "requestParameters" in row: |
| return row.get("requestParameters") |
| if "request_parameters" in row: |
| return row.get("request_parameters") |
| return row.get("request") or {} |
|
|
|
|
| def _response(row: dict[str, Any]) -> Any: |
| if "responseElements" in row: |
| return row.get("responseElements") |
| if "response_elements" in row: |
| return row.get("response_elements") |
| return row.get("response") or {} |
|
|
|
|
| def resource_from(event_name: str, request: Any, row: dict[str, Any]) -> tuple[str, str]: |
| params = request if isinstance(request, dict) else {} |
| resources = row.get("resources") if isinstance(row.get("resources"), list) else [] |
| candidates = [ |
| ("bucket", params.get("bucketName") or params.get("bucket")), |
| ("role", params.get("roleName") or params.get("roleArn")), |
| ("user", params.get("userName") or params.get("userArn")), |
| ("security-group", params.get("groupId") or params.get("groupName")), |
| ("trail", params.get("name") or params.get("trailName")), |
| ("kms-key", params.get("keyId") or params.get("keyArn")), |
| ("instance", params.get("instanceId")), |
| ("detector", params.get("detectorId")), |
| ("config", params.get("configRuleName") or params.get("roleARN")), |
| ] |
| for kind, value in candidates: |
| if value: |
| return kind, normalize_id(value).split("/")[-1] |
| if resources: |
| first = resources[0] if isinstance(resources[0], dict) else {} |
| arn = normalize_id(first.get("ARN") or first.get("arn")) |
| return normalize_id(first.get("type") or "resource"), arn.rsplit("/", 1)[-1] or arn |
| existing = normalize_id(row.get("resource_alias") or row.get("resource")) |
| if existing: |
| return normalize_id(row.get("resource_kind") or "resource"), existing |
| return "account", event_name or "unknown" |
|
|
|
|
| def user_agent_class(value: Any) -> str: |
| text = normalize_id(value).lower() |
| if "console.amazonaws.com" in text or "signin.amazonaws.com" in text: |
| return "console" |
| if "terraform" in text: |
| return "terraform" |
| if "aws-cli" in text or "awscli" in text: |
| return "cli" |
| if "boto" in text or "sdk" in text: |
| return "sdk" |
| if not text: |
| return "unknown" |
| return "other" |
|
|
|
|
| def normalize_event(row: dict[str, Any]) -> dict[str, Any]: |
| identity = _identity(row) |
| request = _request(row) |
| response = _response(row) |
| incomplete = request in (None, "", {}) and not row.get("request_summary") |
| kind = actor_kind_of(identity) if not row.get("actor_kind") else normalize_id(row.get("actor_kind")) |
| name = actor_name_of(identity) if not row.get("actor_alias") else normalize_id(row.get("actor_alias")) |
| account = alias_account( |
| identity.get("accountId") |
| or row.get("recipientAccountId") |
| or row.get("account_alias") |
| or row.get("account") |
| ) |
| event_name = normalize_id(row.get("eventName") or row.get("event_name")) |
| event_source = normalize_id(row.get("eventSource") or row.get("event_source") or "") |
| change_type = classify_event(event_name, kind, request) |
| if row.get("change_type") and normalize_id(row.get("change_type")) in {item.value for item in ChangeType}: |
| change_type = ChangeType(normalize_id(row.get("change_type"))) |
| flags = flags_from_request(change_type.value, event_name, request, kind) |
| resource_kind, resource_name = resource_from(event_name, request, row) |
| request_text = redact_text(compact_json(request) or normalize_id(row.get("request_summary"))) |
| response_text = redact_text(compact_json(response) or normalize_id(row.get("response_summary"))) |
| error_code = normalize_id(row.get("errorCode") or row.get("error_code")) |
| read_only = row.get("readOnly") if "readOnly" in row else row.get("read_only", False) |
| if isinstance(read_only, str): |
| read_only = read_only.lower() in {"1", "true", "yes"} |
| actor_alias = alias_actor(kind, name, account) |
| return { |
| "event_id": normalize_id(row.get("eventID") or row.get("event_id") or row.get("eventId")), |
| "timestamp": normalize_id(row.get("eventTime") or row.get("timestamp") or row.get("time")), |
| "account_alias": account, |
| "actor_alias": actor_alias, |
| "actor_kind": kind, |
| "actor_role": normalize_id(row.get("actor_role")) or actor_role_of(kind, name), |
| "event_source": event_source, |
| "event_name": event_name, |
| "change_type": change_type.value, |
| "region": normalize_id(row.get("awsRegion") or row.get("region") or "us-east-1"), |
| "resource_alias": alias_resource(resource_kind, resource_name), |
| "resource_kind": resource_kind, |
| "read_only": bool(read_only), |
| "error_code": error_code, |
| "console": user_agent_class(row.get("userAgent") or row.get("user_agent")) == "console", |
| "user_agent_class": user_agent_class(row.get("userAgent") or row.get("user_agent")), |
| "source_ip_alias": alias_ip(row.get("sourceIPAddress") or row.get("source_ip") or row.get("ip")), |
| "request_summary": request_text[:500], |
| "response_summary": response_text[:400], |
| "change_ticket": normalize_id(row.get("change_ticket") or row.get("ticket") or ""), |
| "lab_event_id": normalize_id(row.get("lab_event_id") or ""), |
| "lab_family": normalize_id(row.get("lab_family") or ""), |
| "split": normalize_id(row.get("split") or ""), |
| "incomplete": bool(incomplete or row.get("incomplete")), |
| "cidr_open": flags["cidr_open"], |
| "policy_public": flags["policy_public"], |
| "admin_policy": flags["admin_policy"], |
| "logging_off": flags["logging_off"], |
| "detector_off": flags["detector_off"], |
| "wildcard_trust": flags["wildcard_trust"], |
| "hardening": flags["hardening"], |
| "redacted": looks_sensitive(row), |
| "raw_redacted": { |
| "eventName": event_name, |
| "eventSource": event_source, |
| "eventTime": normalize_id(row.get("eventTime") or row.get("timestamp")), |
| "userIdentity": { |
| "type": identity.get("type"), |
| "userName": actor_alias, |
| "accountId": account, |
| }, |
| "requestParameters": request_text[:500], |
| "errorCode": error_code or None, |
| }, |
| } |
|
|
