Update gnulib files.

[shishi.git] / doc / specifications / draft-ietf-krb-wg-preauth-framework-03.txt

Kerberos Working Group                                            L. Zhu
Internet-Draft                                     Microsoft Corporation
Updates: 4120 (if approved)                                   S. Hartman
Intended status: Standards Track                                     MIT
Expires: April 26, 2007                                 October 23, 2006


        A Generalized Framework for Kerberos Pre-Authentication
                 draft-ietf-krb-wg-preauth-framework-03

Status of this Memo

   By submitting this Internet-Draft, each author represents that any
   applicable patent or other IPR claims of which he or she is aware
   have been or will be disclosed, and any of which he or she becomes
   aware will be disclosed, in accordance with Section 6 of BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF), its areas, and its working groups.  Note that
   other groups may also distribute working documents as Internet-
   Drafts.

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."

   The list of current Internet-Drafts can be accessed at
   http://www.ietf.org/ietf/1id-abstracts.txt.

   The list of Internet-Draft Shadow Directories can be accessed at
   http://www.ietf.org/shadow.html.

   This Internet-Draft will expire on April 26, 2007.

Copyright Notice

   Copyright (C) The Internet Society (2006).

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 mechanism called pre-authentication
   for proving the identity of a principal and for better protecting the
   long-term secret of the principal.

   This document describes a model for Kerberos pre-authentication



Zhu & Hartman            Expires April 26, 2007                 [Page 1]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   mechanisms.  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 such tools is a secure channel
   between the client and the KDC with a reply key delivery mechanism,
   this secure channel can be used to protect the authentication
   exchange thus eliminate offline dictionary attacks.  With these
   tools, it is straightforward to chain multiple authentication factors
   or add a plugin to, for example, utilize a different key management
   system, or support a new key agreement algorithm.


Table of Contents

   1.  Introduction . . . . . . . . . . . . . . . . . . . . . . . . .  3
   2.  Conventions Used in This Document  . . . . . . . . . . . . . .  4
   3.  Model for Pre-Authentication . . . . . . . . . . . . . . . . .  4
     3.1.  Information Managed by the Pre-authentication Model  . . .  5
     3.2.  Initial Pre-authentication Required Error  . . . . . . . .  7
     3.3.  Client to KDC  . . . . . . . . . . . . . . . . . . . . . .  8
     3.4.  KDC to Client  . . . . . . . . . . . . . . . . . . . . . .  9
   4.  Pre-Authentication Facilities  . . . . . . . . . . . . . . . . 10
     4.1.  Client-authentication Facility . . . . . . . . . . . . . . 11
     4.2.  Strengthening-reply-key Facility . . . . . . . . . . . . . 11
     4.3.  Replacing-reply-key Facility . . . . . . . . . . . . . . . 12
     4.4.  KDC-authentication Facility  . . . . . . . . . . . . . . . 13
   5.  Requirements for Pre-Authentication Mechanisms . . . . . . . . 13
   6.  Tools for Use in Pre-Authentication Mechanisms . . . . . . . . 14
     6.1.  Combining Keys . . . . . . . . . . . . . . . . . . . . . . 14
     6.2.  Protecting Requests/Responses  . . . . . . . . . . . . . . 15
     6.3.  Managing States for the KDC  . . . . . . . . . . . . . . . 15
     6.4.  Pre-authentication Set . . . . . . . . . . . . . . . . . . 17
     6.5.  Definition of Kerberos FAST Padata . . . . . . . . . . . . 18
       6.5.1.  FAST Request . . . . . . . . . . . . . . . . . . . . . 18
       6.5.2.  FAST Response  . . . . . . . . . . . . . . . . . . . . 22
     6.6.  Authentication Strength Indication . . . . . . . . . . . . 25
   7.  IANA Considerations  . . . . . . . . . . . . . . . . . . . . . 25
   8.  Security Considerations  . . . . . . . . . . . . . . . . . . . 25
   9.  Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . 26
   10. References . . . . . . . . . . . . . . . . . . . . . . . . . . 26
     10.1. Normative References . . . . . . . . . . . . . . . . . . . 26
     10.2. Informative References . . . . . . . . . . . . . . . . . . 26
   Appendix A.  ASN.1 module  . . . . . . . . . . . . . . . . . . . . 26
   Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 29
   Intellectual Property and Copyright Statements . . . . . . . . . . 30



Zhu & Hartman            Expires April 26, 2007                 [Page 2]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


1.  Introduction

   The core Kerberos specification [RFC4120] treats pre-authentication
   data as an opaque typed hole in the messages to the 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, problems like combining a key with the long-term secret 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 appropriated.  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 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 plugin architectures for pre-authentication; such
   architectures are likely to support mechanisms that follow this
   framework plus commonly used extensions.

   One of these common tools is the flexible authentication secure
   tunneling (FAST) padata.  FAST provides a protected channel between
   the client and the KDC, and it also delivers a 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 padata field Section 6.5 of
   FAST.  A pre-authentication type thus carried within FAST is called a
   FAST factor.  A FAST factor MUST NOT be used outside of FAST unless
   its specification explicitly allows so.  Note that FAST without a
   FAST factor for authentication does NOT by itself authenticate the
   client or the KDC.

   New pre-authentication mechanisms SHOULD design FAST factors, instead



