SOP-95: Kerberoasting (Service Ticket Roasting) Response | CyberHawk Threat Intel

·

Kerberoasting is one of the most common Active Directory attacks a SOC will ever triage. Any authenticated domain user can request a Kerberos service ticket (TGS) for any account that has a Service Principal Name (SPN) registered. The encrypted portion of that ticket is sealed with the service account's password hash — so an attacker who harvests the ticket can crack it offline, at their own pace, with no further contact with the domain and no lockout risk. Weak service-account passwords fall in minutes.

The attack is dangerous precisely because it is quiet: requesting a service ticket is normal Kerberos behaviour, so the malicious request looks almost identical to legitimate traffic. The tells are volume (one principal requesting tickets for many distinct SPNs in a short window), cipher downgrade (RC4-HMAC / 0x17 requested even when the domain supports AES), and target selection (user service accounts, not machine accounts).

Key data sources: SecurityEvent 4769 (Kerberos service-ticket request on Domain Controllers), SecurityEvent 4768 (TGT request), DeviceProcessEvents (roasting tool execution on the source host), and Microsoft Defender for Identity (built-in Kerberoasting alert).

☰ Table of Contents

01 Background 02 Identification 03 Containment 04 Eradication 05 Escalation
🛠

01 — BACKGROUND

TECHNIQUE OVERVIEW
01
Technique Overview — Kerberoasting
MITRE T1558.003

Kerberoasting (T1558.003) is a credential-access technique. Any account that can authenticate to the domain can send a TGS-REQ (service-ticket request) to the KDC for a target SPN. The KDC returns a service ticket whose encrypted body is protected with the long-term key of the SPN's owning account — for a user-based service account, that key is derived from the account password. The attacker extracts the encrypted blob and runs an offline dictionary/brute-force attack (e.g. hashcat mode 13100 for RC4, 19600/19700 for AES). Because cracking happens off-domain, there is no authentication failure, no lockout, and no further network noise — this is what makes it a favourite privilege-escalation stepping stone.

FieldValue
MITRE TechniqueT1558.003 — Steal or Forge Kerberos Tickets: Kerberoasting
Kill-chain PhaseCredential Access → Privilege Escalation
Primary Log SourceSecurityEvent 4769 (TGS request, logged on Domain Controllers)
Secondary Log SourcesSecurityEvent 4768 (TGT), DeviceProcessEvents (tooling), Microsoft Defender for Identity Kerberoasting alert, SecurityEvent 4662 (LDAP SPN enumeration)
Common ToolingRubeus (kerberoast), Impacket GetUserSPNs.py, PowerView Invoke-Kerberoast / Get-DomainUser -SPN, mimikatz kerberos::list /export, setspn.exe -q
Decisive FieldsTicketEncryptionType (0x17 = RC4 crackable), ServiceName (SPN account), TargetUserName (requester), IpAddress (source), Status (0x0 = success)
Default SeveritySEV2 — escalates to SEV1 if a privileged service account is roasted
Detection WindowQuery last 6 hours minimum; extend to 7 days for hunting

The stolen ticket is already off the wire by the time you triage the 4769 alert. You cannot "un-steal" it — the encrypted hash is on the attacker's cracking rig. Containment for Kerberoasting is therefore RESET THE ROASTED SERVICE ACCOUNT PASSWORD, not just isolate a host. Assume every roasted account with a weak password is compromised.

02
Attack Paths, Log Sources & Severity Model
CONTEXT

Five concrete paths a SOC actually sees. Grade severity by which account was roasted, not by the raw request count.

#Attack PathWhat You See
A1Foothold → mass SPN roastCompromised standard user enumerates all SPN accounts, requests RC4 TGS for every one in a single burst (Rubeus/GetUserSPNs)
A2Targeted high-value roastAttacker roasts only a handful of specific accounts known to be privileged (SQL service, backup service, accounts in admin groups)
A3RC4 downgradeDomain supports AES but the attacker forces RC4 (0x17) requests because RC4 hashes crack far faster than AES
A4Low-and-slow roastTickets requested a few at a time over hours/days to stay under volume thresholds
A5Benign look-alike (FP)Vulnerability scanner, SCCM, or a legacy app that legitimately requests many RC4 service tickets on a schedule
SeveritySignal
LOW / FPSmall number of RC4 tickets from a known service host or scanner matching a documented schedule; machine-account SPNs only
SEV2Burst of RC4 (0x17) TGS for 5+ distinct user SPN accounts from one non-DC source in a short window, no change ticket
SEV1Any roasted account is privileged (Domain/Enterprise Admin, or member of a Tier-0 group), OR a roasted service account subsequently logs on from an unusual host (crack succeeded)

