Let us follow one person through one morning. Meera, an accountant at an invented company called Kaveri Textiles, switches on her domain-joined laptop at 9:30 IST, types her password, and opens a shared finance folder on a file server. Three things happen behind that simple sequence, and every well-known Active Directory attack is a way of abusing one of them.

Step one: proving who she is to the key distribution centre

In an Active Directory domain, each domain controller runs the Kerberos key distribution centre, usually shortened to KDC. When Meera logs in, her laptop derives a secret key from her password and uses it to prove her identity to the KDC. The password itself is not sent across the network in the clear.

The KDC replies with a ticket-granting ticket, the TGT. Think of it as a day pass. It says “this is Meera, the KDC vouches for her”, and it is sealed with a key known only to the KDC, tied to a special built-in account called krbtgt. Meera cannot read inside it, and she cannot forge one. She can only present it. By default it lasts around ten hours and can be renewed for several days, though administrators can change this.

Step two: asking for a ticket to one specific service

Meera now clicks the finance share. Her laptop shows the TGT to the KDC and says “I would like to talk to the file server”. The KDC returns a service ticket, sealed with a key derived from the file server’s own account password. Only that server can open it.

This is the design’s neat trick. The file server never sees Meera’s password and never needs to call the domain controller for each request. It receives a ticket, opens it with its own key, sees Meera’s identity and group memberships inside, and decides what she may do. Authentication is one thing; what Meera is allowed to access on that share is a separate decision, made later using those group memberships.

Step three: the ticket gets used, and cached

Here is the detail that matters for attackers. To avoid asking for tickets every few seconds, Meera’s laptop keeps her tickets and related secrets in memory while she is logged on. Single sign-on is possible precisely because these things are lying around. Convenient for her, convenient for anyone who gains enough control of that machine to read that memory.

Now, an attacker enters the story

Suppose a phishing email compromises Meera’s laptop. The attacker initially has only her privileges, which are modest. What they want is to travel: to other servers and eventually to someone with wider rights. This travelling is called lateral movement, and the Kerberos walk-through above tells us what they can steal.

  • Her tickets. Reusing a stolen ticket in place of the real user is commonly called pass-the-ticket. The attacker does not need the password, because the ticket is the proof the service checks. It works until the ticket expires.
  • Her password-derived secret. In older NTLM-style authentication the hash of the password can itself be used to authenticate. This is pass-the-hash. It is why a password hash is nearly as valuable as the password.
  • Service tickets for offline cracking. Any authenticated domain user can request a service ticket for a service account. That ticket is sealed with a key derived from the service account’s password. If that password is weak, the attacker can take the ticket away and guess at it offline, with no failed-login noise at all. This is known as Kerberoasting, and it is why service accounts with old, human-chosen passwords are such a favourite target.

The worst case is the krbtgt secret itself. If an attacker obtains it, usually after taking over a domain controller, they can manufacture TGTs for any identity, with any group memberships, lasting as long as they like. This is the “golden ticket”. Resetting that account’s password twice, with time between resets, is the standard recovery step, because the domain remembers the previous value too.

Why a helpdesk laptop can become a domain compromise

Return to Kaveri Textiles. Say an IT support engineer, Arjun, once logged into Meera’s laptop to fix a printer, using an administrator account. His credentials were cached in memory on that machine. Now the attacker, who owns the laptop, can use his cached material to reach the file server, then a database server, then perhaps a domain controller. Each hop leaves a more powerful credential behind for the next one.

Nothing here exploits a software bug. It exploits convenience. That is why defensive advice in this area is mostly about structure:

  • Administrators use separate accounts, and high-privilege accounts never log into ordinary workstations.
  • Service accounts get long random passwords, or managed service accounts that rotate automatically.
  • Legacy NTLM is reduced or disabled where applications allow it.
  • Workstations cannot freely talk to each other on administrative ports, so one compromised laptop cannot reach ten others.
  • Credential protection features in the operating system are turned on, to make memory theft harder.

What a defender can see

Domain controllers log ticket requests. Some patterns stand out: one account requesting service tickets for an unusual number of services in a few minutes, tickets using weaker encryption types than your environment normally uses, an admin account logging into a machine it has never touched, or a user logging in from two machines at one time with no plausible journey between them. None of these is proof alone. Together, over a timeline, they tell the story of the sideways walk.

If you can narrate Meera’s morning in your own words, you can reason about most questions on this topic from first principles: what was stolen, what does it prove, how long does it last, and who can see it being used?

Figures and names in the examples are illustrative.

Leave a Reply

Trending