Zhu & Hartman            Expires April 26, 2007                 [Page 3]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   of full-blown pre-authentication mechanisms.

   A conversation consists of all messages that are necessary to
   complete the mutual authentication between the client and the KDC.  A
   conversation is the smallest logic unit for messages exchanged
   between the client and the KDC.  The KDC need to manage mulitple
   authentication sets frequently need to keep track of KDC states
   during a convesation, standard solutions are provided for these
   common problems.

   This document should be read only after reading the documents
   describing the Kerberos cryptography framework [RFC3961] and the core
   Kerberos protocol [RFC4120].  This document freely uses terminology
   and notation from these documents without reference or further
   explanation.


2.  Conventions 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].

   The word padata is used as the shorthand of pre-authentication data.
   A conversation is used to refer to all authentication messages
   exchanged between the client and the KDC.


3.  Model for Pre-Authentication

   When a Kerberos client wishes to obtain a ticket using the
   authentication server, it sends an initial Authentication Service
   (AS) request.  If pre-authentication is required but not being used,
   then the KDC will respond with a KDC_ERR_PREAUTH_REQUIRED error.
   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
   wrong padata, 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 as
   that of the KDC_ERR_PREAUTH_REQUIRED error, 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



Zhu & Hartman            Expires April 26, 2007                 [Page 4]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   single authentication session.  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
   authentication session is trivial.  For more complex authentication
   sessions, 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 6.3.

   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
   process.

3.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 authentication session

   o  Whether the reply key has been replaced in this authentication
      session

   o  Whether the contents of the KDC reply can be verified by the
      client principal






Zhu & Hartman            Expires April 26, 2007                 [Page 5]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   o  Whether the contents of the KDC reply can be verified by the
      client machine

   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 handling a request, the client
   picks a reply 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
   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 is 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.  This information is useful to keep track of 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 6.6.

   Initially the reply key has not been used.  A pre-authentication
   mechanism that uses the reply key either directly to encrypt or
   checksum some data or indirectly 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 4.3 that the reply key cannot be used after it is replaced.

   Initially the reply key has not been replaced.  If a mechanism
   implements the Replace Reply Key facility discussed in Section 4.3,



Zhu & Hartman            Expires April 26, 2007                 [Page 6]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   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 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 authentication session.

   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 handling any message the KDC reply is
   presumed to be verified using the client principal's long-term key.
   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.

   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 to authenticate the KDC.  Examples
   of this include signing the reply with a well-known public key or
   providing a ticket for the client machine as a service in addition to
   the requested ticket.

3.2.  Initial Pre-authentication Required Error

   Typically a client starts an authentication session 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_NEEDED for
   pre-authentication configurations that use multi-round-trip
   mechanisms; see Section 3.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



Zhu & Hartman            Expires April 26, 2007                 [Page 7]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   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 or offered alone.  For each mechanism that is
   offered alone, the KDC includes the pre-authentication type ID of the
   mechanism in the padata sequence returned in the
   KDC_ERR_PREAUTH_REQUIRED error.

   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 pre-authentication is desirable and where
   the KDC needs to expose cipher text encrypted in a weak key before
   the client has proven knowledge of that key.

3.3.  Client to KDC

   This description assumes 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 optimistically
   choose the information it would normally receive from that error
   response.

   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 MUST NOT ignore
   the padata defined in Section 6.3.  Clients SHOULD process padata
   unrelated to this framework or other means of authenticating the
   user.  Clients SHOULD choose one authentication set or mechanism that
   could lead to authenticating the user and ignore the rest.  Since the
   list of mechanisms offered by the KDC is in the decreasing preference
   order, clients typically choose the first mechanism that the client
   can usefully perform.  If a client chooses to ignore a padata it MUST
   NOT process the padata, allow the padata to affect the pre-
   authentication state, nor respond to the padata.

   For each padata the client chooses to process, the client processes



Zhu & Hartman            Expires April 26, 2007                 [Page 8]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   the padata and modifies the pre-authentication state as required by
   that mechanism.  Padata are processed in the order received from the
   KDC.

   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.

3.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 a 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.  It then
   processes the padata in the request.  As mentioned in Section 3.3,
   the KDC MAY ignore padata that is inappropriate for the configuration
   and MUST ignore padata of an unknown type.

   At this point the KDC decides whether it will issue a pre-
   authentication required 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_PREAUTH_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.
   Mechanisms that are inappropriate for the client principal or the
   request SHOULD also be 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 is generated, the error response is sent.
   Typically the errors with the code KDC_ERR_MORE_PREAUTH_DATA_NEEDED
   in a converstation will include KDC state as discussed in
   Section 6.3.

   To generate a final reply, the KDC generates the padata modifying the
   pre-authentication state as necessary.  Then it generates the final



Zhu & Hartman            Expires April 26, 2007                 [Page 9]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   response, encrypting it in the current pre-authentication reply key.


4.  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.  By combining multiple facilities in a single mechanism,
   it is often easier to construct a secure, simple solution 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.

   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 4.2 discusses how to design mechanisms that modify the reply
   key to be split into a proposal and acceptance without requiring



Zhu & Hartman            Expires April 26, 2007                [Page 10]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   additional round trips to use the new reply key in subsequent pre-
   authentication.  Other changes in the state described in Section 3.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.

4.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 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.

4.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 [RFC4556].  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 6.1.

   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



Zhu & Hartman            Expires April 26, 2007                [Page 11]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   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 interpreted as if they were included
   immediately following the proposal.  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 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.  Typically the reply key is used to protect the
   padata.  If you are only minimally increasing the strength of the
   reply key, this may give the attacker access to something too close
   to the original reply key.  However, binding the padata to the new
   reply key seems potentially important from a security standpoint.
   There may also be objections to this from a double encryption
   standpoint because we also recommend client authentication facilities
   be tied to the reply key.

4.3.  Replacing-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.  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 more common 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 4.2 if appropriate.