Highest-value targets are user accounts with an SPN that are ALSO members of privileged groups — a single crack there is a direct domain-privilege win. Hunt your own directory for these before an attacker does: they should have 25+ char passwords or be gMSA.

🔍

02 — IDENTIFICATION

5 INDICATORS
▶ Investigation Workflow
I0
Alert Triage Checklist
30-SEC GATE
WHY CHECK

Kerberoasting fires as either a Sentinel scheduled-rule hit on 4769 or a Microsoft Defender for Identity "Suspected Kerberoasting" alert. Answer these five before opening a full investigation — they decide whether this queues or pages.

  • 1Is the ticket encryption type RC4 (0x17) while the domain otherwise issues AES? (downgrade = suspicious)
  • 2Did a single requester / source IP pull tickets for 5+ distinct SPN accounts in a short window?
  • 3Are the target SPNs user accounts (not machine accounts ending in $)? Machine SPNs are far less interesting to roast.
  • 4Is the source host a workstation / non-service system rather than a known scanner or app server?
  • 5Is any roasted account privileged (Domain Admin, Tier-0, high-value service)? If yes → treat as SEV1 immediately.

If Microsoft Defender for Identity raised the alert, open it first — MDI already correlates the source account, source host and the list of requested SPNs, saving you the initial 4769 join.

I1
4769 RC4 Service-Ticket Burst (Core Signal)
MANUAL + KQL
WHY CHECK

The defining footprint of Kerberoasting is one principal requesting RC4-encrypted service tickets for many distinct user SPNs in a short window. Normal clients request a ticket for the one or two services they actually use — not a sweep of every SPN in the directory.

📍 Portal Navigation — Microsoft Sentinel
portal.azure.com› Microsoft Sentinel› Logs› New Query
  • 1Open Microsoft Sentinel → Logs (or Defender XDR → Advanced Hunting if 4769 is ingested there).
  • 2Paste the KQL below. Set the time range to Last 6 hours, expand to 7 days when hunting.
  • 3Read the DistinctSPNs and SPNs columns — a single Account/IpAddress pulling many SPNs is the primary tell.
  • 4Note the IpAddress (source host) and the requesting Account — these feed Containment C3 and the tooling hunt I4.
TicketEncryptionTypeMeaningCrack Posture
0x17RC4-HMAC — legacy, keyed off NTLM hashCRACKABLE (hashcat 13100) — top roast target
0x18RC4-HMAC-EXP (export) — legacy RC4 variantCRACKABLE — treat like 0x17
0x11AES128-CTS-HMAC-SHA1-96Crackable but far slower (hashcat 19600)
0x12AES256-CTS-HMAC-SHA1-96Strongest — slow to crack (hashcat 19700)
0x1 / 0x3DES (should never appear in a modern domain)Trivially crackable — investigate why DES is enabled
DETECTS: one account/source requesting RC4 (0x17) TGS for 5+ distinct user-SPN accounts inside a 10-minute bucket — the canonical Kerberoasting sweep
KQL — Microsoft Sentinel / Defender XDR (Security Events via AMA)
SecurityEvent | where TimeGenerated > ago(6h) | where EventID == 4769 | where Status == "0x0" // successful ticket issuance | where TicketEncryptionType in ("0x17","0x18") // RC4 downgrade — the crackable ciphers | where ServiceName !endswith "$" // exclude machine-account SPNs | where ServiceName !in~ ("krbtgt") | where TargetUserName !endswith "$" // exclude computer-account requesters | summarize DistinctSPNs = dcount(ServiceName), SPNs = make_set(ServiceName, 60), Requests = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated) by TargetUserName, IpAddress, bin(TimeGenerated, 10m) | where DistinctSPNs >= 5 | order by DistinctSPNs desc
DETECTS: Splunk equivalent — same RC4 4769 sweep, bucketed per requester + source
SPL — Splunk
index=wineventlog (EventCode=4769) Ticket_Encryption_Type IN ("0x17","0x18") Status=0x0 | search Service_Name!="*$" Account_Name!="*$" Service_Name!="krbtgt" | bin _time span=10m | stats dc(Service_Name) as DistinctSPNs values(Service_Name) as SPNs count as Requests min(_time) as FirstSeen max(_time) as LastSeen by Account_Name, Client_Address, _time | where DistinctSPNs>=5 | sort - DistinctSPNs

