0Pricing
Cloud & IT Cert Prep · Lesson

Lateral Movement: Pass-the-Hash and Pass-the-Ticket

Understand how attackers reuse NTLM hashes and Kerberos tickets to move laterally without knowing plaintext passwords, and the defenses that stop them.

Lateral Movement: Pass-the-Hash and Pass-the-Ticket is a free Cloud & IT Cert Prep lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Cloud & IT Cert Prep learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Lateral Movement: Spreading Through the Network

Lateral movement refers to techniques attackers use to progressively move through a network after establishing an initial foothold, aiming to reach higher-value targets such as domain controllers, databases, and administrative workstations. Unlike initial access (which usually targets a single endpoint), lateral movement exploits trust relationships between systems — authentication mechanisms, shared credentials, network connectivity, and administrative tools — that legitimate users rely on daily. Effective lateral movement allows a single compromised low-privilege account to eventually reach every system in an environment.

How Windows Authentication Works: NTLM

NTLM (NT LAN Manager) is a legacy Windows authentication protocol based on a challenge-response mechanism. When a client authenticates to a server, the server sends a random challenge; the client responds by hashing the challenge with the user's NT hash (a fixed hash derived from the password). The critical design flaw: the NT hash itself is sufficient to authenticate — not the password. The NT hash is stored in the Security Account Manager (SAM) database on workstations and in NTDS.DIT on domain controllers. If an attacker obtains the NT hash, they can authenticate as that user without ever knowing the password.

# NT hash example: MD4 of Unicode password
# Password 'Password123' -> NT hash: 58a478135a93ac3bf058a5ea0e8fdb71
# This hash alone is sufficient for NTLM authentication
# An attacker with the hash can authenticate to any service accepting NTLM

Pass-the-Hash (PtH): Authentication Without Passwords

Pass-the-Hash (PtH) is an attack technique where an attacker uses a captured NTLM hash to authenticate to other systems without knowing the underlying plaintext password. After compromising one system and extracting hashes from memory (LSASS) or the SAM database, the attacker replaces their own credential material with the stolen hash in authentication requests. This is particularly devastating because shared local administrator passwords (common in environments without LAPS) mean one hash compromises hundreds or thousands of machines. Tools like Mimikatz, Impacket's psexec.py, and CrackMapExec automate PtH attacks.

# PtH attack using Impacket's psexec (attacker tool - for understanding defenses)
# psexec.py -hashes :58a478135a93ac3bf058a5ea0e8fdb71 administrator@192.168.1.100

# This grants an interactive shell on 192.168.1.100 WITHOUT knowing the password
# Using only the NTLM hash extracted from a previously compromised system

Defending Against Pass-the-Hash

Several mitigations reduce PtH attack effectiveness: Local Administrator Password Solution (LAPS) — Microsoft's tool that assigns unique, rotated local admin passwords to each machine, so a hash stolen from one machine only unlocks that machine; Credential Guard (Windows 10/11) — uses virtualization-based security to isolate LSASS in a secure enclave where hashes cannot be extracted; Disabling NTLM in favor of Kerberos where possible; restricting administrative access through Privileged Access Workstations (PAWs) and tiered admin models; and Protected Users security group in Active Directory that prevents hash caching for member accounts.

# Check if LAPS is deployed on a domain
# Look for the ms-Mcs-AdmPwd attribute on computer objects
Get-ADComputer -Filter * -Properties ms-Mcs-AdmPwd | 
  Where {$_.'ms-Mcs-AdmPwd' -ne $null} | 
  Select-Object Name, 'ms-Mcs-AdmPwd'

Kerberos Overview: How Tickets Work

Kerberos is the default authentication protocol in Active Directory environments and avoids sending passwords or hashes over the network by using encrypted tickets. The process: (1) the client authenticates to the Key Distribution Center (KDC) — a role held by the domain controller — and receives a Ticket Granting Ticket (TGT) encrypted with the KRBTGT account's hash; (2) when the client needs to access a service, it presents the TGT to receive a Service Ticket (TGS/ST) encrypted with the target service's key; (3) the client presents the service ticket to the target, which validates it without contacting the KDC. Tickets have a default lifetime of 10 hours.

# View current Kerberos tickets on Windows
klist
# Output shows:
# Ticket cache: API:...
# Server: krbtgt/DOMAIN.COM
# Encryption type: AES-256
# Expiration date: <timestamp>

Pass-the-Ticket (PtT): Stealing Kerberos Tickets

Pass-the-Ticket (PtT) is the Kerberos equivalent of Pass-the-Hash: an attacker extracts a valid Kerberos ticket from a compromised system's memory and imports it into their own session to authenticate as the ticket's owner. Kerberos tickets are stored in memory on Windows and can be extracted with Mimikatz's kerberos::list and kerberos::ptt commands. Stolen TGTs are most valuable because they can be used to request service tickets for any service the ticket's owner can access. Stolen Service Tickets (TGS) are more limited — they only grant access to the specific service they were issued for.

# PtT attack: export and import tickets with Mimikatz
# On compromised system:
# mimikatz# kerberos::list /export   <- dumps all tickets to .kirbi files

# On attacker system:
# mimikatz# kerberos::ptt ticket.kirbi  <- injects stolen ticket
# Now authenticated as the ticket's owner for its service

Over-Pass-the-Hash: Upgrading Hash to Ticket