Zhu & Hartman            Expires April 26, 2007                [Page 12]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


4.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.


5.  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 need information such as, for
   example, 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.

   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 consideration 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 is used in FAST to provide
   authentication information.

   Significant problems have resulted in the specification of Kerberos
   protocols because much of the KDC exchange is not protected against
   authentication.  The security considerations section should discuss
   unauthenticated plaintext attacks.  It should either show that



Zhu & Hartman            Expires April 26, 2007                [Page 13]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   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.


6.  Tools for Use in Pre-Authentication Mechanisms

   This section describes common tools needed by multiple pre-
   authentication mechanisms.  By using these tools mechanism designers
   can use a modular approach to specify mechanism details and ease
   security analysis.

6.1.  Combining Keys

   Frequently a weaker key need to be combined with a strong key before
   use.  For example, passwords are typically limited in size and
   insufficiently random, therefore it is desirable to increase the
   strength of the keys based on passwords by adding additional secrets
   to it.  Additional source of secrecy can come from a hardware token.

   This section provides a standard way to combine two keys into one.
   The function KRB-FX-CF1() produces a new key based on two existing
   keys of the same enctype and it is base on the primitives encrypt(),
   random-to-key() and K-truncate() described in [RFC3961].

    KRB-FX-CF1(protocol key, protocol key, octet string) ->
                  (resulting key)

   The KRB-FX-CF1() function takes two protocol keys and an octet string
   as input, and output a new key of the same enctype.

    encrypt(B, initial-cipher-state, pepper) -> (state-1, cipher-text-1)

    encrypt(A, initial-cipher-state, cipher-text-1) ->
                    (state-2, cipher-text-2)

    K-truncate(cipher-text-2) -> bitstring-3

    random-to-key(bitstring-3) -> final-key

    KRB-FX-CF1(A, B, pepper) -> final-key

   Where initial-cipher-state is defined in [RFC3961] and the key-
   generation seed length K is specified by the enctype profile
   [RFC3961].  The length of the parameter pepper MUST be chosen such
   that cipher-text-2 has at least K bits.  If the input parameter
   pepper is too short for encrypt(), it MUST first be padded with all



Zhu & Hartman            Expires April 26, 2007                [Page 14]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   zeroes to the next shortest length that encryt() can operate on.

   KRB-FX-CF1() has the following properties:

   o  The knowledge of the final-key does not reveal either key A or key
      B.

   o  Without the knowledge of key A, it is infeasible to find the value
      of the final-key within the lifetime of key A.

   o  Without the knowledge of key B, it is infeasible to find the value
      of final key within the lifetime of key B.

   o  Typically Key A is stronger than Key B. The lifetime of final-key
      is no worse than that of Key A.

   Any mechanism that uses KRB-FX-CF1() MUST show the security
   requirements are met base on these properties.

6.2.  Protecting Requests/Responses

   Mechanism designers SHOULD provide integrity protection of the
   messages in a conversation whenever feasible

   Sensitive data MUST be encrypted when sent over the wire.  Non-
   sensitive data that have privacy implications are encouraged to be
   encrypted as well.

   If there are more than one roundtrip for an authentication exchange,
   mechanism designers SHOULD allow either the client or the KDC provide
   a checksum of all the messages exchanged on the wire, that is then
   verified by the receiver.

   Primitives defined in [RFC3961] are RECOMMENDED for integrity
   protection and confidentiality.  Mechanisms based on these primitives
   have the benefit of crypto-agility provided by [RFC3961].  The
   advantage afforded by crypto-agility is the ability to avoid a multi-
   year standardization and deployment cycle to fix a problem specific
   to a particular algorithm, when real attacks do arise against that
   algorithm.

   New mechanisms MUST NOT be hard-wired to use a specific algorithm.

6.3.  Managing States for the KDC

   For any conversation that consists of more than two messages, the KDC
   likely need to keep track of KDC states for incomplete authentication
   exchanges and destroy the states of a conversation when the



Zhu & Hartman            Expires April 26, 2007                [Page 15]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   authentication completes successful or fails, or the KDC times out.
   When the KDC times out, the KDC returns an error message with the
   code KDC_ERR_PREAUTH_TIMED_OUT.

       KDC_ERR_PREAUTH_TIMED_OUT           TBA

   Upnon receipt of this error, the client MUST abort the existing
   conversation, and restart a new one.

   An example, where more than one message from the client is needed, is
   when the client is authenticated based on a challenge-response
   scheme.  In that case, the KDC need to keep track of the challenge
   issued for a client authentication request.

   The PA-FX-COOKIE pdata type is defined in this section to facilitate
   state management.

       PA_FX_COOKIE                        TBA

   The corresponding padata-value field [RFC4120] contains the
   Distinguished Encoding Rules (DER) [X60] [X690] encoding of the
   following Abstract Syntax Notation One (ASN.1) type PA-FX-COOKIE:

     PA-FX-COOKIE ::= SEQUENCE {
         Cookie          [1] OCTET STRING,
             -- Opaque data, for use to associate all the messages in a
             -- single conversation between the client and the KDC.
             -- This can be generated by either the client or the KDC.
             -- The receiver MUST copy the exact Cookie encapsulated in
             -- a PA_FX_COOKIE data element into the next message of the
             -- same conversation.
         ...
     }

   The PA-FX-COOKIE structure contains a opaque cookie that is a logic
   identifier of all the messages in a conversation.

   The PA_FX_COOKIE can be initially sent by the client or the KDC, the
   receiver MUST copy the Cookie into a PA_FX_COOKIE padata and include
   it in the next message, if any, in the same conversation.

   The content of the PA_FX_COOKIE padata is a local matter of the
   sender.  Implementations MUST NOT include any sensitive or private
   data in the PA-FX-COOKIE structure.

   If at least one more message for a mechanism or a mechanism set is
   expected by the KDC, the KDC returns a
   KDC_ERR_MORE_PREAUTH_DATA_NEEDED error with a PA_FX_COOKIE to