Do NOT dismiss a hit just because the count is low. A targeted attacker (A2) roasts only the two or three accounts they already know are privileged. A single RC4 TGS for a Domain-Admin service account with no matching business reason is more serious than a 40-SPN sweep of low-value accounts.

I2
Privileged-SPN Targeting & RC4 Downgrade
MANUAL + KQL
WHY CHECK

Severity is decided by which account was roasted. A roasted account that is a member of a privileged group is a domain-compromise-in-waiting the moment its password cracks. Also confirm whether RC4 was forced while the domain supports AES — that downgrade is a deliberate cracking-speed optimisation, not accidental.

📍 Portal Navigation — Enrich in AD / Entra
Active Directory Users & Computers› [Roasted SPN account]› Member Of
  • 1For every ServiceName from I1, check group membership in ADUC → account → Member Of, or run Get-ADUser <svc> -Properties MemberOf,servicePrincipalName,msDS-SupportedEncryptionTypes.
  • 2Flag any roasted account in Domain Admins, Enterprise Admins, Administrators, Account Operators, or a Tier-0 group — that is an automatic SEV1.
  • 3Check msDS-SupportedEncryptionTypes on the account and the domain policy — if AES is supported but the ticket came back RC4 (0x17), the requester downgraded on purpose.
DETECTS: RC4 service-ticket requests whose target SPN account matches a watchlist of privileged / Tier-0 service accounts
KQL — join 4769 to a privileged-account watchlist
let PrivSvcAccounts = _GetWatchlist("Tier0ServiceAccounts") | project SamAccountName = tolower(SamAccountName); SecurityEvent | where TimeGenerated > ago(7d) | where EventID == 4769 and Status == "0x0" | where TicketEncryptionType in ("0x17","0x18") | extend Svc = tolower(trim_end("$", ServiceName)) | where Svc in (PrivSvcAccounts) | project TimeGenerated, TargetUserName, IpAddress, ServiceName, TicketEncryptionType, TicketOptions | order by TimeGenerated desc
DETECTS: Splunk — RC4 4769 whose Service_Name matches a privileged-service-account lookup table
SPL — Splunk (lookup join)
index=wineventlog EventCode=4769 Status=0x0 Ticket_Encryption_Type IN ("0x17","0x18") | eval Svc=lower(replace(Service_Name,"\$","")) | lookup tier0_service_accounts sam_account_name AS Svc OUTPUT tier | where tier="tier0" | table _time Account_Name Client_Address Service_Name Ticket_Encryption_Type Ticket_Options | sort - _time

No watchlist yet? Build one now: Get-ADUser -LDAPFilter "(servicePrincipalName=*)" -Properties MemberOf | where MemberOf -match "Admin" gives you every SPN account in a privileged group. These are your crown-jewel roast targets — protect them first.

I3
SPN Enumeration Precursor
MANUAL + KQL
WHY CHECK

Before roasting, an attacker must discover which accounts have SPNs. That discovery is an LDAP query for the servicePrincipalName attribute, or a setspn -q run. Finding the enumeration immediately before the 4769 burst confirms intent and pins the source host.

📍 Portal Navigation — Defender XDR Advanced Hunting
security.microsoft.com› Hunting› Advanced Hunting
  • 1Run the DeviceProcessEvents query below on the source host identified in I1.
  • 2Correlate timing: SPN enumeration a few seconds/minutes before the ticket burst is a confirmed roast chain.
  • 3If SecurityEvent 4662 (directory object access) is collected, look for the requester reading servicePrincipalName across many user objects.
DETECTS: SPN discovery commands (setspn, PowerView Get-DomainUser -SPN, Get-ADUser servicePrincipalName filter) on the source host
KQL — SPN enumeration on source host
DeviceProcessEvents | where Timestamp > ago(7d) | where ProcessCommandLine has_any ( "setspn","-q","servicePrincipalName","Get-DomainUser","Get-NetUser", "GetUserSPNs","-Filter {ServicePrincipalName","Find-DomainUserLocation") and ProcessCommandLine has_any ("SPN","servicePrincipalName","spn ","-q") | project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName, InitiatingProcessCommandLine | order by Timestamp asc
DETECTS: Splunk — same SPN-enumeration command lines from Sysmon/EDR process telemetry
SPL — Splunk
index=edr sourcetype=*ProcessEvents (Process_Command_Line="*setspn*-q*" OR Process_Command_Line="*servicePrincipalName*" OR Process_Command_Line="*Get-DomainUser*-SPN*" OR Process_Command_Line="*GetUserSPNs*") | table _time DeviceName Account_Name Process_Name Process_Command_Line Parent_Process_Name | sort _time
I4
Roasting Tool Execution on Source Host
MANUAL + KQL
WHY CHECK

