Join our Newsletter — 33% off our NHI Course
Authentication, Authorisation & Trust

TGS_REQ

← Back to Glossary
By NHI Mgmt Group Updated October 31, 2026 Domain: Authentication, Authorisation & Trust

TGS_REQ is the Kerberos ticket-granting service request sent when a client needs a ticket for a specific service. It is a normal part of the Kerberos sequence after initial authentication. In a healthy flow, its presence helps confirm that the application is completing the protocol rather than stopping early after initial credential validation.

TGS_REQ in the Kerberos Exchange

TGS_REQ is the message a Kerberos client sends to the ticket-granting service when it needs a ticket for a particular application or service. It sits in the middle of the normal Kerberos flow, after initial authentication, and it is the step that turns a general ticket-granting ticket into service-specific access.

That makes TGS_REQ more than a protocol label. It marks the point where Kerberos moves from proving the client once to authorising access to a specific service, which is why its absence, repetition, or failure can be operationally meaningful during authentication troubleshooting and security monitoring.

Why TGS_REQ Matters Operationally

In a healthy environment, TGS_REQ traffic confirms that users and applications are progressing through Kerberos as intended. If that request never appears, the problem may be upstream in initial authentication, ticket caching, name resolution, or client configuration. If it appears unexpectedly often, it can point to misconfiguration, repeated service lookups, or abnormal access patterns that deserve attention.

The request is also useful because it reflects the handoff between identity proof and service access. In other words, it is one of the clearest protocol indicators that a client is trying to reach a named service rather than simply establishing a login session.

TGS_REQ and Service Ticket Issuance

TGS_REQ is the client-side request that asks Kerberos to mint a ticket for a specific target service. The response, commonly understood as the service-ticket step, is what lets the client present proof to the application without sending its long-term secret again.

This separation is central to Kerberos security. The client does not reuse the initial authentication exchange for every service call; instead, it relies on short-lived, purpose-specific tickets. That design reduces repeated exposure of credentials and keeps access tied to the service named in the request.

What to Look For in Normal and Abnormal Flow

Normal TGS_REQ activity should align with expected application use, service principal names, and valid ticket lifetimes. A healthy pattern is usually consistent with user action, application startup, or automated service-to-service activity that has already authenticated successfully.

Abnormal patterns include repeated requests for the same service in a short time, requests that fail after initial authentication succeeds, or service ticket activity that does not match the user, host, or application that is supposed to be active. Those signals do not prove compromise on their own, but they can help separate a routine Kerberos exchange from a broken or suspicious one.

Security Implications of the Ticket-Granting Step

Because TGS_REQ sits between initial authentication and service access, it is a useful place to reason about exposure, trust, and misuse. If an attacker has already obtained a valid client context, they may try to request tickets for services they should not reach, or abuse that trust chain to move laterally. Good monitoring therefore treats the ticket-granting step as part of the control surface, not just protocol noise.

For defenders, the main security value is correlation. TGS_REQ becomes meaningful when it is matched with the surrounding authentication events, the service being requested, and the expected behaviour of the client that generated it.

Risk and Threat Considerations

Kerberos ticket-granting traffic can become risky when it is used outside the expected client, service, or timing pattern. The main concern is not the request itself, but what it reveals about access intent, ticket abuse, or a compromised client trying to obtain service tickets it should not legitimately use.

Failure mechanism: A valid initial login context can be misused to request service tickets for unintended services, or a broken configuration can generate repeated failed requests that obscure real compromise.

Impact: Organisations may see lateral movement, service impersonation attempts, noisy authentication failures, or blind spots in detection if they do not correlate TGS_REQ activity with the rest of the Kerberos exchange.

Standards & Framework Alignment

This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.

MITRE ATT&CK addresses the attack and risk surface, while NIST SP 800-53 Rev 5 sets the governance and control requirements practitioners need to meet.

FrameworkControl / ReferenceRelevance
NIST SP 800-53 Rev 5IA-5 — Authenticator ManagementTGS_REQ sits inside ticket and authenticator lifecycle, which this control governs.
IA-2 — Identification and Authentication (Organizational Users)Kerberos service-ticket requests follow successful user authentication.
AU-6 — Audit Record Review, Analysis, and ReportingTGS_REQ becomes security-significant when reviewed alongside surrounding authentication events.
Recommendation — Manage Kerberos ticket and authenticator lifecycles to limit reuse and reduce exposure. Validate authenticated user identities before allowing ticket-granting activity. Correlate ticket-granting activity with adjacent logs to detect abnormal service access patterns.
MITRE ATT&CKT1558 — Steal or Forge Kerberos TicketsKerberos ticket-granting requests are part of the attack surface for ticket theft and forgery.
Recommendation — Map suspicious Kerberos activity to ticket-theft techniques and investigate for misuse.

Practitioner Guidance

What to watch for: Use TGS_REQ as a protocol checkpoint when investigating Kerberos issues. If the request is missing, look upstream at initial authentication and ticket caching; if it is excessive or mismatched to the expected service, investigate whether the client, application, or service principal is behaving normally.

Practitioner note: The most useful analysis usually comes from pairing TGS_REQ observation with the requested service identity and the surrounding ticket lifecycle, rather than treating the message as a standalone event.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Reviewed and updated by the NHIMG editorial team on October 31, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org