Over-Pass-the-Hash (oPtH), also called Pass-the-Key, bridges the gap between NTLM hash theft and Kerberos ticket acquisition. An attacker uses a stolen NT hash or AES key to request a Kerberos TGT from the domain controller, even without knowing the plaintext password. This converts a stolen hash into a full Kerberos TGT, granting all the flexibility of PtT attacks. This technique is valuable because many organizations have disabled NTLM in favor of Kerberos — oPtH allows hash-based attacks to succeed against Kerberos-only environments. Mimikatz implements this as sekurlsa::pth.

Lateral Movement Protocols: SMB, WMI, and RDP

Attackers use several protocols to move laterally with stolen credentials or tickets: SMB (Server Message Block) allows executing commands remotely via PsExec, providing remote file access and service creation; WMI (Windows Management Instrumentation) allows remote command execution and is heavily used by both administrators and attackers due to its ubiquity and logging gaps; RDP (Remote Desktop Protocol) provides an interactive desktop session; and WinRM/PowerShell Remoting allows executing PowerShell commands on remote systems. Defenders should baseline which systems legitimately use these protocols and alert on anomalous usage patterns.

# Detection: look for unusual SMB authentication from workstations
# Windows Security Event ID 4624: successful logon
# Windows Security Event ID 4648: explicit credential use
# Splunk query:
# index=windows EventCode=4624 LogonType=3 WorkstationName!='DOMAIN\server*'
#   NOT [whitelist of servers]
# | stats count by Computer, AccountName, IpAddress

BloodHound: Visualizing Attack Paths

BloodHound is an open-source tool used by both red teamers and defenders to visualize Active Directory privilege escalation and lateral movement paths. It collects relationship data (who is a member of which group, who has admin rights on which machine, which accounts have delegation enabled) and displays it as a graph where nodes are users/machines/groups and edges are permissions. BloodHound's 'Find Shortest Paths to Domain Admins' query can show attackers — and defenders — exactly which sequence of compromises could lead to full domain control. Defenders use BloodHound to eliminate unnecessary privilege paths before attackers exploit them.

# Run BloodHound collector (SharpHound) on domain
# SharpHound.exe -c All --outputdirectory C:\Temp
# Outputs JSON files imported into BloodHound Neo4j database

# Key queries for defenders:
# - Find all Domain Admins
# - Find Shortest Paths to Domain Admins
# - Find Principals with DCSync Rights

Detecting Lateral Movement

Detecting lateral movement requires correlating events across multiple systems. Key detection signals: Windows Event ID 4648 (logon with explicit credentials — common in PtH/PtT); Event ID 4769 (Kerberos service ticket requested — abnormal if requesting tickets for rarely-accessed services); Event ID 7045/4697 (new service installed — common in PsExec-based lateral movement); unusual administrative tool usage from non-admin workstations (wmic.exe, psexec.exe); and SMB authentication anomalies where workstations authenticate to other workstations (normal traffic flows from workstations to servers, not peer-to-peer). EDR platforms with behavioral detection catch these patterns across the network.

Tiered Administration Model

The tiered administration model (Microsoft's recommended Active Directory design) prevents credential theft from one tier from compromising higher tiers: Tier 0 (identity control plane — domain controllers, Azure AD) — only Tier 0 admin accounts can administer these, and these accounts never log into Tier 1 or 2 systems; Tier 1 (servers and cloud services) — dedicated Tier 1 admin accounts; Tier 2 (workstations and devices) — helpdesk and standard admin accounts. By isolating credentials into tiers, a compromised workstation admin account cannot be used to attack domain controllers. This directly counters PtH and PtT lateral movement.

Quick Check

Test your understanding of CompTIA Security+ (SY0-701) concepts from this lesson.

Lesson Recap

In this lesson you learned: Pass-the-Hash exploits NTLM's hash-as-credential design — the NT hash alone authenticates without the password, defeated primarily by LAPS and Credential Guard, Pass-the-Ticket steals valid Kerberos tickets from memory to authenticate as another user, with stolen TGTs being particularly powerful as they can generate service tickets for any service, and the tiered administration model prevents credential theft at one tier from enabling lateral movement to higher-privilege tiers. Next up we explore Kerberoasting and Golden Ticket attacks targeting Active Directory's Kerberos implementation.

Frequently asked questions

Is the “Lateral Movement: Pass-the-Hash and Pass-the-Ticket” lesson free?

Yes — the full text of “Lateral Movement: Pass-the-Hash and Pass-the-Ticket” is free to read here on the web, and the Cloud & IT Cert Prep course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Cloud & IT Cert Prep course, upgrade to CoddyKit PRO.

What will I learn in “Lateral Movement: Pass-the-Hash and Pass-the-Ticket”?

Understand how attackers reuse NTLM hashes and Kerberos tickets to move laterally without knowing plaintext passwords, and the defenses that stop them. You practise Cloud & IT Cert Prep with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Cloud & IT Cert Prep?

No prior experience is required. Cloud & IT Cert Prep on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Lateral Movement: Pass-the-Hash and Pass-the-Ticket” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Cloud & IT Cert Prep lesson?

Yes. Every Cloud & IT Cert Prep lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. APT Lifecycle: Initial Access to Persistence
  2. Lateral Movement: Pass-the-Hash and Pass-the-Ticket
  3. Kerberoasting and Golden Ticket Attacks
  4. MITRE ATT&CK Framework for Detection and Response
← Back to Cloud & IT Cert Prep