The 4769 tells you a ticket was requested; the source host tells you what did the requesting. Rubeus, Impacket GetUserSPNs, Invoke-Kerberoast and mimikatz leave recognisable command lines. Confirming the tool converts "suspicious volume" into "confirmed attacker tooling".

📍 Portal Navigation — Defender XDR Advanced Hunting
security.microsoft.com› Hunting› Advanced Hunting
  • 1Run the query below scoped to the source DeviceName from I1 across the last 7 days.
  • 2Open the Device Timeline for any hit to reconstruct the full session — download, execution, and any follow-on credential-dumping.
  • 3Capture file hashes for the tool binaries and add them to the IOC list (I5) and MDE custom indicators (Containment).
Tool / SignatureMeaningConfidence
rubeus kerberoastRubeus roasting module — mass or targeted TGS request + hash exportHIGH
GetUserSPNs.py / -requestImpacket Kerberoasting — remote, often from Linux attacker hostHIGH
Invoke-KerberoastPowerView/Empire in-memory roasterHIGH
/tgtdeleg /rc4opsec /nowrapRubeus flags forcing RC4 / hash formatting for hashcatHIGH
kerberos::list /exportmimikatz exporting cached tickets to .kirbi for offline crackMEDIUM
DETECTS: Kerberoasting tool execution — Rubeus, Impacket GetUserSPNs, Invoke-Kerberoast, mimikatz ticket export
KQL — roasting tooling
DeviceProcessEvents | where Timestamp > ago(7d) | where ProcessCommandLine has_any ( "kerberoast","GetUserSPNs","Invoke-Kerberoast","Rubeus", "tgtdeleg","rc4opsec","asktgs","kerberos::list /export", "Request-SPNTicket","klist") and ProcessCommandLine has_any ("kerberoast","GetUserSPNs","Rubeus","tgtdeleg","asktgs",".kirbi","/export") | project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName, SHA256 | order by Timestamp desc
DETECTS: Splunk — Kerberoasting tool command-line signatures on the source endpoint
SPL — Splunk
index=edr sourcetype=*ProcessEvents (Process_Command_Line="*kerberoast*" OR Process_Command_Line="*GetUserSPNs*" OR Process_Command_Line="*Invoke-Kerberoast*" OR Process_Command_Line="*Rubeus*" OR Process_Command_Line="*tgtdeleg*" OR Process_Command_Line="*kerberos::list*/export*") | table _time DeviceName Account_Name Process_Name Process_Command_Line SHA256 | sort - _time

Impacket GetUserSPNs runs from a REMOTE (often Linux) attacker host, so there may be NO process telemetry on any managed Windows endpoint. In that case I1's 4769 IpAddress is your only source pointer — pivot to network / NAC to identify the device before it disappears.

I5
Post-Crack Logon, IOC Extraction & FP/TP Gate
MANUAL + KQL
WHY CHECK

If the password cracked, the attacker's next move is to authenticate as the service account. A service account — normally used only by a service on a fixed host — suddenly performing an interactive/network logon from a new host is the strongest possible confirmation that the roast succeeded. This flips the incident from "attempted" to "confirmed compromise".

DETECTS: a roasted service account authenticating from an unusual host or with an interactive logon type it never normally uses
KQL — anomalous logon of a roasted service account
let RoastedAccounts = dynamic(["svc-sql","svc-backup","svc-app"]); // populate from I1 SecurityEvent | where TimeGenerated > ago(7d) | where EventID in (4624, 4768) | where tolower(TargetUserName) in (RoastedAccounts) | where LogonTypeName has_any ("Interactive","RemoteInteractive") or EventID == 4768 | summarize Logons = count(), Hosts = make_set(Computer, 20), IPs = make_set(IpAddress, 20) by TargetUserName, bin(TimeGenerated, 1h) | order by TimeGenerated desc
DETECTS: Splunk — roasted service account logging on interactively or from a new source host
SPL — Splunk
index=wineventlog (EventCode=4624 OR EventCode=4768) Account_Name IN ("svc-sql","svc-backup","svc-app") | search (Logon_Type=2 OR Logon_Type=10 OR EventCode=4768) | stats count as Logons values(ComputerName) as Hosts values(Source_Network_Address) as IPs by Account_Name | sort - Logons

