Every Kerberos ticket-granting ticket in an Active Directory domain is protected by the key of one account, krbtgt. If that key is stolen, an attacker can forge tickets for any user until the password is changed, and changed twice. Many domains have not reset it since the day they were built. This article shows how to check how old the krbtgt password is, with read-only PowerShell, and how to reset it without breaking sign-ins.

What is the krbtgt account?

krbtgt is the account behind the Key Distribution Center (KDC) service on every domain controller. When a user signs in, the KDC issues a ticket-granting ticket (TGT), encrypted and signed with keys derived from the krbtgt password. Every later request for a service ticket presents that TGT, and the domain controller trusts it because only the KDC holds the krbtgt key.

There is one krbtgt account per domain. It is created with the domain, it is disabled, and nobody signs in with it. Each read-only domain controller (RODC) has its own account, named krbtgt_ followed by a number (krbtgt_12345, for example), so that a stolen RODC does not expose the domain's main key. You never choose the krbtgt password yourself: whatever you type during a reset, the domain controller replaces it with a strong random one.

Why does the krbtgt password age matter?

Anyone who holds the krbtgt key can create a TGT for any account, with any group memberships, and every domain controller in the domain will accept it. That forged ticket is known as a golden ticket. Getting the key takes domain-level access, such as DCSync rights or a copy of ntds.dit from a domain controller or a backup. Once someone has it, they no longer need that access to keep coming back.

The key stays valid until the password changes twice. Active Directory keeps the current and the previous krbtgt password, so that tickets issued just before a change keep working. A single reset moves a stolen key into the "previous" slot, where it is still accepted. Only the second reset removes it.

That is why the age is worth checking. If the password was last set in 2012, any compromise of the domain since 2012, by an attacker, a departed administrator or a backup that left the building, is still usable today. A recent date does not prove nothing happened, but an old one means no past exposure has ever been closed. There is a second reason: a krbtgt password set before the domain reached the Windows Server 2008 functional level has no AES keys, and a reset at a higher level creates them.

How do you check the krbtgt password age with PowerShell?

The commands below only read. They need the ActiveDirectory PowerShell module from the Remote Server Administration Tools (RSAT). On Windows 11, add it with Add-WindowsCapability -Online -Name Rsat.ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0 from an elevated prompt; on Windows Server, with Install-WindowsFeature RSAT-AD-PowerShell. Under the default permissions any authenticated domain user can read these attributes, so you do not need to be a Domain Admin to check.

The domain's krbtgt account, with its age in whole days:

Get-ADUser -Identity krbtgt -Properties PasswordLastSet |
    Select-Object Name, PasswordLastSet,
        @{ Name = 'AgeDays'; Expression = { ((Get-Date) - $_.PasswordLastSet).Days } }

The RODC accounts, with the read-only domain controller each one belongs to:

Get-ADUser -Filter "SamAccountName -like 'krbtgt_*'" -Properties PasswordLastSet, 'msDS-KrbTgtLinkBl' |
    Select-Object Name, PasswordLastSet,
        @{ Name = 'AgeDays'; Expression = { ((Get-Date) - $_.PasswordLastSet).Days } },
        @{ Name = 'UsedBy'; Expression = { $_.'msDS-KrbTgtLinkBl' -join '; ' } }

If the domain uses Microsoft Entra Kerberos (for Windows Hello for Business cloud Kerberos trust, for example), this also lists krbtgt_AzureAD. That account is not an RODC's, and its key is rotated with Set-AzureADKerberosServer -RotateServerKey, not by the procedure below.

Every domain in the forest, oldest first:

$rows = foreach ($domain in (Get-ADForest).Domains) {
    Get-ADUser -Server $domain -Filter "SamAccountName -eq 'krbtgt' -or SamAccountName -like 'krbtgt_*'" -Properties PasswordLastSet |
        Select-Object @{ Name = 'Domain'; Expression = { $domain } }, Name, PasswordLastSet,
            @{ Name = 'AgeDays'; Expression = { ((Get-Date) - $_.PasswordLastSet).Days } }
}
$rows | Sort-Object AgeDays -Descending | Format-Table -AutoSize

How do you reset the krbtgt password safely?

