Q20Information Security Systems

Kerberos, developed at MIT, is a widely used network authentication protocol designed to provide strong mutual authentication for client/server applications over an inherently insecure network, using symmetric-key cryptography rather than public-key methods. It assumes an attacker can intercept, modify, or replay any packet on the network, and it never transmits a user's plaintext password. The architecture centers on a trusted third party known as the Key Distribution Center (KDC), which every client and server shares a secret key with in advance.

The KDC consists of two logically separate components, typically run on the same physical server:

• Authentication Server (AS): Handles the initial login. It verifies the client's identity (indirectly, via a timestamp encrypted with the client's password-derived key) and issues a Ticket Granting Ticket (TGT), which allows the client to request further service tickets without re-entering their password.
• Ticket Granting Server (TGS): Issues Service Tickets for specific application servers. It trusts any client presenting a valid TGT (since only the AS could have issued it) and avoids requiring the client to contact the AS, and hence re-authenticate with a password, for every new service.

• 1. AS Exchange: The client sends a plaintext request to the AS containing its identity and the desired TGS. The AS looks up the client's secret key (derived from their password), generates a random session key (Client-TGS key), and returns two items: a TGT (containing the client's identity and the session key, encrypted with the TGS's own secret key, unreadable by the client) and a copy of the session key encrypted with the client's secret key.
• 2. TGS Exchange: To access a particular application service, the client sends the TGS the TGT along with a freshly built authenticator (client ID and timestamp encrypted with the Client-TGS session key). The TGS decrypts the TGT with its own secret key to recover the session key, uses it to decrypt and validate the authenticator's timestamp (defeating replay attacks), then issues a Service Ticket (encrypted with the target server's secret key) plus a new Client-Server session key.
• 3. Client-Server (Application) Exchange: The client presents the Service Ticket and a new authenticator to the application server. The server decrypts the ticket with its own secret key to obtain the session key, validates the authenticator, and, if mutual authentication is required, returns the timestamp incremented and encrypted with the session key to prove its own identity to the client.

Because tickets carry limited lifetimes and every exchange after the initial login is protected by freshly derived session keys and timestamped authenticators, Kerberos resists replay attacks, and since the user's password never crosses the network, offline password-sniffing attacks are also defeated. Its main practical limitations are a hard dependency on synchronized clocks across all machines, and the fact that a compromised KDC compromises the entire realm's security. This centralization also makes the KDC a single point of failure; if it becomes unreachable, no new tickets can be issued anywhere in the realm, though existing valid tickets continue to work until they expire. Kerberos is deployed widely today, most notably as the default authentication mechanism in Microsoft Active Directory domains.