Zhu & Hartman            Expires April 26, 2007                [Page 16]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   identify the conversation with the client.

       KDC_ERR_MORE_PREAUTH_DATA_NEEDED    TBA

   If a PA_FX_COOKIE is included in the client request, the KDC then
   MUST copy the exact cookie into the response.

6.4.  Pre-authentication Set

   If all mechanisms in a group need to successfully complete in order
   to authenticate a client, the client and the KDC SHOULD use the
   PA_AUTHENTICATION_SET padata element.  A PA_AUTHENTICATION_SET padata
   element contains the ASN.1 DER encoding of the PA-AUTHENTICATION-SET
   structure:

       PA-AUTHENTICATION-SET ::= SEQUENCE OF PA-AUTHENTICATION-SET-ELEM

       PA-AUTHENTICATION-SET-ELEM ::= SEQUENCE {
          pa-type          [1] Int32,
               -- same as padata-type.
          pa-hint          [2] OCTET STRING,
               -- hint data.
           ...
       }

   The pa-type field of the PA-AUTHENTICATION-SET-ELEM structure
   contains the corresponding value of padata-type in PA-DATA [RFC4120].
   Associated with the pa-type is a pa-hint, which is an octet-string
   specified by the pre-authentication mechanism.  This hint may provide
   information for the client which helps it determine whether the
   mechanism can be used.  For example a public-key mechanism might
   include the certificate authorities it trusts in the hint info.  Most
   mechanisms today do not specify hint info; if a mechanism does not
   specify hint info the KDC MUST NOT send a hint for that mechanism.
   To allow future revisions of mechanism specifications to add hint
   info, clients MUST ignore hint info received for mechanisms that the
   client believes do not support hint info.

   When indicating which sets of padata are supported, the KDC includes
   a PA-AUTHENTICATION-SET padata element for each authentication set.

   The client element sends the padata-value for the first mechanism in
   the authentication set, when the first mechanism completes, the
   client and the KDC will proceed with the second mechanism, and so on.
   The PA_FX_COOKIE as defined in Section 6.3 MUST be sent along with
   the first message that contains a PA-AUTHENTICATION-SET, in order to
   keep track of KDC states.




Zhu & Hartman            Expires April 26, 2007                [Page 17]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


6.5.  Definition of Kerberos FAST Padata

   The cipher text exposure of encrypted timestamp pre-authentication
   data is a security concern for Kerberos.  Attackers can lauch offline
   dictionary attack using the cipher text.  The FAST pre-authentication
   padata is a tool to mitigate this threat.  FAST also provides
   solutions to common problems for pre-authentication mechanisms such
   as binding of the request and the reply, freshness guarantee of the
   authentication.  FAST itself, however, does not authenticate the
   client or the KDC, instead, it provides a typed hole to allow pre-
   authentication data be carried with the FAST messages.  A pre-
   authentication data element used within FAST is called a FAST factor.
   A FAST factor represents the minimal work required for extending
   Kerberos to support a new authentication scheme.  A FAST factor MUST
   NOT be used outside of FAST unless its specification explicitly
   allows so.  The FAST typed hole can also be used as a generic one not
   intended to prove the client's identity, or establish the reply key.

   New pre-authentication mechanisms SHOULD design as FAST factors,
   instead of full-blown pre-authentication mechanisms.

   A FAST mechanism factor when used within FAST to authenticate the
   client or the KDC is a pre-authentication mechanism, as such the
   specification of such a FAST factor SHOULD specify which facilities
   it provides per Section 5.

   Implementations of the pre-authentication framework SHOULD use
   encrypted timestamp pre-authentication, if that is the mechanism to
   authenticate the client, as a FAST factor to avoid security exposure.

   The encrypted timestamp FAST factor MUST fill out the encrypted rep-
   key-package field as described in this section.  This pre-
   authentication mechanism provides the following facilities: client-
   authentication, replacing-reply-key, KDC-authentication.  It does not
   provide the strengthening-reply-key facility.  The security
   considerations section of this document provides an explaination why
   the security requirements are met.

   FAST employs an armoring scheme.  The armor can be a host TGT, or an
   anonymous TGT obtained based on anonymous PKINIT [KRB-ANON], or a
   pre-shared long term key such as a host key.  The rest of this
   section describes the messages used by FAST.

6.5.1.  FAST Request

   A padata type PA_FX_FAST is defined for the FAST Kerberos pre-
   authentication padata.  The corresponding padata-value field
   [RFC4120] contains the DER encoding of the ASN.1 type PA-FX-FAST-



