Skip to content

Investigate and remediate a privileged access incident

What you’ll do

You’re Priya Singh, CISO at Acme Corp. It’s 2:14am. Your phone buzzes with an alert from your SIEM: “User dev.torres@example.com performed 47 admin actions in the last 5 minutes from a new IP geolocation (Romania).” Dev is your platform engineer. He’s based in San Francisco. He should be asleep.

This walks the security-shaped scenario — detection through forensic investigation, containment, post-incident review. Time investment: ~30 min during the incident + ~2 hours post-incident write-up.

Phase 1 — Detect (the alert that woke you up)

Your SIEM’s anomaly-detection rules fired. AtmanID streams its audit events to your SIEM (Platform Config → Integrations & API → SIEM), and you wrote these three rules there during the AtmanID rollout — they are your SIEM’s rules, not built-in AtmanID alerts:

  • Geo anomaly: any user-actor action from a NEW country (not seen before in this user’s audit history)
  • Volume anomaly: any user-actor producing >10x their personal baseline of audit events in a 5-minute window
  • Privileged-action burst: any user with >20 privileged actions (e.g., USER_CREATE, ENTITLEMENT_GRANTED, AGENT_REGISTERED) in a 5-minute window

Dev’s session triggered all three simultaneously — high-confidence anomaly. The alert carries the request_ids of the suspicious actions, which you can look up in the AtmanID audit trail.

Phase 2 — Investigate (Iris-driven forensic dig)

Open AtmanID and open Iris. Your first question:

show me every action by actor_email = dev.torres@example.com in the last 60 minutes

Returns 47 rows. Each audit record carries action_type, target_resource_id, ip_address, user_agent, request_id and the timestamp. (For a point-and-click version of the same search, use Security & Risk → Audit & Forensics → Forensics.)

Glance the pattern:

  • First 5 actions (2:09:00 - 2:09:30): LOGIN_SUCCESS, USER_CREATE for “ramos.contractor@contractor.example”, ENTITLEMENT_GRANTED for that new user with Salesforce — System Administrator, ENTITLEMENT_GRANTED for GitHub — Org Admin, ENTITLEMENT_GRANTED for 1Password — Admin Vault
  • Actions 6-47 (2:09:30 - 2:14:00): repeated grants of the same admin entitlements to FIVE more new “contractor” accounts

This is a fresh-account-creation + admin-grant burst. Classic credential-compromise pattern: attacker creates new accounts they control, grants those accounts admin access, then the burst stops because they’ve established persistence.

Confirm with the geolocation check:

show me every action by actor_email = dev.torres@example.com from source_ip not in (192.168.0.0/16, 73.140.0.0/16) in the last 24 hours

The first occurrence of the Romania IP is 2:08:47am — one minute before the burst started. No prior visits from that IP. High confidence: account is compromised.

Phase 3 — Contain (immediate)

Two parallel actions, in this order:

3a. Lock down Dev’s account

emergency lock dev.torres@example.com — reason: incident-2026-05-11-romania-burst, compromised credentials

Iris shows a confirmation card naming the account and the action. Confirm it. AtmanID:

  • Sets the user’s status to LOCKED (an emergency lock — not a termination, which would run the leaver workflow and revoke his access). Entitlements stay in place for forensics.
  • Ends his sessions: every signed-in session (his MacBook in California + the 2 sessions from Romania) stops working on its next request, because the session check requires an ACTIVE account. His outstanding email approve/reject links are revoked too.
  • Audits: ACCOUNT_EMERGENCY_LOCKED with your reason.

(suspend user … does the same with status SUSPENDED and audits USER_SUSPENDED; both are also available as Emergency Lock / Suspend on the user’s Directory page.)

Dev is now locked out. The attacker is also locked out (their session ends the same way).

3b. Reverse the damage — deactivate the rogue accounts

list users created in the last 30 minutes

Returns the 6 contractor accounts. Each is named “ramos.contractor@contractor.example” or similar.

Use Terminate on each rogue account’s Directory page (or ask Iris to offboard ramos.contractor@contractor.example, one account per request, each with its own confirmation — Iris runs the leaver workflow only).

For each terminated account, AtmanID:

  • Contains it immediately: sign-in and live sessions stop and its entitlements are revoked
  • Runs the leaver workflow: connected app accounts (Salesforce, GitHub, …) are deprovisioned through their connectors, disconnected apps get a revocation ticket, and the account ends DEPROVISIONED
  • Audits each step (USER_TERMINATED plus the leaver and revocation records), each with its own request_id

Total elapsed since detection: ~12 minutes. The blast radius is contained.

Phase 4 — Verify containment

Re-query to confirm:

show me any active users where created_at > 1 hour ago

Should return zero. The 6 accounts are SUSPENDED.

show me any ENTITLEMENT_GRANTED audit events from actor_email = dev.torres@example.com in the last 30 minutes that haven't been ENTITLEMENT_REVOKED yet