IOCs to extract and record:

  • 1Requesting account (TargetUserName) and source host / IpAddress from I1.
  • 2Full list of roasted ServiceName SPN accounts (these all need password resets).
  • 3Roasting tool file paths + SHA256 from I4; the encryption type(s) observed.
  • 4Time window (first-to-last 4769) and any post-crack logon host/IP from this step.
True Positive SignalsFalse Positive Signals
RC4 (0x17) forced while domain supports AESOnly AES (0x11/0x12) tickets, matching normal service startup
5+ distinct user-SPN accounts from one requester in minutesMany tickets but from a known vuln scanner on its documented schedule
SPN enumeration (I3) or roasting tooling (I4) on the source hostSource is a legitimate app/SCCM server with a change record
Roasted account is privileged, or logs on from a new host afterMachine-account ($) SPNs only; no interactive follow-on logon
Requester is a standard user with no service roleRequester = the service's own host requesting its own ticket

"It's probably the vulnerability scanner" is a hypothesis, not a verdict. Confirm it against the scanner's asset IP AND its documented scan schedule before closing. Attackers deliberately run roasts during scan windows to hide in the noise.

🚫

03 — CONTAINMENT

STOP IT
C1
Verdict & Containment Decision
DECISION GATE
▶ Based on Identification Findings — Select One
CONFIRMED RC4 burst for multiple user SPNs + enumeration/tooling on source, OR a privileged account roasted, OR post-crack logon seen — reset roasted account passwords NOW, isolate source host, page L2/IR
UNCERTAIN Volume anomaly but no tooling confirmed and source not yet identified — complete I3/I4, identify the source device, hold; reset any privileged roasted account as a precaution
FALSE POSITIVE Tickets match a documented scanner/service on its schedule, machine-account SPNs only, no follow-on logon — document, close, tune the rule to except the source

The clock started when the ticket left the DC. Every hour a weak-password service account stays un-reset is an hour the attacker has to finish cracking. Treat password reset of confirmed roasted accounts as the first, not the last, containment action.

C2
Reset Roasted Service Account Passwords
CREDENTIAL CONTAINMENT
📍 Portal Navigation — Reset in AD
Active Directory Users & Computers› [Roasted service account]› Reset Password
  • 1For EVERY roasted ServiceName from I1, reset the password to a 25+ character random secret (attackers cannot dictionary-crack a long random key). Coordinate with the app owner to update the service config in the same change.
  • 2Prioritise any privileged roasted account — reset it first, then revoke its Kerberos tickets by resetting twice if it is highly sensitive.
  • 3Where the account only serves one host and supports it, plan migration to a Group Managed Service Account (gMSA) — the OS rotates a 120+ char key automatically and it cannot be roasted usefully (covered in Eradication).
  • 4Confirm msDS-SupportedEncryptionTypes is set to AES-only on the reset account so the next ticket is no longer RC4.

Do NOT reset the krbtgt account as a reflex here — Kerberoasting does not compromise krbtgt (that is Golden Ticket, SOP-12). Resetting krbtgt is only warranted if you have separate evidence of DC/DA compromise. Reset the ROASTED accounts, not krbtgt.

C3
Contain the Source & the Foothold Account
HOST + IDENTITY
📍 Portal Navigation — MDE / Entra
security.microsoft.com› Assets› Devices› [Source host]› Isolate Device
  • 1Isolate the source host (MDE Actions → Isolate Device) to stop further enumeration, dumping, or lateral movement from the foothold.
  • 2Disable / force-reset the requesting account (TargetUserName from I1) and revoke its sessions — it is the attacker's foothold identity: Entra Users → [user] → Revoke sessions and on-prem reset.
  • 3If the source was a remote/Linux host (Impacket), block its IP at the firewall/NAC and quarantine the device before it detaches.
  • 4Add roasting-tool file hashes (I4) to MDE custom indicators: Settings → Endpoints → Indicators → File → Add.

Kerberoasting is almost never the attacker's first action — it follows an initial foothold. Once contained, pivot to how the requesting account was obtained (phishing SOP-01, infostealer SOP-83, or lateral movement SOP-06).

🗑

