Internet Engineering Task Force (IETF) S. Hartman
Request for Comments: 6113 Painless Security
Updates: 4120 L. Zhu
Category: Standards Track Microsoft Corporation
ISSN: 2070-1721 April 2011 A Generalized Framework for Kerberos Pre-Authentication
Kerberos is a protocol for verifying the identity of principals
(e.g., a workstation user or a network server) on an open network.
The Kerberos protocol provides a facility called pre-authentication.
Pre-authentication mechanisms can use this facility to extend the
Kerberos protocol and prove the identity of a principal.
This document describes a more formal model for this facility. The
model describes what state in the Kerberos request a pre-
authentication mechanism is likely to change. It also describes how
multiple pre-authentication mechanisms used in the same request will
This document also provides common tools needed by multiple pre-
authentication mechanisms. One of these tools is a secure channel
between the client and the key distribution center with a reply key
strengthening mechanism; this secure channel can be used to protect
the authentication exchange and thus eliminate offline dictionary
attacks. With these tools, it is relatively straightforward to chain
multiple authentication mechanisms, utilize a different key
management system, or support a new key agreement algorithm.
Status of This Memo
This is an Internet Standards Track document.
This document is a product of the Internet Engineering Task Force
(IETF). It represents the consensus of the IETF community. It has
received public review and has been approved for publication by the
Internet Engineering Steering Group (IESG). Further information on
Internet Standards is available in Section 2 of RFC 5741.
Information about the current status of this document, any errata,
and how to provide feedback on it may be obtained at
Copyright (c) 2011 IETF Trust and the persons identified as the
document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents
(http://trustee.ietf.org/license-info) in effect on the date of
publication of this document. Please review these documents
carefully, as they describe your rights and restrictions with respect
to this document. Code Components extracted from this document must
include Simplified BSD License text as described in Section 4.e of
the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License.
Table of Contents
1. Introduction ....................................................41.1. Conventions and Terminology Used in This Document ..........51.2. Conformance Requirements ...................................52. Model for Pre-Authentication ....................................62.1. Information Managed by the Pre-Authentication Model ........72.2. Initial Pre-Authentication Required Error ..................92.3. Client to KDC .............................................102.4. KDC to Client .............................................113. Pre-Authentication Facilities ..................................123.1. Client Authentication Facility ............................133.2. Strengthening Reply Key Facility ..........................133.3. Replace Reply Key Facility ................................143.4. KDC Authentication Facility ...............................154. Requirements for Pre-Authentication Mechanisms .................154.1. Protecting Requests/Responses .............................165. Tools for Use in Pre-Authentication Mechanisms .................175.1. Combining Keys ............................................175.2. Managing States for the KDC ...............................195.3. Pre-Authentication Set ....................................205.4. Definition of Kerberos FAST Padata ........................235.4.1. FAST Armors ........................................245.4.2. FAST Request .......................................265.4.3. FAST Response ......................................305.4.4. Authenticated Kerberos Error Messages Using
Kerberos FAST ......................................335.4.5. Outer and Inner Requests ...........................345.4.6. The Encrypted Challenge FAST Factor ................345.5. Authentication Strength Indication ........................366. Assigned Constants .............................................376.1. New Errors ................................................376.2. Key Usage Numbers .........................................376.3. Authorization Data Elements ...............................376.4. New PA-DATA Types .........................................377. IANA Considerations ............................................387.1. Pre-Authentication and Typed Data .........................387.2. Fast Armor Types ..........................................407.3. FAST Options ..............................................408. Security Considerations ........................................419. Acknowledgements ...............................................4210. References ....................................................4310.1. Normative References .....................................4310.2. Informative References ...................................43Appendix A. Test Vectors for KRB-FX-CF2 ...........................45Appendix B. ASN.1 Module ..........................................46
The core Kerberos specification [RFC4120] treats pre-authentication
data (padata) as an opaque typed hole in the messages to the key
distribution center (KDC) that may influence the reply key used to
encrypt the KDC reply. This generality has been useful: pre-
authentication data is used for a variety of extensions to the
protocol, many outside the expectations of the initial designers.
However, this generality makes designing more common types of pre-
authentication mechanisms difficult. Each mechanism needs to specify
how it interacts with other mechanisms. Also, tasks such as
combining a key with the long-term secrets or proving the identity of
the user are common to multiple mechanisms. Where there are
generally well-accepted solutions to these problems, it is desirable
to standardize one of these solutions so mechanisms can avoid
duplication of work. In other cases, a modular approach to these
problems is appropriate. The modular approach will allow new and
better solutions to common pre-authentication problems to be used by
existing mechanisms as they are developed.
This document specifies a framework for Kerberos pre-authentication
mechanisms. It defines the common set of functions that pre-
authentication mechanisms perform as well as how these functions
affect the state of the request and reply. In addition, several
common tools needed by pre-authentication mechanisms are provided.
Unlike [RFC3961], this framework is not complete -- it does not
describe all the inputs and outputs for the pre-authentication
mechanisms. Pre-authentication mechanism designers should try to be
consistent with this framework because doing so will make their
mechanisms easier to implement. Kerberos implementations are likely
to have plug-in architectures for pre-authentication; such
architectures are likely to support mechanisms that follow this
framework plus commonly used extensions. This framework also
facilitates combining multiple pre-authentication mechanisms, each of
which may represent an authentication factor, into a single multi-
factor pre-authentication mechanism.
One of these common tools is the flexible authentication secure
tunneling (FAST) padata type. FAST provides a protected channel
between the client and the key distribution center (KDC), and it can
optionally deliver key material used to strengthen the reply key
within the protected channel. Based on FAST, pre-authentication
mechanisms can extend Kerberos with ease, to support, for example,
password-authenticated key exchange (PAKE) protocols with zero-
knowledge password proof (ZKPP) [EKE] [IEEE1363.2]. Any pre-
authentication mechanism can be encapsulated in the FAST messages as
defined in Section 5.4. A pre-authentication type carried within
FAST is called a "FAST factor". Creating a FAST factor is the
easiest path to create a new pre-authentication mechanism. FAST
factors are significantly easier to analyze from a security
standpoint than other pre-authentication mechanisms.
Mechanism designers should design FAST factors, instead of new pre-
authentication mechanisms outside of FAST.
1.1. Conventions and Terminology Used in This Document
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].
This document should be read only after reading the documents
describing the Kerberos cryptography framework [RFC3961] and the core
Kerberos protocol [RFC4120]. This document may freely use
terminology and notation from these documents without reference or
The word padata is used as a shorthand for pre-authentication data.
A conversation is the set of all authentication messages exchanged
between the client and the client's Authentication Service (AS) in
order to authenticate the client principal. A conversation as
defined here consists of all messages that are necessary to complete
the authentication between the client and the client's AS. In the
Ticket Granting Service (TGS) exchange, a conversation consists of
the request message and the reply message. The term conversation is
defined here for both AS and TGS for convenience of discussion. See
Section 5.2 for specific rules on the extent of a conversation in the
AS-REQ case. Prior to this framework, implementations needed to use
implementation-specific heuristics to determine the extent of a
If the KDC reply in an AS exchange is verified, the KDC is
authenticated by the client. In this document, verification of the
KDC reply is used as a synonym of authentication of the KDC.
1.2. Conformance Requirements
This section summarizes the mandatory-to-implement subset of this
specification as a convenience to implementors. The actual
requirements and their context are stated in the body of the
Clients conforming to this specification MUST support the padata
defined in Section 5.2.
Conforming implementations MUST support Kerberos FAST padata
(Section 5.4). Conforming implementations MUST implement the
FX_FAST_ARMOR_AP_REQUEST armor type.
Conforming implementations MUST support the encrypted challenge FAST
factor (Section 5.4.6).
2. Model for Pre-Authentication
When a Kerberos client wishes to obtain a ticket, it sends an initial
Authentication Service (AS) request to the KDC. If pre-
authentication is required but not being used, then the KDC will
respond with a KDC_ERR_PREAUTH_REQUIRED error [RFC4120].
Alternatively, if the client knows what pre-authentication to use, it
MAY optimize away a round trip and send an initial request with
padata included in the initial request. If the client includes the
padata computed using the wrong pre-authentication mechanism or
incorrect keys, the KDC MAY return KDC_ERR_PREAUTH_FAILED with no
indication of what padata should have been included. In that case,
the client MUST retry with no padata and examine the error data of
the KDC_ERR_PREAUTH_REQUIRED error. If the KDC includes pre-
authentication information in the accompanying error data of
KDC_ERR_PREAUTH_FAILED, the client SHOULD process the error data and
The conventional KDC maintains no state between two requests;
subsequent requests may even be processed by a different KDC. On the
other hand, the client treats a series of exchanges with KDCs as a
single conversation. Each exchange accumulates state and hopefully
brings the client closer to a successful authentication.
These models for state management are in apparent conflict. For many
of the simpler pre-authentication scenarios, the client uses one
round trip to find out what mechanisms the KDC supports. Then, the
next request contains sufficient pre-authentication for the KDC to be
able to return a successful reply. For these simple scenarios, the
client only sends one request with pre-authentication data and so the
conversation is trivial. For more complex conversations, the KDC
needs to provide the client with a cookie to include in future
requests to capture the current state of the authentication session.
Handling of multiple round-trip mechanisms is discussed in
This framework specifies the behavior of Kerberos pre-authentication
mechanisms used to identify users or to modify the reply key used to
encrypt the KDC reply. The PA-DATA typed hole may be used to carry
extensions to Kerberos that have nothing to do with proving the
identity of the user or establishing a reply key. Such extensions
are outside the scope of this framework. However, mechanisms that do
accomplish these goals should follow this framework.
This framework specifies the minimum state that a Kerberos
implementation needs to maintain while handling a request in order to
process pre-authentication. It also specifies how Kerberos
implementations process the padata at each step of the AS request
2.1. Information Managed by the Pre-Authentication Model
The following information is maintained by the client and KDC as each
request is being processed:
o The reply key used to encrypt the KDC reply
o How strongly the identity of the client has been authenticated
o Whether the reply key has been used in this conversation
o Whether the reply key has been replaced in this conversation
o Whether the origin of the KDC reply can be verified by the client
(i.e., whether the KDC is authenticated to the client)
Conceptually, the reply key is initially the long-term key of the
principal. However, principals can have multiple long-term keys
because of support for multiple encryption types, salts, and
string2key parameters. As described in Section 18.104.22.168 of the
Kerberos protocol [RFC4120], the KDC sends PA-ETYPE-INFO2 to notify
the client what types of keys are available. Thus, in full
generality, the reply key in the pre-authentication model is actually
a set of keys. At the beginning of a request, it is initialized to
the set of long-term keys advertised in the PA-ETYPE-INFO2 element on
the KDC. If multiple reply keys are available, the client chooses
which one to use. Thus, the client does not need to treat the reply
key as a set. At the beginning of a request, the client picks a key
KDC implementations MAY choose to offer only one key in the PA-ETYPE-
INFO2 element. Since the KDC already knows the client's list of
supported enctypes from the request, no interoperability problems are
created by choosing a single possible reply key. This way, the KDC
implementation avoids the complexity of treating the reply key as a
When the padata in the request are verified by the KDC, then the
client is known to have that key; therefore, the KDC SHOULD pick the
same key as the reply key.
At the beginning of handling a message on both the client and the
KDC, the client's identity is not authenticated. A mechanism may
indicate that it has successfully authenticated the client's
identity. It is useful to keep track of this information on the
client in order to know what pre-authentication mechanisms should be
used. The KDC needs to keep track of whether the client is
authenticated because the primary purpose of pre-authentication is to
authenticate the client identity before issuing a ticket. The
handling of authentication strength using various authentication
mechanisms is discussed in Section 5.5.
Initially, the reply key is not used. A pre-authentication mechanism
that uses the reply key to encrypt or checksum some data in the
generation of new keys MUST indicate that the reply key is used.
This state is maintained by the client and the KDC to enforce the
security requirement stated in Section 3.3 that the reply key SHOULD
NOT be replaced after it is used.
Initially, the reply key is not replaced. If a mechanism implements
the Replace Reply Key facility discussed in Section 3.3, then the
state MUST be updated to indicate that the reply key has been
replaced. Once the reply key has been replaced, knowledge of the
reply key is insufficient to authenticate the client. The reply key
is marked as replaced in exactly the same situations as the KDC reply
is marked as not being verified to the client principal. However,
while mechanisms can verify the KDC reply to the client, once the
reply key is replaced, then the reply key remains replaced for the
remainder of the conversation.
Without pre-authentication, the client knows that the KDC reply is
authentic and has not been modified because it is encrypted in a
long-term key of the client. Only the KDC and the client know that
key. So, at the start of a conversation, the KDC reply is presumed
to be verified using the client's long-term key. It should be noted
that in this document, verifying the KDC reply means authenticating
the KDC, and these phrases are used interchangeably. Any pre-
authentication mechanism that sets a new reply key not based on the
principal's long-term secret MUST either verify the KDC reply some
other way or indicate that the reply is not verified. If a mechanism
indicates that the reply is not verified, then the client
implementation MUST return an error unless a subsequent mechanism
verifies the reply. The KDC needs to track this state so it can
avoid generating a reply that is not verified.
In this specification, KDC verification/authentication refers to the
level of authentication of the KDC to the client provided by RFC
4120. There is a stronger form of KDC verification that, while
sometimes important in Kerberos deployments, is not addressed in this
specification: the typical Kerberos request does not provide a way
for the client machine to know that it is talking to the correct KDC.
Someone who can inject packets into the network between the client
machine and the KDC and who knows the password that the user will
give to the client machine can generate a KDC reply that will decrypt
properly. So, if the client machine needs to authenticate that the
user is in fact the named principal, then the client machine needs to
do a TGS request for itself as a service. Some pre-authentication
mechanisms may provide a way for the client machine to authenticate
the KDC. Examples of this include signing the reply that can be
verified using a well-known public key or providing a ticket for the
client machine as a service.
2.2. Initial Pre-Authentication Required Error
Typically, a client starts a conversation by sending an initial
request with no pre-authentication. If the KDC requires pre-
authentication, then it returns a KDC_ERR_PREAUTH_REQUIRED message.
After the first reply with the KDC_ERR_PREAUTH_REQUIRED error code,
the KDC returns the error code KDC_ERR_MORE_PREAUTH_DATA_REQUIRED
(defined in Section 5.2) for pre-authentication configurations that
use multi-round-trip mechanisms; see Section 2.4 for details of that
The KDC needs to choose which mechanisms to offer the client. The
client needs to be able to choose what mechanisms to use from the
first message. For example, consider the KDC that will accept
mechanism A followed by mechanism B or alternatively the single
mechanism C. A client that supports A and C needs to know that it
should not bother trying A.
Mechanisms can either be sufficient on their own or can be part of an
authentication set -- a group of mechanisms that all need to
successfully complete in order to authenticate a client. Some
mechanisms may only be useful in authentication sets; others may be
useful alone or in authentication sets. For the second group of
mechanisms, KDC policy dictates whether the mechanism will be part of
an authentication set, offered alone, or both. For each mechanism
that is offered alone (even if it is also offered in an
authentication set), the KDC includes the pre-authentication type ID
of the mechanism in the padata sequence returned in the
KDC_ERR_PREAUTH_REQUIRED error. Mechanisms that are only offered as
part of an authentication set are not directly represented in the
padata sequence returned in the KDC_ERR_PREAUTH_REQUIRED error,
although they are represented in the PA-AUTHENTICATION-SET sequence.
The KDC SHOULD NOT send data that is encrypted in the long-term
password-based key of the principal. Doing so has the same security
exposures as the Kerberos protocol without pre-authentication. There
are few situations where the KDC needs to expose cipher text
encrypted in a weak key before the client has proven knowledge of
that key, and where pre-authentication is desirable.
2.3. Client to KDC
This description assumes that a client has already received a
KDC_ERR_PREAUTH_REQUIRED from the KDC. If the client performs
optimistic pre-authentication, then the client needs to guess values
for the information it would normally receive from that error
response or use cached information obtained in prior interactions
with the KDC.
The client starts by initializing the pre-authentication state as
specified. It then processes the padata in the
When processing the response to the KDC_ERR_PREAUTH_REQUIRED, the
client MAY ignore any padata it chooses unless doing so violates a
specification to which the client conforms. Clients conforming to
this specification MUST NOT ignore the padata defined in Section 5.2.
Clients SHOULD choose one authentication set or mechanism that could
lead to authenticating the user and ignore other such mechanisms.
However, this rule does not affect the processing of padata unrelated
to this framework; clients SHOULD process such padata normally.
Since the list of mechanisms offered by the KDC is in the decreasing
preference order, clients typically choose the first mechanism or
authentication set that the client can usefully perform. If a client
chooses to ignore padata, it MUST NOT process the padata, allow the
padata to affect the pre-authentication state, or respond to the
For each instance of padata the client chooses to process, the client
processes the padata and modifies the pre-authentication state as
required by that mechanism.
After processing the padata in the KDC error, the client generates a
new request. It processes the pre-authentication mechanisms in the
order in which they will appear in the next request, updating the
state as appropriate. The request is sent when it is complete.
2.4. KDC to Client
When a KDC receives an AS request from a client, it needs to
determine whether it will respond with an error or an AS reply.
There are many causes for an error to be generated that have nothing
to do with pre-authentication; they are discussed in the core
From the standpoint of evaluating the pre-authentication, the KDC
first starts by initializing the pre-authentication state. If a PA-
FX-COOKIE pre-authentication data item is present, it is processed
first; see Section 5.2 for a definition. It then processes the
padata in the request. As mentioned in Section 2.3, the KDC MAY
ignore padata that are inappropriate for the configuration and MUST
ignore padata of an unknown type. The KDC MUST NOT ignore padata of
types used in previous messages. For example, if a KDC issues a
KDC_ERR_PREAUTH_REQUIRED error including padata of type x, then the
KDC cannot ignore padata of type x received in an AS-REQ message from
At this point, the KDC decides whether it will issue an error or a
reply. Typically, a KDC will issue a reply if the client's identity
has been authenticated to a sufficient degree.
In the case of a KDC_ERR_MORE_PREAUTH_DATA_REQUIRED error, the KDC
first starts by initializing the pre-authentication state. Then, it
processes any padata in the client's request in the order provided by
the client. Mechanisms that are not understood by the KDC are
ignored. Next, it generates padata for the error response, modifying
the pre-authentication state appropriately as each mechanism is
processed. The KDC chooses the order in which it will generate
padata (and thus the order of padata in the response), but it needs
to modify the pre-authentication state consistently with the choice
of order. For example, if some mechanism establishes an
authenticated client identity, then the subsequent mechanisms in the
generated response receive this state as input. After the padata are
generated, the error response is sent. Typically, the errors with
the code KDC_ERR_MORE_PREAUTH_DATA_REQUIRED in a conversation will
include KDC state, as discussed in Section 5.2.
To generate a final reply, the KDC generates the padata modifying the
pre-authentication state as necessary. Then, it generates the final
response, encrypting it in the current pre-authentication reply key.
3. Pre-Authentication Facilities
Pre-authentication mechanisms can be thought of as providing various
conceptual facilities. This serves two useful purposes. First,
mechanism authors can choose only to solve one specific small
problem. It is often useful for a mechanism designed to offer key
management not to directly provide client authentication but instead
to allow one or more other mechanisms to handle this need. Secondly,
thinking about the abstract services that a mechanism provides yields
a minimum set of security requirements that all mechanisms providing
that facility must meet. These security requirements are not
complete; mechanisms will have additional security requirements based
on the specific protocol they employ.
A mechanism is not constrained to only offering one of these
facilities. While such mechanisms can be designed and are sometimes
useful, many pre-authentication mechanisms implement several
facilities. It is often easier to construct a secure, simple
solution by combining multiple facilities in a single mechanism than
by solving the problem in full generality. Even when mechanisms
provide multiple facilities, they need to meet the security
requirements for all the facilities they provide. If the FAST factor
approach is used, it is likely that one or a small number of
facilities can be provided by a single mechanism without complicating
the security analysis.
According to Kerberos extensibility rules (Section 1.5 of the
Kerberos specification [RFC4120]), an extension MUST NOT change the
semantics of a message unless a recipient is known to understand that
extension. Because a client does not know that the KDC supports a
particular pre-authentication mechanism when it sends an initial
request, a pre-authentication mechanism MUST NOT change the semantics
of the request in a way that will break a KDC that does not
understand that mechanism. Similarly, KDCs MUST NOT send messages to
clients that affect the core semantics unless the client has
indicated support for the message.
The only state in this model that would break the interpretation of a
message is changing the expected reply key. If one mechanism changed
the reply key and a later mechanism used that reply key, then a KDC
that interpreted the second mechanism but not the first would fail to
interpret the request correctly. In order to avoid this problem,
extensions that change core semantics are typically divided into two
parts. The first part proposes a change to the core semantic -- for
example, proposes a new reply key. The second part acknowledges that
the extension is understood and that the change takes effect.
Section 3.2 discusses how to design mechanisms that modify the reply
key to be split into a proposal and acceptance without requiring
additional round trips to use the new reply key in subsequent pre-
authentication. Other changes in the state described in Section 2.1
can safely be ignored by a KDC that does not understand a mechanism.
Mechanisms that modify the behavior of the request outside the scope
of this framework need to carefully consider the Kerberos
extensibility rules to avoid similar problems.
3.1. Client Authentication Facility
The Client Authentication facility proves the identity of a user to
the KDC before a ticket is issued. Examples of mechanisms
implementing this facility include the encrypted timestamp facility,
defined in Section 22.214.171.124 of the Kerberos specification [RFC4120].
Mechanisms that provide this facility are expected to mark the client
Mechanisms implementing this facility SHOULD require the client to
prove knowledge of the reply key before transmitting a successful KDC
reply. Otherwise, an attacker can intercept the pre-authentication
exchange and get a reply to attack. One way of proving the client
knows the reply key is to implement the Replace Reply Key facility
along with this facility. The Public Key Cryptography for Initial
Authentication in Kerberos (PKINIT) mechanism [RFC4556] implements
Client Authentication alongside Replace Reply Key.
If the reply key has been replaced, then mechanisms such as
encrypted-timestamp that rely on knowledge of the reply key to
authenticate the client MUST NOT be used.
3.2. Strengthening Reply Key Facility
Particularly when dealing with keys based on passwords, it is
desirable to increase the strength of the key by adding additional
secrets to it. Examples of sources of additional secrets include the
results of a Diffie-Hellman key exchange or key bits from the output
of a smart card [KRB-WG.SAM]. Typically, these additional secrets
can be first combined with the existing reply key and then converted
to a protocol key using tools defined in Section 5.1.
Typically, a mechanism implementing this facility will know that the
other side of the exchange supports the facility before the reply key
is changed. For example, a mechanism might need to learn the
certificate for a KDC before encrypting a new key in the public key
belonging to that certificate. However, if a mechanism implementing
this facility wishes to modify the reply key before knowing that the
other party in the exchange supports the mechanism, it proposes
modifying the reply key. The other party then includes a message
indicating that the proposal is accepted if it is understood and
meets policy. In many cases, it is desirable to use the new reply
key for client authentication and for other facilities. Waiting for
the other party to accept the proposal and actually modify the reply
key state would add an additional round trip to the exchange.
Instead, mechanism designers are encouraged to include a typed hole
for additional padata in the message that proposes the reply key
change. The padata included in the typed hole are generated assuming
the new reply key. If the other party accepts the proposal, then
these padata are considered as an inner level. As with the outer
level, one authentication set or mechanism is typically chosen for
client authentication, along with auxiliary mechanisms such as KDC
cookies, and other mechanisms are ignored. When mechanisms include
such a container, the hint provided for use in authentication sets
(as defined in Section 5.3) MUST contain a sequence of inner
mechanisms along with hints for those mechanisms. The party
generating the proposal can determine whether the padata were
processed based on whether the proposal for the reply key is
The specific formats of the proposal message, including where padata
are included, is a matter for the mechanism specification.
Similarly, the format of the message accepting the proposal is
Mechanisms implementing this facility and including a typed hole for
additional padata MUST checksum that padata using a keyed checksum or
encrypt the padata. This requirement protects against modification
of the contents of the typed hole. By modifying these contents, an
attacker might be able to choose which mechanism is used to
authenticate the client, or to convince a party to provide text
encrypted in a key that the attacker had manipulated. It is
important that mechanisms strengthen the reply key enough that using
it to checksum padata is appropriate.
3.3. Replace Reply Key Facility
The Replace Reply Key facility replaces the key in which a successful
AS reply will be encrypted. This facility can only be used in cases
where knowledge of the reply key is not used to authenticate the
client. The new reply key MUST be communicated to the client and the
KDC in a secure manner. This facility MUST NOT be used if there can
be a man-in-the-middle between the client and the KDC. Mechanisms
implementing this facility MUST mark the reply key as replaced in the
pre-authentication state. Mechanisms implementing this facility MUST
either provide a mechanism to verify the KDC reply to the client or
mark the reply as unverified in the pre-authentication state.
Mechanisms implementing this facility SHOULD NOT be used if a
previous mechanism has used the reply key.
As with the Strengthening Reply Key facility, Kerberos extensibility
rules require that the reply key not be changed unless both sides of
the exchange understand the extension. In the case of this facility,
it will likely be the case for both sides to know that the facility
is available by the time that the new key is available to be used.
However, mechanism designers can use a container for padata in a
proposal message, as discussed in Section 3.2, if appropriate.
3.4. KDC Authentication Facility
This facility verifies that the reply comes from the expected KDC.
In traditional Kerberos, the KDC and the client share a key, so if
the KDC reply can be decrypted, then the client knows that a trusted
KDC responded. Note that the client machine cannot trust the client
unless the machine is presented with a service ticket for it
(typically, the machine can retrieve this ticket by itself).
However, if the reply key is replaced, some mechanism is required to
verify the KDC. Pre-authentication mechanisms providing this
facility allow a client to determine that the expected KDC has
responded even after the reply key is replaced. They mark the pre-
authentication state as having been verified.
4. Requirements for Pre-Authentication Mechanisms
This section lists requirements for specifications of pre-
For each message in the pre-authentication mechanism, the
specification describes the pa-type value to be used and the contents
of the message. The processing of the message by the sender and
recipient is also specified. This specification needs to include all
modifications to the pre-authentication state.
Generally, mechanisms have a message that can be sent in the error
data of the KDC_ERR_PREAUTH_REQUIRED error message or in an
authentication set. If the client needs information, such as trusted
certificate authorities, in order to determine if it can use the
mechanism, then this information should be in that message. In
addition, such mechanisms should also define a pa-hint to be included
in authentication sets. Often, the same information included in the
padata-value is appropriate to include in the pa-hint (as defined in
In order to ease security analysis, the mechanism specification
should describe what facilities from this document are offered by the
mechanism. For each facility, the security considerations section of
the mechanism specification should show that the security
requirements of that facility are met. This requirement is
applicable to any FAST factor that provides authentication
Significant problems have resulted in the specification of Kerberos
protocols because much of the KDC exchange is not protected against
alteration. The security considerations section should discuss
unauthenticated plaintext attacks. It should either show that
plaintext is protected or discuss what harm an attacker could do by
modifying the plaintext. It is generally acceptable for an attacker
to be able to cause the protocol negotiation to fail by modifying
plaintext. More significant attacks should be evaluated carefully.
As discussed in Section 5.2, there is no guarantee that a client will
use the same KDCs for all messages in a conversation. The mechanism
specification needs to show why the mechanism is secure in this
situation. The hardest problem to deal with, especially for
challenge/response mechanisms is to make sure that the same response
cannot be replayed against two KDCs while allowing the client to talk
to any KDC.
4.1. Protecting Requests/Responses
Mechanism designers SHOULD protect cleartext portions of pre-
authentication data. Various denial-of-service attacks and downgrade
attacks against Kerberos are possible unless plaintexts are somehow
protected against modification. An early design goal of Kerberos
Version 5 [RFC4120] was to avoid encrypting more of the
authentication exchange than was required. (Version 4 doubly-
encrypted the encrypted part of a ticket in a KDC reply, for
example). This minimization of encryption reduces the load on the
KDC and busy servers. Also, during the initial design of Version 5,
the existence of legal restrictions on the export of cryptography
made it desirable to minimize of the number of uses of encryption in
the protocol. Unfortunately, performing this minimization created
numerous instances of unauthenticated security-relevant plaintext
Mechanisms MUST guarantee that by the end of a successful
authentication exchange, both the client and the KDC have verified
all the plaintext sent by the other party. If there is more than one
round trip in the exchange, mechanisms MUST additionally guarantee
that no individual messages were reordered or replayed from a
previous exchange. Strategies for accomplishing this include using
message authentication codes (MACs) to protect the plaintext as it is
sent including some form of nonce or cookie to allow for the chaining
of state from one message to the next or exchanging a MAC of the
entire conversation after a key is established.
Mechanism designers need to provide a strategy for updating
cryptographic algorithms, such as defining a new pre-authentication
type for each algorithm or taking advantage of the client's list of
supported RFC 3961 encryption types to indicate the client's support
for cryptographic algorithms.
Primitives defined in [RFC3961] are RECOMMENDED for integrity
protection and confidentiality. Mechanisms based on these primitives
are crypto-agile as the result of using [RFC3961] along with
[RFC4120]. The advantage afforded by crypto-agility is the ability
to incrementally deploy a fix specific to a particular algorithm thus
avoid a multi-year standardization and deployment cycle, when real
attacks do arise against that algorithm.
Note that data used by FAST factors (defined in Section 5.4) is
encrypted in a protected channel; thus, they do not share the un-
authenticated-text issues with mechanisms designed as full-blown pre-