Should return zero. Every grant has a corresponding revoke. (If any are non-zero — a connector failed; work the open tickets in Identity & Access → Provisioning Queues → Revocation, or revoke by hand in the target system.)

Phase 5 — Investigate the root cause (post-immediate-containment)

Now that the burst is contained, dig into how Dev’s account was compromised:

show me dev.torres login history grouped by source_ip in the last 30 days

Returns IP frequency table. The Romania IP shows only one prior visit — yesterday at 9pm Acme time, one LOGIN_SUCCESS + immediate logout. No actions, no audit-row clusters. That’s likely when the credential was tested.

Pattern: attacker gained creds yesterday, tested them, came back tonight to execute. Common pattern.

Check Dev’s MFA enrollment:

show me dev.torres MFA enrollment status and recent MFA events

If MFA is enrolled, AND the Romania login succeeded — either the attacker bypassed MFA (unlikely given AtmanID’s TOTP enforcement) OR Dev’s MFA device was also compromised (possible if it’s SMS-based; very unlikely if it’s TOTP/passkey).

Most common reality: Dev’s MFA wasn’t enrolled, or was enrolled but bypassed via account-recovery social engineering. The audit trail will show the credential reset attempt if one happened.

Phase 6 — Notify + escalate

In parallel with investigation:

  1. Reach Dev directly (not via email — assume his email is also compromised). Phone call: “I locked your AtmanID account; here’s why; meet me in 30 min.”
  2. Notify your incident response team (other CISO + engineering on-call + legal if customer data was exposed)
  3. Notify the affected target systems (Salesforce/GitHub/1Password admins) with the request_ids of the suspicious grants — they may need to invalidate sessions on their end too
  4. Begin breach-notification timer if customer data was actually exposed (the rogue accounts had Salesforce admin = customer data access; assume yes until proven otherwise)

Phase 7 — Post-incident certification

Within 48 hours of containment:

  1. Audit-trail review — pull every audit row from [2 hours before incident, 1 hour after containment] and review row-by-row. This is the forensic record for any subsequent regulatory disclosure or insurance claim.
  2. Reactivate Dev’s account with fresh credentials + re-enrolled MFA + a forced password change. Reactivation (Unlock on his Directory page, or activate user in Iris) requires a reason and is audited (USER_UNSUSPENDED from the Directory page, USER_ACTIVATED from Iris).
  3. Re-review Dev’s existing entitlements — were any LEGITIMATE grants made that you should re-verify? Launch a small certification campaign that covers Dev (for example a Manager Certification scoped to his department), ~10 entitlements, ~15 minutes.
  4. Assemble the incident evidence for customer notification (if breach reaches notification threshold) or insurance claim — the audit records for the incident window, exported from the audit trail or the audit API with since / until.

Phase 8 — Lessons + harden

Within 7 days:

  1. File the post-mortem in our internal lessons archive if any AtmanID detection or containment didn’t work as expected (e.g., a connector failed to revoke; an audit row was missing actor context; an Iris query returned wrong results)
  2. Update your SIEM alert rules if the incident revealed a gap (e.g., add a “burst of new account creations” rule if you didn’t already have one)
  3. Update incident playbook in internal incident response runbook with anything you did differently from the documented flow
  4. Review the 30-day audit log for similar patterns — does Dev have other accounts that were compromised? Are other engineers showing the same anomaly profile?

What just happened

You converted “incident response is reactive ad-hoc fire-fighting” into:

  • Sub-15-minute containment — detection (alert) → investigation (Iris) → containment (revoke) in one continuous flow
  • Forensic chain by construction — every action audits with request_id; the full incident is one audit query away
  • Bounded blast radius — credentials compromised but cross-tenant defense bounded the damage to your tenant; no other customer affected
  • Compliance-ready evidence — the incident audit trail IS the post-incident report

This is the shape of every privileged-access incident — same flow whether it’s compromised credentials, insider threat, or accidental over-privileged-grant by a legitimate operator.

Common pitfalls during incidents

  • Skipping the confirmation. During an incident, you’ll be tempted to rush past Iris’s confirmation cards. Don’t. The audit record captures how each action was confirmed, which is what demonstrates “the operator deliberately did this.”
  • Reactivating too quickly. Don’t reactivate Dev’s account until you’ve verified MFA is enrolled + credentials are rotated. Premature reactivation = re-compromise.
  • Not notifying target systems. Salesforce/GitHub/1Password admins need to know to invalidate sessions on their end. The connector-level revoke clears the entitlement; in-flight sessions in those tools may persist.
  • Rushing the certification. Quickly running certification “to close the incident” defeats the purpose. Take the 15 minutes; audit each grant.
  • Not filing the post-mortem. Missed lessons are missed lessons forever. Even if everything went perfectly, document it for the next incident.

Adjacent reading

© AtmanID · Privacy