Zhu & Hartman            Expires April 26, 2007                [Page 18]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   REQUEST.

    PA-FX-FAST-REQUEST ::= CHOICE {
        armored-data    [1] KrbFastAmoredReq,
        ...
    }

    KrbFastAmoredReq ::= SEQUENCE {
        armor           [1] KrbFastArmor OPTIONAL,
            -- Contains the armor that determines the armor key.
            -- MUST be present in the initial AS-REQ in a converstation,
            -- MUST be absent in any subsequent AS-REQ.
            -- MUST be absent in TGS-REQ.
        req-checksum    [2] Checksum,
            -- Checksum performed over the type KDC-REQ-BODY.
            -- The checksum key is the armor key, and the checksum
            -- type is the required checksum type for the enctype of
            -- the armor key.
        enc-fast-req    [3] EncryptedData, -- KrbFastReq --
            -- The encryption key is the armor key, and the key usage
            -- number is TBA.
        ...
    }

   The PA-FX-FAST-REQUEST contains a KrbFastAmoredReq structure.  The
   KrbFastAmoredReq encapsulates the encrypted padata.

   The key used to encrypt the KrbFastReq structure in the
   KrbFastAmoredReq is called the armor key, and the key usage number
   for that encryption is TBA.

   When a KrbFastAmoredReq is included in an AS request, the
   KrbFastArmor field MUST be present in the initial AS-REQ in a
   converstation, specifying the armor key being used.  The armor field
   MUST be absent in any subsequent AS-REQ of the same converstation.
   Thus the armor key is specified explicitly in the initial AS-REQ in a
   converstation, and implicitly thereafter.

   When a KrbFastAmoredReq is included in a TGS request, the
   KrbFastArmor field MUST be absent.  In which case, the subkey in the
   AP-REQ authenticator in the PA-TGS-REQ MUST be present, and the armor
   key is implicitly that subkey.

6.5.1.1.  FAST Armor

   The ArmorData structure is used to identify the armor key.  It
   contains two fields: The armor-type identifies the type of armor
   data, and the armor-value as an OCTET STRING contains the data.



Zhu & Hartman            Expires April 26, 2007                [Page 19]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


       KrbFastArmor ::= SEQUENCE {
           armor-type     [1] Int32,
               -- Type of the armor.
           armor-value    [2] OCTET STRING,
               -- Value of the armor.
           ...
       }

   The value of the armor key is a matter of the armor type
   specification.  The following types of armors are defined:


       FX_FAST_ARMOR_AP_REQUEST  1
       FX_FAST_ARMOR_KEY_ID      2

6.5.1.1.1.  Ticket Based Armors

   The FX_FAST_ARMOR_AP_REQUEST armor type is based on a Kerberos
   ticket.  The content of a FX_FAST_ARMOR_AP_REQUEST is an AP-REQ
   encoded in DER.  The subkey field in the AP-REQ MUST be present.  And
   the armor key is the subkey in the AP-REQ authenticator.

   If the client has a TGT for the expected KDC, it can use that ticket
   to construct the AP-REQ.  If not, the client can use anonymous PKINIT
   as described in [KRB-ANON] to obtain a TGT anonymously and use that
   to construct a FX_FAST_ARMOR_AP_REQUEST armor.

6.5.1.1.2.  Key Based Armors

   The FX_FAST_ARMOR_KEY_ID armor type contains an identifier of a key
   shared between the client host and the KDC.  The content and the
   encoding of the armor-data is a local matter of the client and the
   KDC.  The FX_FAST_ARMOR_KEY_ID value is an identifier of the armor
   key.  The FX_FAST_ARMOR_KEY_ID armor is useful when the client host
   and the KDC does have a shared key and it is beneficial to minimize
   the number of messages exchanged between the client and the KDC,
   namely eliminating the messages to obtain a host ticket based on the
   host key.

   Conforming implementations MUST implement the
   FX_FAST_ARMOR_AP_REQUEST armor.

   The req-checksum field contains a checksum that is performed over the
   type KDC-REQ-BODY.  The checksum key is the armor key, and the
   checksum type is the required checksum type for the enctype of the
   armor key.

   The enc-fast-req field contains an encrypted KrbFastReq structure.



Zhu & Hartman            Expires April 26, 2007                [Page 20]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   The KrbFastReq structure contains the following information:

       KrbFastReq ::= SEQUENCE {
           fast-options    [0] FastOptions,
               -- Additional options.
           padata          [1] SEQUENCE OF PA-DATA,
               -- padata typed holes.
           timestamp       [2] KerberosTime,
           usec            [3] Microseconds,
               -- timestamp and usec represent the time of the client
               -- host.
           req-nonce       [4] OCTET STRING,
               -- At least 128 octets in length, randomly filled using
               -- a PRNG by the client for each message request.
           ...
       }

   The fast-options field indicates various options to modify the
   behavior of the KDC.  The meanings of the options are as follows:

      FastOptions ::= KerberosFlags
          -- reserved(0),
          -- anonymous(1),
          -- kdc-referrals(16)


      Bits    Name          Description
     -----------------------------------------------------------------
      0     RESERVED        Reserved for future expansion of this field.
      1     anonymous       Requesting the KDC to hide client names in
                            the KDC response, as described next in this
                            section.
      16    kdc-referrals   Requesting the KDC to follow referrals, as
                            described next in this section.

   Bits 1 through 15 (with bit 2 and bit 15 included) are critical
   options.  If the KDC does not understand the critical option, it MUST
   fail the request.  Bit 16 and onward (with bit 16 included) are non-
   critical options.  The KDC ignores an unknown non-critical option.

   The anonymous Option

      The Kerberos response defined in [RFC4120] contains the client
      identity in clear text, This makes traffic analysis
      straightforward.  The anonymous option is designed to complicate
      traffic analysis against the client-KDC exchange.  If the
      anonymous option is set, the KDC implementing PA_FX_FAST MUST
      identify out the client as the anonymous principal in the KDC



