Network Working Group C. Neuman
Request for Comments: 4120 USC-ISI
Obsoletes: 1510 T. Yu
Category: Standards Track S. HartmanK. Raeburn
July 2005 The Kerberos Network Authentication Service (V5)
Status of This Memo
This document specifies an Internet standards track protocol for the
Internet community, and requests discussion and suggestions for
improvements. Please refer to the current edition of the Internet
Official Protocol Standards" (STD 1) for the standardization state
and status of this protocol. Distribution of this memo is unlimited.
Copyright (C) The Internet Society (2005).
This document provides an overview and specification of Version 5 of
the Kerberos protocol, and it obsoletes RFC 1510 to clarify aspects
of the protocol and its intended use that require more detailed or
clearer explanation than was provided in RFC 1510. This document is
intended to provide a detailed description of the protocol, suitable
for implementation, together with descriptions of the appropriate use
of protocol messages and fields within those messages.
Table of Contents
1. Introduction ....................................................51.1. The Kerberos Protocol ......................................61.2. Cross-Realm Operation ......................................81.3. Choosing a Principal with Which to Communicate .............91.4. Authorization .............................................101.5. Extending Kerberos without Breaking Interoperability ......111.5.1. Compatibility with RFC 1510 ........................111.5.2. Sending Extensible Messages ........................121.6. Environmental Assumptions .................................121.7. Glossary of Terms .........................................132. Ticket Flag Uses and Requests ..................................162.1. Initial, Pre-authenticated, and
Hardware-Authenticated Tickets ............................172.2. Invalid Tickets ...........................................172.3. Renewable Tickets .........................................172.4. Postdated Tickets .........................................182.5. Proxiable and Proxy Tickets ...............................192.6. Forwardable Tickets .......................................192.7. Transited Policy Checking .................................202.8. OK as Delegate ............................................212.9. Other KDC Options .........................................212.9.1. Renewable-OK .......................................212.9.2. ENC-TKT-IN-SKEY ....................................222.9.3. Passwordless Hardware Authentication ...............223. Message Exchanges ..............................................223.1. The Authentication Service Exchange .......................223.1.1. Generation of KRB_AS_REQ Message ...................243.1.2. Receipt of KRB_AS_REQ Message ......................243.1.3. Generation of KRB_AS_REP Message ...................243.1.4. Generation of KRB_ERROR Message ....................273.1.5. Receipt of KRB_AS_REP Message ......................273.1.6. Receipt of KRB_ERROR Message .......................283.2. The Client/Server Authentication Exchange .................293.2.1. The KRB_AP_REQ Message .............................293.2.2. Generation of a KRB_AP_REQ Message .................293.2.3. Receipt of KRB_AP_REQ Message ......................303.2.4. Generation of a KRB_AP_REP Message .................333.2.5. Receipt of KRB_AP_REP Message ......................333.2.6. Using the Encryption Key ...........................333.3. The Ticket-Granting Service (TGS) Exchange ................343.3.1. Generation of KRB_TGS_REQ Message ..................353.3.2. Receipt of KRB_TGS_REQ Message .....................373.3.3. Generation of KRB_TGS_REP Message ..................383.3.4. Receipt of KRB_TGS_REP Message .....................42
This document describes the concepts and model upon which the
Kerberos network authentication system is based. It also specifies
Version 5 of the Kerberos protocol. The motivations, goals,
assumptions, and rationale behind most design decisions are treated
cursorily; they are more fully described in a paper available in IEEE
communications [NT94] and earlier in the Kerberos portion of the
Athena Technical Plan [MNSS87].
This document is not intended to describe Kerberos to the end user,
system administrator, or application developer. Higher-level papers
describing Version 5 of the Kerberos system [NT94] and documenting
version 4 [SNS88] are available elsewhere.
The Kerberos model is based in part on Needham and Schroeder's
trusted third-party authentication protocol [NS78] and on
modifications suggested by Denning and Sacco [DS81]. The original
design and implementation of Kerberos Versions 1 through 4 was the
work of two former Project Athena staff members, Steve Miller of
Digital Equipment Corporation and Clifford Neuman (now at the
Information Sciences Institute of the University of Southern
California), along with Jerome Saltzer, Technical Director of Project
Athena, and Jeffrey Schiller, MIT Campus Network Manager. Many other
members of Project Athena have also contributed to the work on
Version 5 of the Kerberos protocol (described in this document) has
evolved because of new requirements and desires for features not
available in Version 4. The design of Version 5 was led by Clifford
Neuman and John Kohl with much input from the community. The
development of the MIT reference implementation was led at MIT by
John Kohl and Theodore Ts'o, with help and contributed code from many
others. Since RFC 1510 was issued, many individuals have proposed
extensions and revisions to the protocol. This document reflects
some of these proposals. Where such changes involved significant
effort, the document cites the contribution of the proposer.
Reference implementations of both Version 4 and Version 5 of Kerberos
are publicly available, and commercial implementations have been
developed and are widely used. Details on the differences between
Versions 4 and 5 can be found in [KNT94].
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in [RFC2119].
1.1. The Kerberos Protocol
Kerberos provides a means of verifying the identities of principals,
(e.g., a workstation user or a network server) on an open
(unprotected) network. This is accomplished without relying on
assertions by the host operating system, without basing trust on host
addresses, without requiring physical security of all the hosts on
the network, and under the assumption that packets traveling along
the network can be read, modified, and inserted at will. Kerberos
performs authentication under these conditions as a trusted third-
party authentication service by using conventional (shared secret
key) cryptography. Extensions to Kerberos (outside the scope of this
document) can provide for the use of public key cryptography during
certain phases of the authentication protocol. Such extensions
support Kerberos authentication for users registered with public key
certification authorities and provide certain benefits of public key
cryptography in situations where they are needed.
The basic Kerberos authentication process proceeds as follows: A
client sends a request to the authentication server (AS) for
"credentials" for a given server. The AS responds with these
credentials, encrypted in the client's key. The credentials consist
of a "ticket" for the server and a temporary encryption key (often
called a "session key"). The client transmits the ticket (which
contains the client's identity and a copy of the session key, all
encrypted in the server's key) to the server. The session key (now
shared by the client and server) is used to authenticate the client
and may optionally be used to authenticate the server. It may also
be used to encrypt further communication between the two parties or
to exchange a separate sub-session key to be used to encrypt further
communication. Note that many applications use Kerberos' functions
only upon the initiation of a stream-based network connection.
Unless an application performs encryption or integrity protection for
the data stream, the identity verification applies only to the
initiation of the connection, and it does not guarantee that
subsequent messages on the connection originate from the same
Implementation of the basic protocol consists of one or more
authentication servers running on physically secure hosts. The
authentication servers maintain a database of principals (i.e., users
and servers) and their secret keys. Code libraries provide
encryption and implement the Kerberos protocol. In order to add
authentication to its transactions, a typical network application
adds calls to the Kerberos library directly or through the Generic
Security Services Application Programming Interface (GSS-API)
described in a separate document [RFC4121]. These calls result in
the transmission of the messages necessary to achieve authentication.
The Kerberos protocol consists of several sub-protocols (or
exchanges). There are two basic methods by which a client can ask a
Kerberos server for credentials. In the first approach, the client
sends a cleartext request for a ticket for the desired server to the
AS. The reply is sent encrypted in the client's secret key. Usually
this request is for a ticket-granting ticket (TGT), which can later
be used with the ticket-granting server (TGS). In the second method,
the client sends a request to the TGS. The client uses the TGT to
authenticate itself to the TGS in the same manner as if it were
contacting any other application server that requires Kerberos
authentication. The reply is encrypted in the session key from the
TGT. Though the protocol specification describes the AS and the TGS
as separate servers, in practice they are implemented as different
protocol entry points within a single Kerberos server.
Once obtained, credentials may be used to verify the identity of the
principals in a transaction, to ensure the integrity of messages
exchanged between them, or to preserve privacy of the messages. The
application is free to choose whatever protection may be necessary.
To verify the identities of the principals in a transaction, the
client transmits the ticket to the application server. Because the
ticket is sent "in the clear" (parts of it are encrypted, but this
encryption doesn't thwart replay) and might be intercepted and reused
by an attacker, additional information is sent to prove that the
message originated with the principal to whom the ticket was issued.
This information (called the authenticator) is encrypted in the
session key and includes a timestamp. The timestamp proves that the
message was recently generated and is not a replay. Encrypting the
authenticator in the session key proves that it was generated by a
party possessing the session key. Since no one except the requesting
principal and the server know the session key (it is never sent over
the network in the clear), this guarantees the identity of the
The integrity of the messages exchanged between principals can also
be guaranteed by using the session key (passed in the ticket and
contained in the credentials). This approach provides detection of
both replay attacks and message stream modification attacks. It is
accomplished by generating and transmitting a collision-proof
checksum (elsewhere called a hash or digest function) of the client's
message, keyed with the session key. Privacy and integrity of the
messages exchanged between principals can be secured by encrypting
the data to be passed by using the session key contained in the
ticket or the sub-session key found in the authenticator.
The authentication exchanges mentioned above require read-only access
to the Kerberos database. Sometimes, however, the entries in the
database must be modified, such as when adding new principals or
changing a principal's key. This is done using a protocol between a
client and a third Kerberos server, the Kerberos Administration
Server (KADM). There is also a protocol for maintaining multiple
copies of the Kerberos database. Neither of these protocols are
described in this document.
1.2. Cross-Realm Operation
The Kerberos protocol is designed to operate across organizational
boundaries. A client in one organization can be authenticated to a
server in another. Each organization wishing to run a Kerberos
server establishes its own "realm". The name of the realm in which a
client is registered is part of the client's name and can be used by
the end-service to decide whether to honor a request.
By establishing "inter-realm" keys, the administrators of two realms
can allow a client authenticated in the local realm to prove its
identity to servers in other realms. The exchange of inter-realm
keys (a separate key may be used for each direction) registers the
ticket-granting service of each realm as a principal in the other
realm. A client is then able to obtain a TGT for the remote realm's
ticket-granting service from its local realm. When that TGT is used,
the remote ticket-granting service uses the inter-realm key (which
usually differs from its own normal TGS key) to decrypt the TGT; thus
it is certain that the ticket was issued by the client's own TGS.
Tickets issued by the remote ticket-granting service will indicate to
the end-service that the client was authenticated from another realm.
Without cross-realm operation, and with appropriate permission, the
client can arrange registration of a separately-named principal in a
remote realm and engage in normal exchanges with that realm's
services. However, for even small numbers of clients this becomes
cumbersome, and more automatic methods as described here are
A realm is said to communicate with another realm if the two realms
share an inter-realm key, or if the local realm shares an inter-realm
key with an intermediate realm that communicates with the remote
realm. An authentication path is the sequence of intermediate realms
that are transited in communicating from one realm to another.
Realms may be organized hierarchically. Each realm shares a key with
its parent and a different key with each child. If an inter-realm
key is not directly shared by two realms, the hierarchical
organization allows an authentication path to be easily constructed.
If a hierarchical organization is not used, it may be necessary to
consult a database in order to construct an authentication path
Although realms are typically hierarchical, intermediate realms may
be bypassed to achieve cross-realm authentication through alternate
authentication paths. (These might be established to make
communication between two realms more efficient.) It is important
for the end-service to know which realms were transited when deciding
how much faith to place in the authentication process. To facilitate
this decision, a field in each ticket contains the names of the
realms that were involved in authenticating the client.
The application server is ultimately responsible for accepting or
rejecting authentication and SHOULD check the transited field. The
application server may choose to rely on the Key Distribution Center
(KDC) for the application server's realm to check the transited
field. The application server's KDC will set the
TRANSITED-POLICY-CHECKED flag in this case. The KDCs for
intermediate realms may also check the transited field as they issue
TGTs for other realms, but they are encouraged not to do so. A
client may request that the KDCs not check the transited field by
setting the DISABLE-TRANSITED-CHECK flag. KDCs SHOULD honor this
1.3. Choosing a Principal with Which to Communicate
The Kerberos protocol provides the means for verifying (subject to
the assumptions in Section 1.6) that the entity with which one
communicates is the same entity that was registered with the KDC
using the claimed identity (principal name). It is still necessary
to determine whether that identity corresponds to the entity with
which one intends to communicate.
When appropriate data has been exchanged in advance, the application
may perform this determination syntactically based on the application
protocol specification, information provided by the user, and
configuration files. For example, the server principal name
(including realm) for a telnet server might be derived from the
user-specified host name (from the telnet command line), the "host/"
prefix specified in the application protocol specification, and a
mapping to a Kerberos realm derived syntactically from the domain
part of the specified hostname and information from the local
Kerberos realms database.
One can also rely on trusted third parties to make this
determination, but only when the data obtained from the third party
is suitably integrity-protected while resident on the third-party
server and when transmitted. Thus, for example, one should not rely
on an unprotected DNS record to map a host alias to the primary name
of a server, accepting the primary name as the party that one intends
to contact, since an attacker can modify the mapping and impersonate
Implementations of Kerberos and protocols based on Kerberos MUST NOT
use insecure DNS queries to canonicalize the hostname components of
the service principal names (i.e., they MUST NOT use insecure DNS
queries to map one name to another to determine the host part of the
principal name with which one is to communicate). In an environment
without secure name service, application authors MAY append a
statically configured domain name to unqualified hostnames before
passing the name to the security mechanisms, but they should do no
more than that. Secure name service facilities, if available, might
be trusted for hostname canonicalization, but such canonicalization
by the client SHOULD NOT be required by KDC implementations.
Implementation note: Many current implementations do some degree of
canonicalization of the provided service name, often using DNS even
though it creates security problems. However, there is no
consistency among implementations as to whether the service name is
case folded to lowercase or whether reverse resolution is used. To
maximize interoperability and security, applications SHOULD provide
security mechanisms with names that result from folding the user-
entered name to lowercase without performing any other modifications
As an authentication service, Kerberos provides a means of verifying
the identity of principals on a network. Authentication is usually
useful primarily as a first step in the process of authorization,
determining whether a client may use a service, which objects the
client is allowed to access, and the type of access allowed for each.
Kerberos does not, by itself, provide authorization. Possession of a
client ticket for a service provides only for authentication of the
client to that service, and in the absence of a separate
authorization procedure, an application should not consider it to
authorize the use of that service.
Separate authorization methods MAY be implemented as application-
specific access control functions and may utilize files on the
application server, on separately issued authorization credentials
such as those based on proxies [Neu93], or on other authorization
services. Separately authenticated authorization credentials MAY be
embedded in a ticket's authorization data when encapsulated by the
KDC-issued authorization data element.
Applications should not accept the mere issuance of a service ticket
by the Kerberos server (even by a modified Kerberos server) as
granting authority to use the service, since such applications may
become vulnerable to the bypass of this authorization check in an
environment where other options for application authentication are
provided, or if they interoperate with other KDCs.
1.5. Extending Kerberos without Breaking Interoperability
As the deployed base of Kerberos implementations grows, extending
Kerberos becomes more important. Unfortunately, some extensions to
the existing Kerberos protocol create interoperability issues because
of uncertainty regarding the treatment of certain extensibility
options by some implementations. This section includes guidelines
that will enable future implementations to maintain interoperability.
Kerberos provides a general mechanism for protocol extensibility.
Some protocol messages contain typed holes -- sub-messages that
contain an octet-string along with an integer that defines how to
interpret the octet-string. The integer types are registered
centrally, but they can be used both for vendor extensions and for
extensions standardized through the IETF.
In this document, the word "extension" refers to extension by
defining a new type to insert into an existing typed hole in a
protocol message. It does not refer to extension by addition of new
fields to ASN.1 types, unless the text explicitly indicates
1.5.1. Compatibility with RFC 1510
Note that existing Kerberos message formats cannot readily be
extended by adding fields to the ASN.1 types. Sending additional
fields often results in the entire message being discarded without an
error indication. Future versions of this specification will provide
guidelines to ensure that ASN.1 fields can be added without creating
an interoperability problem.
In the meantime, all new or modified implementations of Kerberos that
receive an unknown message extension SHOULD preserve the encoding of
the extension but otherwise ignore its presence. Recipients MUST NOT
decline a request simply because an extension is present.
There is one exception to this rule. If an unknown authorization
data element type is received by a server other than the ticket-
granting service either in an AP-REQ or in a ticket contained in an
AP-REQ, then authentication MUST fail. One of the primary uses of
authorization data is to restrict the use of the ticket. If the
service cannot determine whether the restriction applies to that
service, then a security weakness may result if the ticket can be
used for that service. Authorization elements that are optional
SHOULD be enclosed in the AD-IF-RELEVANT element.
The ticket-granting service MUST ignore but propagate to derivative
tickets any unknown authorization data types, unless those data types
are embedded in a MANDATORY-FOR-KDC element, in which case the
request will be rejected. This behavior is appropriate because
requiring that the ticket-granting service understand unknown
authorization data types would require that KDC software be upgraded
to understand new application-level restrictions before applications
used these restrictions, decreasing the utility of authorization data
as a mechanism for restricting the use of tickets. No security
problem is created because services to which the tickets are issued
will verify the authorization data.
Implementation note: Many RFC 1510 implementations ignore unknown
authorization data elements. Depending on these implementations to
honor authorization data restrictions may create a security weakness.
1.5.2. Sending Extensible Messages
Care must be taken to ensure that old implementations can understand
messages sent to them, even if they do not understand an extension
that is used. Unless the sender knows that an extension is
supported, the extension cannot change the semantics of the core
message or previously defined extensions.
For example, an extension including key information necessary to
decrypt the encrypted part of a KDC-REP could only be used in
situations where the recipient was known to support the extension.
Thus when designing such extensions it is important to provide a way
for the recipient to notify the sender of support for the extension.
For example in the case of an extension that changes the KDC-REP
reply key, the client could indicate support for the extension by
including a padata element in the AS-REQ sequence. The KDC should
only use the extension if this padata element is present in the
AS-REQ. Even if policy requires the use of the extension, it is
better to return an error indicating that the extension is required
than to use the extension when the recipient may not support it.
Debugging implementations that do not interoperate is easier when
errors are returned.
1.6. Environmental Assumptions
Kerberos imposes a few assumptions on the environment in which it can
properly function, including the following:
* "Denial of service" attacks are not solved with Kerberos. There
are places in the protocols where an intruder can prevent an
application from participating in the proper authentication steps.
Detection and solution of such attacks (some of which can appear
to be not-uncommon "normal" failure modes for the system) are
usually best left to the human administrators and users.
* Principals MUST keep their secret keys secret. If an intruder
somehow steals a principal's key, it will be able to masquerade as
that principal or to impersonate any server to the legitimate
* "Password guessing" attacks are not solved by Kerberos. If a user
chooses a poor password, it is possible for an attacker to
successfully mount an offline dictionary attack by repeatedly
attempting to decrypt, with successive entries from a dictionary,
messages obtained which are encrypted under a key derived from the
* Each host on the network MUST have a clock which is "loosely
synchronized" to the time of the other hosts; this synchronization
is used to reduce the bookkeeping needs of application servers
when they do replay detection. The degree of "looseness" can be
configured on a per-server basis, but it is typically on the order
of 5 minutes. If the clocks are synchronized over the network,
the clock synchronization protocol MUST itself be secured from
* Principal identifiers are not recycled on a short-term basis. A
typical mode of access control will use access control lists
(ACLs) to grant permissions to particular principals. If a stale
ACL entry remains for a deleted principal and the principal
identifier is reused, the new principal will inherit rights
specified in the stale ACL entry. By not re-using principal
identifiers, the danger of inadvertent access is removed.
1.7. Glossary of Terms
Below is a list of terms used throughout this document.
Verifying the claimed identity of a principal.
A record containing a Ticket and an Authenticator to be presented
to a server as part of the authentication process.
A sequence of intermediate realms transited in the authentication
process when communicating from one realm to another.
A record containing information that can be shown to have been
recently generated using the session key known only by the client
The process of determining whether a client may use a service,
which objects the client is allowed to access, and the type of
access allowed for each.
A token that grants the bearer permission to access an object or
service. In Kerberos, this might be a ticket whose use is
restricted by the contents of the authorization data field, but
which lists no network addresses, together with the session key
necessary to use the ticket.
The output of an encryption function. Encryption transforms
plaintext into ciphertext.
A process that makes use of a network service on behalf of a user.
Note that in some cases a Server may itself be a client of some
other server (e.g., a print server may be a client of a file
A ticket plus the secret session key necessary to use that ticket
successfully in an authentication exchange.
Encryption Type (etype)
When associated with encrypted data, an encryption type identifies
the algorithm used to encrypt the data and is used to select the
appropriate algorithm for decrypting the data. Encryption type
tags are communicated in other messages to enumerate algorithms
that are desired, supported, preferred, or allowed to be used for
encryption of data between parties. This preference is combined
with local information and policy to select an algorithm to be
Key Distribution Center. A network service that supplies tickets
and temporary session keys; or an instance of that service or the
host on which it runs. The KDC services both initial ticket and
ticket-granting ticket requests. The initial ticket portion is
sometimes referred to as the Authentication Server (or service).
The ticket-granting ticket portion is sometimes referred to as the
ticket-granting server (or service).
The name given to the Project Athena's authentication service, the
protocol used by that service, or the code used to implement the
authentication service. The name is adopted from the three-headed
dog that guards Hades.
Key Version Number (kvno)
A tag associated with encrypted data identifies which key was used
for encryption when a long-lived key associated with a principal
changes over time. It is used during the transition to a new key
so that the party decrypting a message can tell whether the data
was encrypted with the old or the new key.
The input to an encryption function or the output of a decryption
function. Decryption transforms ciphertext into plaintext.
A named client or server entity that participates in a network
communication, with one name that is considered canonical.
The canonical name used to identify each different principal
To encipher a record containing several fields in such a way that
the fields cannot be individually replaced without knowledge of
the encryption key or leaving evidence of tampering.
An encryption key shared by a principal and the KDC, distributed
outside the bounds of the system, with a long lifetime. In the
case of a human user's principal, the secret key MAY be derived
from a password.
A particular Principal that provides a resource to network
clients. The server is sometimes referred to as the Application
A resource provided to network clients; often provided by more
than one server (for example, remote file service).
A temporary encryption key used between two principals, with a
lifetime limited to the duration of a single login "session". In
the Kerberos system, a session key is generated by the KDC. The
session key is distinct from the sub-session key, described next.
A temporary encryption key used between two principals, selected
and exchanged by the principals using the session key, and with a
lifetime limited to the duration of a single association. The
sub-session key is also referred to as the subkey.
A record that helps a client authenticate itself to a server; it
contains the client's identity, a session key, a timestamp, and
other information, all sealed using the server's secret key. It
only serves to authenticate a client when presented along with a