04 — ERADICATION

CLEAN UP
E1
Close the Roasting Surface
HARDENING
  • 1Rotate all roastable service-account passwords, not only the ones you observed requested — the attacker may have pulled tickets you did not log. Any user account with an SPN and a <25 char password is exposed.
  • 2Migrate service accounts to gMSA / dMSA where the application supports it. Managed accounts use a 120+ char machine-managed key that is not feasibly crackable, eliminating the roast payoff.
  • 3Enforce AES. Set msDS-SupportedEncryptionTypes to AES-only on service accounts and disable RC4 in the domain where compatibility allows, removing the downgrade path (I1).
  • 4Remove stale/unnecessary SPNs. Every SPN on a user account is an attack surface — deregister SPNs on decommissioned services with setspn -D.
  • 5Remove SPN accounts from privileged groups where possible; a service account rarely needs Domain Admin. Apply least privilege so a future crack yields nothing valuable.
  • 6Clean up the foothold: search for scheduled tasks, run keys, or WMI persistence created by the requesting account/source host around the same window (cross-reference SOP-26 and SOP-30).
E2
Verify Clean State & Reconstruct Timeline
VERIFY
  • 1Re-run I1 (RC4 4769 burst) and I4 (tooling) scoped to the source and requester — expected result is 0 hits after containment.
  • 2Re-run I5 for the roasted accounts — confirm no interactive/new-host logons occur after the password resets.
  • 3Reconstruct the timeline: initial foothold → SPN enumeration (I3) → ticket burst (I1) → any post-crack logon (I5). Note which accounts' hashes left the environment and were therefore at risk.
  • 4Deploy/confirm a standing detection: a Sentinel scheduled rule on the I1 logic, plus the Microsoft Defender for Identity Kerberoasting alert enabled.
Eradication Complete When
  • All roasted (and all roastable) service-account passwords reset to 25+ char / migrated to gMSA
  • AES enforced and RC4 disabled on service accounts where compatible
  • Requesting/foothold account reset, source host reimaged or cleared of tooling and persistence
  • I1 + I4 re-run return 0 hits; I5 shows no post-reset anomalous logon
  • Standing Sentinel rule + MDI Kerberoasting alert active; unnecessary SPNs and privileged-group memberships removed

Do not close on "we reset the one account in the alert." If tickets were roasted, assume the attacker holds hashes for every SPN they enumerated. Rotate the whole roastable set or you will re-open this incident when a second account cracks.

📢

05 — ESCALATION

TIERS
ES1
Escalation Matrix & Notification
ESCALATION
TierTrigger ConditionWho to NotifyAction
L1 → L2RC4 4769 burst confirmed but TP/FP undecided in 30 min, or any privileged account among the SPNs, or 5+ accounts roastedSOC Lead / L2Hand off with I1–I5 output; reset privileged roasted accounts pre-emptively
L2 → IRConfirmed roast with tooling on source, OR post-crack logon of a service account, OR active hands-on-keyboard from the footholdIR Team / Security ManagerFull IR: isolate, reset roastable set, hunt lateral movement
IR → CISOA Domain/Enterprise Admin or Tier-0 service account cracked, OR evidence of domain-wide compromise following the roastCISO / Exec / LegalTreat as potential domain compromise; consider Tier-0 rebuild & krbtgt reset (SOP-12); GDPR/PCI 72h clock if data at risk
ExternalConfirmed data access via a cracked account, regulated data exposed, or attribution/forensics neededMSSP / Forensics / Regulator / Law EnforcementEngage per breach-response policy and legal guidance

Bring to every escalation:

  • 1Incident / alert ID and the requesting account + source host / IP.
  • 2Full list of roasted SPN accounts and which are privileged.
  • 3Timeline (first-to-last 4769), tool + hashes from I4, and any post-crack logon from I5.
  • 4Containment already done (which passwords reset, host isolated) and current confidence (TP confirmed / suspected / unverified).

A single confirmed crack of a privileged, SPN-bearing account is a domain-privilege escalation — route straight to IR + CISO regardless of how few tickets were requested. Ticket count measures noise, not impact; the identity of the roasted account measures impact.


Stay Threat-Ready

Follow CyberHawk Threat Intel for daily SOC analyst playbooks, detection engineering guides, and threat intelligence.

📺 YouTube 🎤 TikTok 🐦 X / Twitter 📡 Telegram
All SOPs Blog Web App (Free)
They can't exploit you if you are the Exploit.