Zhu & Hartman            Expires April 26, 2007                [Page 21]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


      reply and the error response.  Thus this option is set by the
      client to hide the client identity in the KDC response.

   The kdc-referrals Option

      The Kerberos client described in [RFC4120] has to request referral
      TGTs along the authentication path in order to get a service
      ticket for the target service.  The Kerberos client described in
      the [REFERRALS] need to contain the AS specified in the error
      response in order to complete client referrals.  In many cases, it
      is desirable to keep the client's involvement minimal.  For
      example, the client may contact the KDC via a satellite link that
      has high latency, or the client has limited computational
      capabilities.  The kdc-referrals option is designed to minimize
      the number of KDC response messages that the client need to
      process.  If the kdc-referrals option is set, the KDC that honors
      this option acts as the client to follow AS referrals and TGS
      referrals [REFERRALS], and return the ticket thus-obtained using
      the reply key expected by the client.  The kdc-referrals option
      can be implemented when the KDC knows the reply key.  KDC can
      igore kdc-referrals option when it does not understand it or it
      does not allow it based on local policy.  The client MUST be able
      to process the KDC responses when this option is not honored by
      the KDC.

   The padata field contains a list of PA-DATA structures as described
   in Section 5.2.7 in [RFC4120].  These PA-DATA structures can contain
   FAST factors.  They can also be used as generic typed-holes to
   contain data not intended for proving the client's identity or
   establishing a reply, but for protocol extensibility.

   The timestamp and usec fields represent the time of the client host,
   these fields have the same semantics as the corresponding-
   identically-named fields in Section 5.6.1 of [RFC4120].

   The req-nonce field is randomly filled using a PRNG by the client for
   each message request.  It MUST have at least 128 octets in length.

6.5.2.  FAST Response

   The KDC that supports the PA_FX_FAST padata MUST include a PA_FX_FAST
   padata element in the KDC reply and/or the error response.  The KDC
   can include a PA_FX_FAST padata element in the error response when
   the client and the KDC agreed upon the armor key.  The corresponding
   padata-value field [RFC4120] in the KDC response is the DER encoding
   of the ASN.1 type PA-FX-FAST-REPLY.





Zhu & Hartman            Expires April 26, 2007                [Page 22]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


      PA-FX-FAST-REPLY ::= CHOICE {
          armored-data    [1] KrbFastArmoredRep,
          ...
      }

      KrbFastArmoredRep ::= SEQUENCE {
          enc-fast-rep    [1] EncryptedData, -- KrbFastResponse --
              -- The encryption key is the armor key in the request, and
              -- the key usage number is TBA.
          ...
      }

   The PA-FX-FAST-REPLY structure contains a KrbFastArmoredRep
   structure.  The KrbFastArmoredRep structure encapsulates the KDC
   reply in the encrypted form.  The KrbFastResponse is encrypted with
   the armor key used in the corresponding request, and the key usage
   number is TBA.

   The Kerberos client who does not receive a PA-FX-FAST-REPLY in the
   KDC response to a PA-FX-FAST-REQUEST MUST reject the reply based on a
   local policy.  The Kerberos client MAY process an error message
   without a PA-FX-FAST-REPLY, if that is only intended to return better
   error information to the application, typically for trouble-shooing
   purposes.

   The KrbFastResponse structure contains the following information:

      KrbFastResponse ::= SEQUENCE {
          padata          [1] SEQUENCE OF PA-DATA,
              -- padata typed holes.
          finish          [2] KrbFastFinish OPTIONAL,
              -- MUST be present if the client is authenticated,
              -- absent otherwise.
              -- Typically this is present if and only if the containing
              -- message is the last one in a conversation.
          rep-nonce       [3] OCTET STRING,
              -- At least 128 octets in length, randomly filled using
              -- a PRNG by the KDC for each KDC response.
          ...
      }

   The padata field in the KrbFastResponse structure contains a list of
   PA-DATA structures as described in Section 5.2.7 of [RFC4120].  These
   PA-DATA structures are used to carry data completing the exchange for
   the FAST factors.  They can also be used as generic typed-holes for
   protocol extensibility.

   The finish field contains a KrbFastFinish structure.  It is filled by



Zhu & Hartman            Expires April 26, 2007                [Page 23]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   the KDC to indicate the client has been authenticated, it MUST be
   absent otherwise.  This field can only be present in an AS-REP or a
   TGS-REP when a ticket is returned, and typically the containing
   message is the last one in a conversation.

   The KrbFastFinish structure contains the following information:

    KrbFastFinish ::= SEQUENCE {
        authtime        [1] KerberosTime,
        usec            [2] Microseconds,
            -- timestamp and usec represent the time on the KDC when
            -- the reply was generated.
        rep-key-package [3]  EncryptedData OPTIONAL, -- EncryptionKey --
            -- This, if present, replaces the reply key for AS and TGS.
            -- The encryption key is the client key, unless otherwise
            -- specified. The key usage number is TBA.
        crealm          [4] Realm,
        cname           [5] PrincipalName,
            -- Contains the client realm and the client name.
        checksum        [6] Checksum,
            -- Checksum performed over all the messages in the
            -- conversation, except the containing message.
            -- The checksum key is the ticket session key of the reply
            -- ticket, and the checksum type is the required checksum
            -- type of that key.
        ...
    }

   The timestamp and usec fields represent the time on the KDC when the
   reply was generated, these fields have the same semantics as the
   corresponding-identically-named fields in Section 5.6.1 of [RFC4120].
   The client MUST use the KDC's time in these fields thereafter when
   using the returned ticket.  This KDC time in AS-REP may not match the
   authtime in the reply ticket if the kdc-referrals option is requested
   and honored by the KDC.

   The rep-key-package field, if present, contains the reply key
   encrypted using the client key unless otherwise specified.  The key
   usage number is TBA.

   When the encrypted timestamp FAST factor is used in the request, the
   rep-key-package field MUST be present.  If a KrbFastArmoredRep is
   included in the reply, the reply key MUST NOT be the client key.  The
   client key can be used to encrypt the reply key enclosed in the
   KrbFastArmoredRep.

   The cname and crealm fields identifies the authenticated client.




