Tech-invite3GPPspaceIETF RFCsSIP
9190898887868584838281807978777675747372717069686766656463626160595857565554535251504948474645444342414039383736353433323130292827262524232221201918171615141312111009080706050403020100
in Index   Prev   Next

RFC 6113

A Generalized Framework for Kerberos Pre-Authentication

Pages: 48
Proposed Standard
Updates:  4120
Part 1 of 3 – Pages 1 to 17
None   None   Next

Top   ToC   RFC6113 - Page 1
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

Abstract

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 interact. 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 http://www.rfc-editor.org/info/rfc6113.
Top   ToC   RFC6113 - Page 2
Copyright Notice

   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.
Top   ToC   RFC6113 - Page 3

Table of Contents

1. Introduction ....................................................4 1.1. Conventions and Terminology Used in This Document ..........5 1.2. Conformance Requirements ...................................5 2. Model for Pre-Authentication ....................................6 2.1. Information Managed by the Pre-Authentication Model ........7 2.2. Initial Pre-Authentication Required Error ..................9 2.3. Client to KDC .............................................10 2.4. KDC to Client .............................................11 3. Pre-Authentication Facilities ..................................12 3.1. Client Authentication Facility ............................13 3.2. Strengthening Reply Key Facility ..........................13 3.3. Replace Reply Key Facility ................................14 3.4. KDC Authentication Facility ...............................15 4. Requirements for Pre-Authentication Mechanisms .................15 4.1. Protecting Requests/Responses .............................16 5. Tools for Use in Pre-Authentication Mechanisms .................17 5.1. Combining Keys ............................................17 5.2. Managing States for the KDC ...............................19 5.3. Pre-Authentication Set ....................................20 5.4. Definition of Kerberos FAST Padata ........................23 5.4.1. FAST Armors ........................................24 5.4.2. FAST Request .......................................26 5.4.3. FAST Response ......................................30 5.4.4. Authenticated Kerberos Error Messages Using Kerberos FAST ......................................33 5.4.5. Outer and Inner Requests ...........................34 5.4.6. The Encrypted Challenge FAST Factor ................34 5.5. Authentication Strength Indication ........................36 6. Assigned Constants .............................................37 6.1. New Errors ................................................37 6.2. Key Usage Numbers .........................................37 6.3. Authorization Data Elements ...............................37 6.4. New PA-DATA Types .........................................37 7. IANA Considerations ............................................38 7.1. Pre-Authentication and Typed Data .........................38 7.2. Fast Armor Types ..........................................40 7.3. FAST Options ..............................................40 8. Security Considerations ........................................41 9. Acknowledgements ...............................................42 10. References ....................................................43 10.1. Normative References .....................................43 10.2. Informative References ...................................43 Appendix A. Test Vectors for KRB-FX-CF2 ...........................45 Appendix B. ASN.1 Module ..........................................46
Top   ToC   RFC6113 - Page 4

1. Introduction

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
Top   ToC   RFC6113 - Page 5
   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 further explanation. 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 conversation. 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 document. Clients conforming to this specification MUST support the padata defined in Section 5.2.
Top   ToC   RFC6113 - Page 6
   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 then retry. 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 Section 5.2. 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
Top   ToC   RFC6113 - Page 7
   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
   process.

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 5.2.7.5 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 to use. 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
Top   ToC   RFC6113 - Page 8
   created by choosing a single possible reply key.  This way, the KDC
   implementation avoids the complexity of treating the reply key as a
   set.

   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
Top   ToC   RFC6113 - Page 9
   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 case. 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
Top   ToC   RFC6113 - Page 10
   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 KDC_ERR_PREAUTH_REQUIRED. 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 padata. 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.
Top   ToC   RFC6113 - Page 11
   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 Kerberos specification. 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 the client. 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.
Top   ToC   RFC6113 - Page 12

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
Top   ToC   RFC6113 - Page 13
   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 5.2.7.2 of the Kerberos specification [RFC4120]. Mechanisms that provide this facility are expected to mark the client as authenticated. 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
Top   ToC   RFC6113 - Page 14
   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
   accepted.

   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
   mechanism specific.

   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.
Top   ToC   RFC6113 - Page 15
   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- authentication mechanisms. 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 Section 5.3). 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
Top   ToC   RFC6113 - Page 16
   requirements of that facility are met.  This requirement is
   applicable to any FAST factor that provides authentication
   information.

   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 fields. 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.
Top   ToC   RFC6113 - Page 17
   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-
   authentication mechanisms.



(page 17 continued on part 2)

Next Section