Reset it once, let the change reach every writable domain controller, wait at least the maximum ticket lifetime, then reset it a second time.

  1. Check replication first. Run repadmin /replsummary and fix any domain controller that shows failures. A reset that does not replicate is the main way this goes wrong.
  2. Look up the ticket lifetime. In the Group Policy Management Console, open the Default Domain Policy at Computer Configuration, Policies, Windows Settings, Security Settings, Account Policies, Kerberos Policy. Maximum lifetime for user ticket is 10 hours by default and Maximum lifetime for service ticket is 600 minutes. If your domain sets them higher, wait longer.
  3. Reset once. As a Domain Admin, in Active Directory Users and Computers, turn on View, Advanced Features, open Users, right-click krbtgt and select Reset Password.
  4. Confirm it replicated. This lists the krbtgt password date on each writable domain controller; every row should show the new time:
    foreach ($dc in (Get-ADDomainController -Filter * | Where-Object { -not $_.IsReadOnly })) {
        $krbtgt = Get-ADUser -Identity krbtgt -Server $dc.HostName -Properties PasswordLastSet
        [pscustomobject]@{ DomainController = $dc.HostName; PasswordLastSet = $krbtgt.PasswordLastSet }
    }
  5. Wait, at least the maximum ticket lifetime from the moment the last domain controller has the change. Many teams wait a full day to leave margin.
  6. Reset a second time, and confirm replication again.

Why two resets: the first one makes the old key the previous key, so tickets issued before the change keep working while the new key spreads. The second one drops the old key entirely. Why the wait: any TGT signed with the original key has expired by then, so the second reset invalidates nothing that is still in use.

Microsoft engineers published a script for this procedure, New-KrbtgtKeys.ps1. It has an informational mode that changes nothing, simulation modes that test replication without touching the real account, and a reset mode that resets the real krbtgt password once per run and checks that the change has reached each domain controller. You run the reset mode twice, with the wait in between. Microsoft archived the original GitHub repository in March 2024 and no longer maintains it, so read the copy you have before you run it.

What can break?

  • Two resets in quick succession. If the second reset follows the first before the tickets have expired, every TGT issued before the first reset stops working. Users have to sign in again, and some services and computers need a restart before they authenticate.
  • Long-lived tickets. Applications that hold a ticket and renew it, rather than authenticating again, fail when their ticket's key is gone. Find them in the first window, while the old key still works.
  • Domain controllers that are offline or not replicating. A controller that missed the reset still uses the old key. Tickets it issues are rejected by controllers that have the new one, and the failures are hard to trace. Do not reset while one is down.
  • RODC accounts. Resetting krbtgt does not touch the krbtgt_ accounts of the read-only domain controllers; reset those separately, the same way.

Sometimes breaking every ticket is the point. After a suspected compromise you want the stolen key gone quickly, so you do the two resets close together, after the first has replicated to every writable domain controller, and accept that everyone signs in again.

How often should you reset the krbtgt password?

Every 180 days is a common practice and the threshold many assessment tools use. It is a recommendation of practice, not a limit Windows enforces: nothing in Active Directory expires the krbtgt password on its own.

Reset it twice, straight away, after any suspected compromise of the domain; Microsoft's Active Directory forest recovery guide includes the double reset as a step. Many teams also reset it when an administrator with domain-level access leaves. A team that resets every six months also learns how its applications react, so the reset after an incident is not the first one.

Checked against

  • ActiveDirectory module (RSAT): Get-ADUser with -Identity, -Filter, -Server and -Properties PasswordLastSet; Get-ADForest (Domains); Get-ADDomainController -Filter * (HostName, IsReadOnly)
  • The msDS-KrbTgtLinkBl back-link from an RODC's krbtgt_ account to the read-only domain controller
  • RSAT install names: Rsat.ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0 (Windows 11) and RSAT-AD-PowerShell (Windows Server)
  • Microsoft Learn, "AD Forest Recovery - Reset the krbtgt password" (updated 2025): reset twice, wait 10 hours by default (the maximum user and service ticket lifetimes), password history of two, RODC accounts named krbtgt_number, the password typed is replaced by a generated one
  • New-KrbtgtKeys.ps1 in Microsoft's archived repository (archived March 2024): Informational Mode, Simulation Modes, Real Reset Mode (resets once per run)
  • The commands were checked by name against the module reference; they were not run against a domain by us: run them in a test domain first

Where does GlacierPoint Scan fit?

GlacierPoint Scan reports the krbtgt password age as control AD-001, "krbtgt password age", in its Active Directory assessment. It reads the domain krbtgt account's password date, works out the age at the time of collection, and marks the control failed, with high severity, when the password is more than 180 days old. The guidance on the finding follows the procedure above: check replication and ticket lifetimes, then schedule the two resets with the interval between them. AD-001 covers the domain's krbtgt account; check the RODC accounts with the second command above.

It is one of more than two hundred controls across Active Directory, Windows hosts and Microsoft 365, all read-only. The user guide explains how a collection runs, and What is an Active Directory security assessment? covers what else an assessment should check.