Zhu & Hartman            Expires April 26, 2007                [Page 24]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   The checksum field contains a checksum of all the prior messages in
   the conversation excluding the containing message.  The checksum key
   is the ticket session key of the reply ticket, and the checksum type
   is the required checksum type of that key.

   The rep-nonce field is randomly filled using a PRNG by the KDC, for
   each KDC response, and it MUST have at least 128 octets in length.

   The client MUST include a PA_FX_COOKIE as defined in Section 6.3, if
   it includes a PA_FX_FAST in the request.

6.6.  Authentication Strength Indication

   Implementations that have pre-authentication mechanisms offering
   significantly different strengths of client authentication MAY choose
   to keep track of the strength of the authentication used as an input
   into policy decisions.  For example, some principals might require
   strong pre-authentication, while less sensitive principals can use
   relatively weak forms of pre-authentication like encrypted timestamp.

   An AuthorizationData data type AD-Authentication-Strength is defined.

          AD-Authentication-Strength      TBA

   The corresponding ad-data field contains the DER encoding of the pre-
   authentication data set as defined in Section 6.4.  This set contains
   all the pre-authentication mechanisms that were used to authenticate
   the client.  If only one pre-authentication mechanism was used to
   authenticate the client, the pre-authentication set contains one
   element.

   The AD-Authentication-Strength element MUST be included in the AD-IF-
   RELEVANT, thus it can be ignored if it is unknown to the receiver.


7.  IANA Considerations

   This document defines FAST factors, these are mini- and light-
   weighted- pre-authentication mechanisms.  A new IANA registry should
   be setup for registering FAST factor IDs.


8.  Security Considerations

   The kdc-referrals option in the Kerberos FAST padata requests the KDC
   to act as the client to follow referrals.  This can overload the KDC.
   To limit the damages of denied of service using this option, KDCs MAY
   restrict the number of simultaneous active requests with this option



Zhu & Hartman            Expires April 26, 2007                [Page 25]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


   for any given client principal.

   Because the client secrets are known only to the client and the KDC,
   the verification of the encrypted timestamp proves the client's
   identity, the verification of the encrypted rep-key-package in the
   KDC reply proves that the expected KDC responded.  The encrypted
   reply key is contained in the rep-key-package in the PA-FX-FAST-
   REPLY.  Therefore, the encrypted timestamp FAST factor as a pre-
   authentication mechanism offers the following facilities: client-
   authentication, replacing-reply-key, KDC-authentication.  There is no
   un-authenticated cleartext introduced by the encrypted timestamp FAST
   factor.


9.  Acknowledgements

   Serveral suggestions from Jeffery Hutzman based on early revisions of
   this documents led significant improvements of this document.


10.  References

10.1.  Normative References

   [KRB-ANON] Zhu, L., Leach, P. and Jaganathan, K., "Kerberos Anonymity 
              Support", draft-ietf-krb-wg-anon, work in progress.

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119, March 1997.

   [RFC3961]  Raeburn, K., "Encryption and Checksum Specifications for
              Kerberos 5", RFC 3961, February 2005.

   [RFC4120]  Neuman, C., Yu, T., Hartman, S., and K. Raeburn, "The
              Kerberos Network Authentication Service (V5)", RFC 4120,
              July 2005.

   [REFERALS] Raeburn, K. et al, "Generating KDC Referrals to Locate 
              Kerberos Realms", draft-ietf-krb-wg-kerberos-referrals, 
              work in progress.

   [X680]     ITU-T Recommendation X.680 (2002) | ISO/IEC 8824-1:2002,
              Information technology - Abstract Syntax Notation One
              (ASN.1): Specification of basic notation.


Zhu & Hartman            Expires April 26, 2007                [Page 26]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006



   [X690]     ITU-T Recommendation X.690 (2002) | ISO/IEC 8825-1:2002,
              Information technology - ASN.1 encoding Rules:
              Specification of Basic Encoding Rules (BER), Canonical
              Encoding Rules (CER) and Distinguished Encoding Rules
              (DER).

10.2.  Informative References

   [EKE]      Bellovin, S. M. and M. Merritt. "Augmented 
              Encrypted Key Exchange: A Password-Based Protocol Secure 
              Against Dictionary Attacks and Password File Compromise". 
              Proceedings of the 1st ACM Conference on Computer and 
              Communications Security, ACM Press, November 1993.
              
   [IEEE1363.2] 
              IEEE P1363.2: Password-Based Public-Key Cryptography

   [RFC4556]  Zhu, L. and B. Tung, "Public Key Cryptography for Initial
              Authentication in Kerberos (PKINIT)", RFC 4556, June 2006.


Appendix A.  ASN.1 module

    KerberosPreauthFramework {
           iso(1) identified-organization(3) dod(6) internet(1)
           security(5) kerberosV5(2) modules(4) preauth-framework(3)
    } DEFINITIONS EXPLICIT TAGS ::= BEGIN

    PA-FX-COOKIE ::= SEQUENCE {
        Cookie              [1] OCTET STRING,
            -- Opaque data, for use to associate all the messages in a
            -- single conversation between the client and the KDC.
            -- This can be generated by either the client or the KDC.
            -- The receiver MUST copy the exact Cookie encapsulated in
            -- a PA_FX_COOKIE data element into the next message of the
            -- same conversation.
        ...
    }

    PA-AUTHENTICATION-SET ::= SEQUENCE OF PA-AUTHENTICATION-SET-ELEM

    PA-AUTHENTICATION-SET-ELEM ::= SEQUENCE {
       pa-type          [1] Int32,
            -- same as padata-type.
       pa-hint          [2] OCTET STRING,
            -- hint data.
        ...
        ...
    }

    PA-FX-FAST-REQUEST ::= CHOICE {
        armored-data    [1] KrbFastAmoredReq,
        ...
    }

    KrbFastAmoredReq ::= SEQUENCE {
        armor           [1] KrbFastArmor OPTIONAL,
            -- Contains the armor that determines the armor key.
            -- MUST be present in AS-REQ.
            -- MUST be absent in TGS-REQ.
        req-checksum    [2] Checksum,
            -- Checksum performed over the type KDC-REQ-BODY.
            -- The checksum key is the armor key, and the checksum
            -- type is the required checksum type for the enctype of
            -- the armor key.
        enc-fast-req    [3] EncryptedData, -- KrbFastReq --
            -- The encryption key is the armor key, and the key usage
            -- number is TBA.
        ...
    }

Zhu & Hartman            Expires April 26, 2007                [Page 27]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006



    KrbFastArmor ::= SEQUENCE {
        armor-type     [1] Int32,
            -- Type of the armor.
        armor-value    [2] OCTET STRING,
            -- Value of the armor.
        ...
    }

    KrbFastReq ::= SEQUENCE {
        fast-options    [0] FastOptions,
            -- Additional options.
        padata          [1] SEQUENCE OF PA-DATA,
            -- padata typed holes.
        timestamp       [2] KerberosTime,
        usec            [3] Microseconds,
            -- timestamp and usec represent the time of the client
            -- host.
        req-nonce       [4] OCTET STRING,
            -- At least 128 octets in length, randomly filled using
            -- a PRNG by the client for each message request.
        ...
    }

    FastOptions ::= KerberosFlags
        -- reserved(0),
        -- anonymous(1),
        -- kdc-referrals(16)

    PA-FX-FAST-REPLY ::= SEQUENCE {
        enc-fast-rep    [1] EncryptedData, -- KrbFastResponse --
            -- The encryption key is the armor key in the request, and
            -- the key usage number is TBA.
        ...
    }

    KrbFastResponse ::= SEQUENCE {
        padata          [1] SEQUENCE OF PA-DATA,
            -- padata typed holes.
        finish          [2] KrbFastFinish OPTIONAL,
            -- MUST be present if the client is authenticated,
            -- absent otherwise.
            -- Typically this is present if and only if the containing
            -- message is the last one in a conversation.
        rep-nonce       [3] OCTET STRING,
            -- At least 128 octets in length, randomly filled using
            -- a PRNG by the KDC for each KDC response.
        ...
    }


Zhu & Hartman            Expires April 26, 2007                [Page 28]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006



    KrbFastFinish ::= SEQUENCE {
        timestamp       [1] KerberosTime,
        usec            [2] Microseconds,
            -- timestamp and usec represent the time on the KDC when
            -- the reply was generated.
        rep-key-package [3]  EncryptedData OPTIONAL, -- EncryptionKey --
            -- This, if present, replaces the reply key for AS and TGS.
            -- The encryption key is the client key, unless otherwise
            -- specified. The key usage number is TBA.
        crealm          [4] Realm,
        cname           [5] PrincipalName,
            -- Contains the client realm and the client name.
        checksum        [6] Checksum,
            -- Checksum performed over all the messages in the
            -- conversation, except the containing message.
            -- The checksum key is the ticket session key of the reply
            -- ticket, and the checksum type is the required checksum
            -- type of that key.
        ...
    }

    END


Authors' Addresses

   Larry Zhu
   Microsoft Corporation
   One Microsoft Way
   Redmond, WA  98052
   US

   Email: lzhu@microsoft.com


   Sam hartman
   MIT

   Email: hartmans@mit.edu






Zhu & Hartman            Expires April 26, 2007                [Page 29]
\f
Internet-Draft         Kerberos Preauth Framework           October 2006


Full Copyright Statement

   Copyright (C) The Internet Society (2006).

   This document is subject to the rights, licenses and restrictions
   contained in BCP 78, and except as set forth therein, the authors
   retain all their rights.

   This document and the information contained herein are provided on an
   "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
   OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET
   ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED,
   INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
   INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
   WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.


Intellectual Property

   The IETF takes no position regarding the validity or scope of any
   Intellectual Property Rights or other rights that might be claimed to
   pertain to the implementation or use of the technology described in
   this document or the extent to which any license under such rights
   might or might not be available; nor does it represent that it has
   made any independent effort to identify any such rights.  Information
   on the procedures with respect to rights in RFC documents can be
   found in BCP 78 and BCP 79.

   Copies of IPR disclosures made to the IETF Secretariat and any
   assurances of licenses to be made available, or the result of an
   attempt made to obtain a general license or permission for the use of
   such proprietary rights by implementers or users of this
   specification can be obtained from the IETF on-line IPR repository at
   http://www.ietf.org/ipr.

   The IETF invites any interested party to bring to its attention any
   copyrights, patents or patent applications, or other proprietary
   rights that may cover technology that may be required to implement
   this standard.  Please address the information to the IETF at
   ietf-ipr@ietf.org.


Acknowledgment

   Funding for the RFC Editor function is provided by the IETF
   Administrative Support Activity (IASA).





Zhu & Hartman            Expires April 26, 2007                [Page 30]
\f