Tech-invite3GPPspaceIETFspace
96959493929190898887868584838281807978777675747372717069686766656463626160595857565554535251504948474645444342414039383736353433323130292827262524232221201918171615141312111009080706050403020100
in Index   Prev   Next

RFC 1510

The Kerberos Network Authentication Service (V5)

Pages: 112
Obsoleted by:  41206649
Part 1 of 4 – Pages 1 to 20
None   None   Next

ToP   noToC   RFC1510 - Page 1
Network Working Group                                            J. Kohl
Request for Comments: 1510                 Digital Equipment Corporation
                                                               C. Neuman
                                                                     ISI
                                                          September 1993


            The Kerberos Network Authentication Service (V5)

Status of this Memo

   This RFC specifies an Internet standards track protocol for the
   Internet community, and requests discussion and suggestions for
   improvements.  Please refer to the current edition of the "Internet
   Official Protocol Standards" for the standardization state and status
   of this protocol.  Distribution of this memo is unlimited.

Abstract

   This document gives an overview and specification of Version 5 of the
   protocol for the Kerberos network authentication system. Version 4,
   described elsewhere [1,2], is presently in production use at MIT's
   Project Athena, and at other Internet sites.

Overview

   Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos,
   Moira, and Zephyr are trademarks of the Massachusetts Institute of
   Technology (MIT).  No commercial use of these trademarks may be made
   without prior written permission of MIT.

   This RFC describes the concepts and model upon which the Kerberos
   network authentication system is based. It also specifies Version 5
   of the Kerberos protocol.

   The motivations, goals, assumptions, and rationale behind most design
   decisions are treated cursorily; for Version 4 they are fully
   described in the Kerberos portion of the Athena Technical Plan [1].
   The protocols are under review, and are not being submitted for
   consideration as an Internet standard at this time.  Comments are
   encouraged.  Requests for addition to an electronic mailing list for
   discussion of Kerberos, kerberos@MIT.EDU, may be addressed to
   kerberos-request@MIT.EDU.  This mailing list is gatewayed onto the
   Usenet as the group comp.protocols.kerberos.  Requests for further
   information, including documents and code availability, may be sent
   to info-kerberos@MIT.EDU.
ToP   noToC   RFC1510 - Page 2
Background

   The Kerberos model is based in part on Needham and Schroeder's
   trusted third-party authentication protocol [3] and on modifications
   suggested by Denning and Sacco [4].  The original design and
   implementation of Kerberos Versions 1 through 4 was the work of two
   former Project Athena staff members, Steve Miller of Digital
   Equipment Corporation and Clifford Neuman (now at the Information
   Sciences Institute of the University of Southern California), along
   with Jerome Saltzer, Technical Director of Project Athena, and
   Jeffrey Schiller, MIT Campus Network Manager.  Many other members of
   Project Athena have also contributed to the work on Kerberos.
   Version 4 is publicly available, and has seen wide use across the
   Internet.

   Version 5 (described in this document) has evolved from Version 4
   based on new requirements and desires for features not available in
   Version 4.  Details on the differences between Kerberos Versions 4
   and 5 can be found in [5].

Table of Contents

   1. Introduction .......................................    5
   1.1. Cross-Realm Operation ............................    7
   1.2. Environmental assumptions ........................    8
   1.3. Glossary of terms ................................    9
   2. Ticket flag uses and requests ......................   12
   2.1. Initial and pre-authenticated tickets ............   12
   2.2. Invalid tickets ..................................   12
   2.3. Renewable tickets ................................   12
   2.4. Postdated tickets ................................   13
   2.5. Proxiable and proxy tickets ......................   14
   2.6. Forwardable tickets ..............................   15
   2.7. Other KDC options ................................   15
   3. Message Exchanges ..................................   16
   3.1. The Authentication Service Exchange ..............   16
   3.1.1. Generation of KRB_AS_REQ message ...............   17
   3.1.2. Receipt of KRB_AS_REQ message ..................   17
   3.1.3. Generation of KRB_AS_REP message ...............   17
   3.1.4. Generation of KRB_ERROR message ................   19
   3.1.5. Receipt of KRB_AS_REP message ..................   19
   3.1.6. Receipt of KRB_ERROR message ...................   20
   3.2. The Client/Server Authentication Exchange ........   20
   3.2.1. The KRB_AP_REQ message .........................   20
   3.2.2. Generation of a KRB_AP_REQ message .............   20
   3.2.3. Receipt of KRB_AP_REQ message ..................   21
   3.2.4. Generation of a KRB_AP_REP message .............   23
   3.2.5. Receipt of KRB_AP_REP message ..................   23
ToP   noToC   RFC1510 - Page 3
   3.2.6. Using the encryption key .......................   24
   3.3. The Ticket-Granting Service (TGS) Exchange .......   24
   3.3.1. Generation of KRB_TGS_REQ message ..............   25
   3.3.2. Receipt of KRB_TGS_REQ message .................   26
   3.3.3. Generation of KRB_TGS_REP message ..............   27
   3.3.3.1. Encoding the transited field .................   29
   3.3.4. Receipt of KRB_TGS_REP message .................   31
   3.4. The KRB_SAFE Exchange ............................   31
   3.4.1. Generation of a KRB_SAFE message ...............   31
   3.4.2. Receipt of KRB_SAFE message ....................   32
   3.5. The KRB_PRIV Exchange ............................   33
   3.5.1. Generation of a KRB_PRIV message ...............   33
   3.5.2. Receipt of KRB_PRIV message ....................   33
   3.6. The KRB_CRED Exchange ............................   34
   3.6.1. Generation of a KRB_CRED message ...............   34
   3.6.2. Receipt of KRB_CRED message ....................   34
   4. The Kerberos Database ..............................   35
   4.1. Database contents ................................   35
   4.2. Additional fields ................................   36
   4.3. Frequently Changing Fields .......................   37
   4.4. Site Constants ...................................   37
   5. Message Specifications .............................   38
   5.1. ASN.1 Distinguished Encoding Representation ......   38
   5.2. ASN.1 Base Definitions ...........................   38
   5.3. Tickets and Authenticators .......................   42
   5.3.1. Tickets ........................................   42
   5.3.2. Authenticators .................................   47
   5.4. Specifications for the AS and TGS exchanges ......   49
   5.4.1. KRB_KDC_REQ definition .........................   49
   5.4.2. KRB_KDC_REP definition .........................   56
   5.5. Client/Server (CS) message specifications ........   58
   5.5.1. KRB_AP_REQ definition ..........................   58
   5.5.2. KRB_AP_REP definition ..........................   60
   5.5.3. Error message reply ............................   61
   5.6. KRB_SAFE message specification ...................   61
   5.6.1. KRB_SAFE definition ............................   61
   5.7. KRB_PRIV message specification ...................   62
   5.7.1. KRB_PRIV definition ............................   62
   5.8. KRB_CRED message specification ...................   63
   5.8.1. KRB_CRED definition ............................   63
   5.9. Error message specification ......................   65
   5.9.1. KRB_ERROR definition ...........................   66
   6. Encryption and Checksum Specifications .............   67
   6.1. Encryption Specifications ........................   68
   6.2. Encryption Keys ..................................   71
   6.3. Encryption Systems ...............................   71
   6.3.1. The NULL Encryption System (null) ..............   71
   6.3.2. DES in CBC mode with a CRC-32 checksum (descbc-crc)71
ToP   noToC   RFC1510 - Page 4
   6.3.3. DES in CBC mode with an MD4 checksum (descbc-md4)  72
   6.3.4. DES in CBC mode with an MD5 checksum (descbc-md5)  72
   6.4. Checksums ........................................   74
   6.4.1. The CRC-32 Checksum (crc32) ....................   74
   6.4.2. The RSA MD4 Checksum (rsa-md4) .................   75
   6.4.3. RSA MD4 Cryptographic Checksum Using DES
   (rsa-md4-des) .........................................   75
   6.4.4. The RSA MD5 Checksum (rsa-md5) .................   76
   6.4.5. RSA MD5 Cryptographic Checksum Using DES
   (rsa-md5-des) .........................................   76
   6.4.6. DES cipher-block chained checksum (des-mac)
   6.4.7. RSA MD4 Cryptographic Checksum Using DES
   alternative (rsa-md4-des-k) ...........................   77
   6.4.8. DES cipher-block chained checksum alternative
   (des-mac-k) ...........................................   77
   7. Naming Constraints .................................   78
   7.1. Realm Names ......................................   77
   7.2. Principal Names ..................................   79
   7.2.1. Name of server principals ......................   80
   8. Constants and other defined values .................   80
   8.1. Host address types ...............................   80
   8.2. KDC messages .....................................   81
   8.2.1. IP transport ...................................   81
   8.2.2. OSI transport ..................................   82
   8.2.3. Name of the TGS ................................   82
   8.3. Protocol constants and associated values .........   82
   9. Interoperability requirements ......................   86
   9.1. Specification 1 ..................................   86
   9.2. Recommended KDC values ...........................   88
   10. Acknowledgments ...................................   88
   11. References ........................................   89
   12. Security Considerations ...........................   90
   13. Authors' Addresses ................................   90
   A. Pseudo-code for protocol processing ................   91
   A.1. KRB_AS_REQ generation ............................   91
   A.2. KRB_AS_REQ verification and KRB_AS_REP generation    92
   A.3. KRB_AS_REP verification ..........................   95
   A.4. KRB_AS_REP and KRB_TGS_REP common checks .........   96
   A.5. KRB_TGS_REQ generation ...........................   97
   A.6. KRB_TGS_REQ verification and KRB_TGS_REP generation  98
   A.7. KRB_TGS_REP verification .........................  104
   A.8. Authenticator generation .........................  104
   A.9. KRB_AP_REQ generation ............................  105
   A.10. KRB_AP_REQ verification .........................  105
   A.11. KRB_AP_REP generation ...........................  106
   A.12. KRB_AP_REP verification .........................  107
   A.13. KRB_SAFE generation .............................  107
   A.14. KRB_SAFE verification ...........................  108
ToP   noToC   RFC1510 - Page 5
   A.15. KRB_SAFE and KRB_PRIV common checks .............  108
   A.16. KRB_PRIV generation .............................  109
   A.17. KRB_PRIV verification ...........................  110
   A.18. KRB_CRED generation .............................  110
   A.19. KRB_CRED verification ...........................  111
   A.20. KRB_ERROR generation ............................  112

1.  Introduction

   Kerberos provides a means of verifying the identities of principals,
   (e.g., a workstation user or a network server) on an open
   (unprotected) network.  This is accomplished without relying on
   authentication by the host operating system, without basing trust on
   host addresses, without requiring physical security of all the hosts
   on the network, and under the assumption that packets traveling along
   the network can be read, modified, and inserted at will. (Note,
   however, that many applications use Kerberos' functions only upon the
   initiation of a stream-based network connection, and assume the
   absence of any "hijackers" who might subvert such a connection.  Such
   use implicitly trusts the host addresses involved.)  Kerberos
   performs authentication under these conditions as a trusted third-
   party authentication service by using conventional cryptography,
   i.e., shared secret key.  (shared secret key - Secret and private are
   often used interchangeably in the literature.  In our usage, it takes
   two (or more) to share a secret, thus a shared DES key is a secret
   key.  Something is only private when no one but its owner knows it.
   Thus, in public key cryptosystems, one has a public and a private
   key.)

   The authentication process proceeds as follows: A client sends a
   request to the authentication server (AS) requesting "credentials"
   for a given server.  The AS responds with these credentials,
   encrypted in the client's key.  The credentials consist of 1) a
   "ticket" for the server and 2) a temporary encryption key (often
   called a "session key").  The client transmits the ticket (which
   contains the client's identity and a copy of the session key, all
   encrypted in the server's key) to the server.  The session key (now
   shared by the client and server) is used to authenticate the client,
   and may optionally be used to authenticate the server.  It may also
   be used to encrypt further communication between the two parties or
   to exchange a separate sub-session key to be used to encrypt further
   communication.

   The implementation consists of one or more authentication servers
   running on physically secure hosts.  The authentication servers
   maintain a database of principals (i.e., users and servers) and their
   secret keys. Code libraries provide encryption and implement the
   Kerberos protocol.  In order to add authentication to its
ToP   noToC   RFC1510 - Page 6
   transactions, a typical network application adds one or two calls to
   the Kerberos library, which results in the transmission of the
   necessary messages to achieve authentication.

   The Kerberos protocol consists of several sub-protocols (or
   exchanges).  There are two methods by which a client can ask a
   Kerberos server for credentials.  In the first approach, the client
   sends a cleartext request for a ticket for the desired server to the
   AS. The reply is sent encrypted in the client's secret key. Usually
   this request is for a ticket-granting ticket (TGT) which can later be
   used with the ticket-granting server (TGS).  In the second method,
   the client sends a request to the TGS.  The client sends the TGT to
   the TGS in the same manner as if it were contacting any other
   application server which requires Kerberos credentials.  The reply is
   encrypted in the session key from the TGT.

   Once obtained, credentials may be used to verify the identity of the
   principals in a transaction, to ensure the integrity of messages
   exchanged between them, or to preserve privacy of the messages.  The
   application is free to choose whatever protection may be necessary.

   To verify the identities of the principals in a transaction, the
   client transmits the ticket to the server.  Since the ticket is sent
   "in the clear" (parts of it are encrypted, but this encryption
   doesn't thwart replay) and might be intercepted and reused by an
   attacker, additional information is sent to prove that the message
   was originated by the principal to whom the ticket was issued.  This
   information (called the authenticator) is encrypted in the session
   key, and includes a timestamp.  The timestamp proves that the message
   was recently generated and is not a replay.  Encrypting the
   authenticator in the session key proves that it was generated by a
   party possessing the session key.  Since no one except the requesting
   principal and the server know the session key (it is never sent over
   the network in the clear) this guarantees the identity of the client.

   The integrity of the messages exchanged between principals can also
   be guaranteed using the session key (passed in the ticket and
   contained in the credentials).  This approach provides detection of
   both replay attacks and message stream modification attacks.  It is
   accomplished by generating and transmitting a collision-proof
   checksum (elsewhere called a hash or digest function) of the client's
   message, keyed with the session key.  Privacy and integrity of the
   messages exchanged between principals can be secured by encrypting
   the data to be passed using the session key passed in the ticket, and
   contained in the credentials.

   The authentication exchanges mentioned above require read-only access
   to the Kerberos database.  Sometimes, however, the entries in the
ToP   noToC   RFC1510 - Page 7
   database must be modified, such as when adding new principals or
   changing a principal's key.  This is done using a protocol between a
   client and a third Kerberos server, the Kerberos Administration
   Server (KADM).  The administration protocol is not described in this
   document. There is also a protocol for maintaining multiple copies of
   the Kerberos database, but this can be considered an implementation
   detail and may vary to support different database technologies.

1.1.  Cross-Realm Operation

   The Kerberos protocol is designed to operate across organizational
   boundaries.  A client in one organization can be authenticated to a
   server in another.  Each organization wishing to run a Kerberos
   server establishes its own "realm".  The name of the realm in which a
   client is registered is part of the client's name, and can be used by
   the end-service to decide whether to honor a request.

   By establishing "inter-realm" keys, the administrators of two realms
   can allow a client authenticated in the local realm to use its
   authentication remotely (Of course, with appropriate permission the
   client could arrange registration of a separately-named principal in
   a remote realm, and engage in normal exchanges with that realm's
   services. However, for even small numbers of clients this becomes
   cumbersome, and more automatic methods as described here are
   necessary).  The exchange of inter-realm keys (a separate key may be
   used for each direction) registers the ticket-granting service of
   each realm as a principal in the other realm.  A client is then able
   to obtain a ticket-granting ticket for the remote realm's ticket-
   granting service from its local realm. When that ticket-granting
   ticket is used, the remote ticket-granting service uses the inter-
   realm key (which usually differs from its own normal TGS key) to
   decrypt the ticket-granting ticket, and is thus certain that it was
   issued by the client's own TGS. Tickets issued by the remote ticket-
   granting service will indicate to the end-service that the client was
   authenticated from another realm.

   A realm is said to communicate with another realm if the two realms
   share an inter-realm key, or if the local realm shares an inter-realm
   key with an intermediate realm that communicates with the remote
   realm.  An authentication path is the sequence of intermediate realms
   that are transited in communicating from one realm to another.

   Realms are typically organized hierarchically. Each realm shares a
   key with its parent and a different key with each child.  If an
   inter-realm key is not directly shared by two realms, the
   hierarchical organization allows an authentication path to be easily
   constructed.  If a hierarchical organization is not used, it may be
   necessary to consult some database in order to construct an
ToP   noToC   RFC1510 - Page 8
   authentication path between realms.

   Although realms are typically hierarchical, intermediate realms may
   be bypassed to achieve cross-realm authentication through alternate
   authentication paths (these might be established to make
   communication between two realms more efficient).  It is important
   for the end-service to know which realms were transited when deciding
   how much faith to place in the authentication process. To facilitate
   this decision, a field in each ticket contains the names of the
   realms that were involved in authenticating the client.

1.2.  Environmental assumptions

   Kerberos imposes a few assumptions on the environment in which it can
   properly function:

   +    "Denial of service" attacks are not solved with Kerberos.  There
        are places in these protocols where an intruder intruder can
        prevent an application from participating in the proper
        authentication steps.  Detection and solution of such attacks
        (some of which can appear to be not-uncommon "normal" failure
        modes for the system) is usually best left to the human
        administrators and users.

   +    Principals must keep their secret keys secret.  If an intruder
        somehow steals a principal's key, it will be able to masquerade
        as that principal or impersonate any server to the legitimate
        principal.

   +    "Password guessing" attacks are not solved by Kerberos.  If a
        user chooses a poor password, it is possible for an attacker to
        successfully mount an offline dictionary attack by repeatedly
        attempting to decrypt, with successive entries from a
        dictionary, messages obtained which are encrypted under a key
        derived from the user's password.

   +    Each host on the network must have a clock which is "loosely
        synchronized" to the time of the other hosts; this
        synchronization is used to reduce the bookkeeping needs of
        application servers when they do replay detection.  The degree
        of "looseness" can be configured on a per-server basis.  If the
        clocks are synchronized over the network, the clock
        synchronization protocol must itself be secured from network
        attackers.

   +    Principal identifiers are not recycled on a short-term basis.  A
        typical mode of access control will use access control lists
        (ACLs) to grant permissions to particular principals.  If a
ToP   noToC   RFC1510 - Page 9
        stale ACL entry remains for a deleted principal and the
        principal identifier is reused, the new principal will inherit
        rights specified in the stale ACL entry. By not re-using
        principal identifiers, the danger of inadvertent access is
        removed.

1.3.  Glossary of terms

   Below is a list of terms used throughout this document.


   Authentication      Verifying the claimed identity of a
                       principal.


   Authentication header A record containing a Ticket and an
                         Authenticator to be presented to a
                         server as part of the authentication
                         process.


   Authentication path  A sequence of intermediate realms transited
                        in the authentication process when
                        communicating from one realm to another.

   Authenticator       A record containing information that can
                       be shown to have been recently generated
                       using the session key known only by  the
                       client and server.


   Authorization       The process of determining whether a
                       client may use a service, which objects
                       the client is allowed to access, and the
                       type of access allowed for each.


   Capability          A token that grants the bearer permission
                       to access an object or service.  In
                       Kerberos, this might be a ticket whose
                       use is restricted by the contents of the
                       authorization data field, but which
                       lists no network addresses, together
                       with the session key necessary to use
                       the ticket.
ToP   noToC   RFC1510 - Page 10
   Ciphertext          The output of an encryption function.
                       Encryption transforms plaintext into
                       ciphertext.


   Client              A process that makes use of a network
                       service on behalf of a user.  Note that
                       in some cases a Server may itself be a
                       client of some other server (e.g., a
                       print server may be a client of a file
                       server).


   Credentials         A ticket plus the secret session key
                       necessary to successfully use that
                       ticket in an authentication exchange.


   KDC                 Key Distribution Center, a network service
                       that supplies tickets and temporary
                       session keys; or an instance of that
                       service or the host on which it runs.
                       The KDC services both initial ticket and
                       ticket-granting ticket requests.  The
                       initial ticket portion is sometimes
                       referred to as the Authentication Server
                       (or service).  The ticket-granting
                       ticket portion is sometimes referred to
                       as the ticket-granting server (or service).

   Kerberos            Aside from the 3-headed dog guarding
                       Hades, the name given to Project
                       Athena's authentication service, the
                       protocol used by that service, or the
                       code used to implement the authentication
                       service.


   Plaintext           The input to an encryption function  or
                       the output of a decryption function.
                       Decryption transforms ciphertext into
                       plaintext.


   Principal           A uniquely named client or server
                       instance that participates in a network
                       communication.
ToP   noToC   RFC1510 - Page 11
   Principal identifier The name used to uniquely identify each
                        different principal.


   Seal                To encipher a record containing several
                       fields in such a way that the fields
                       cannot be individually replaced without
                       either knowledge of the encryption key
                       or leaving evidence of tampering.


   Secret key          An encryption key shared by a principal
                       and the KDC, distributed outside the
                       bounds of the system, with a long lifetime.
                       In the case of a human user's
                       principal, the secret key is derived
                       from a password.


   Server              A particular Principal which provides a
                       resource to network clients.


   Service             A resource provided to network clients;
                       often provided by more than one server
                       (for example, remote file service).


   Session key         A temporary encryption key used between
                       two principals, with a lifetime limited
                       to the duration of a single login "session".


   Sub-session key     A temporary encryption key used between
                       two principals, selected and exchanged
                       by the principals using the session key,
                       and with a lifetime limited to the duration
                       of a single association.


   Ticket              A record that helps a client authenticate
                       itself to a server; it contains the
                       client's identity, a session key, a
                       timestamp, and other information, all
                       sealed using the server's secret key.
                       It only serves to authenticate a client
                       when presented along with a fresh
                       Authenticator.
ToP   noToC   RFC1510 - Page 12
2.  Ticket flag uses and requests

   Each Kerberos ticket contains a set of flags which are used to
   indicate various attributes of that ticket.  Most flags may be
   requested by a client when the ticket is obtained; some are
   automatically turned on and off by a Kerberos server as required.
   The following sections explain what the various flags mean, and gives
   examples of reasons to use such a flag.

2.1.  Initial and pre-authenticated tickets

   The INITIAL flag indicates that a ticket was issued using the AS
   protocol and not issued based on a ticket-granting ticket.
   Application servers that want to require the knowledge of a client's
   secret key (e.g., a passwordchanging program) can insist that this
   flag be set in any tickets they accept, and thus be assured that the
   client's key was recently presented to the application client.

   The PRE-AUTHENT and HW-AUTHENT flags provide addition information
   about the initial authentication, regardless of whether the current
   ticket was issued directly (in which case INITIAL will also be set)
   or issued on the basis of a ticket-granting ticket (in which case the
   INITIAL flag is clear, but the PRE-AUTHENT and HW-AUTHENT flags are
   carried forward from the ticket-granting ticket).

2.2.  Invalid tickets

   The INVALID flag indicates that a ticket is invalid.  Application
   servers must reject tickets which have this flag set.  A postdated
   ticket will usually be issued in this form. Invalid tickets must be
   validated by the KDC before use, by presenting them to the KDC in a
   TGS request with the VALIDATE option specified.  The KDC will only
   validate tickets after their starttime has passed.  The validation is
   required so that postdated tickets which have been stolen before
   their starttime can be rendered permanently invalid (through a hot-
   list mechanism).

2.3.  Renewable tickets

   Applications may desire to hold tickets which can be valid for long
   periods of time.  However, this can expose their credentials to
   potential theft for equally long periods, and those stolen
   credentials would be valid until the expiration time of the
   ticket(s).  Simply using shortlived tickets and obtaining new ones
   periodically would require the client to have long-term access to its
   secret key, an even greater risk.  Renewable tickets can be used to
   mitigate the consequences of theft.  Renewable tickets have two
   "expiration times": the first is when the current instance of the
ToP   noToC   RFC1510 - Page 13
   ticket expires, and the second is the latest permissible value for an
   individual expiration time.  An application client must periodically
   (i.e., before it expires) present a renewable ticket to the KDC, with
   the RENEW option set in the KDC request.  The KDC will issue a new
   ticket with a new session key and a later expiration time.  All other
   fields of the ticket are left unmodified by the renewal process.
   When the latest permissible expiration time arrives, the ticket
   expires permanently.  At each renewal, the KDC may consult a hot-list
   to determine if the ticket had been reported stolen since its last
   renewal; it will refuse to renew such stolen tickets, and thus the
   usable lifetime of stolen tickets is reduced.

   The RENEWABLE flag in a ticket is normally only interpreted by the
   ticket-granting service (discussed below in section 3.3).  It can
   usually be ignored by application servers.  However, some
   particularly careful application servers may wish to disallow
   renewable tickets.

   If a renewable ticket is not renewed by its  expiration time, the KDC
   will not renew the ticket.  The RENEWABLE flag is reset by default,
   but a client may request it be  set  by setting  the RENEWABLE option
   in the KRB_AS_REQ message.  If it is set, then the renew-till field
   in the ticket  contains the time after which the ticket may not be
   renewed.

2.4.  Postdated tickets

   Applications may occasionally need to obtain tickets for use much
   later, e.g., a batch submission system would need tickets to be valid
   at the time the batch job is serviced.  However, it is dangerous to
   hold valid tickets in a batch queue, since they will be on-line
   longer and more prone to theft.  Postdated tickets provide a way to
   obtain these tickets from the KDC at job submission time, but to
   leave them "dormant" until they are activated and validated by a
   further request of the KDC.  If a ticket theft were reported in the
   interim, the KDC would refuse to validate the ticket, and the thief
   would be foiled.

   The MAY-POSTDATE flag in a ticket is normally only interpreted by the
   ticket-granting service.  It can be ignored by application servers.
   This flag must be set in a ticket-granting ticket in order to issue a
   postdated ticket based on the presented ticket. It is reset by
   default; it may be requested by a client by setting the ALLOW-
   POSTDATE option in the KRB_AS_REQ message.  This flag does not allow
   a client to obtain a postdated ticket-granting ticket; postdated
   ticket-granting tickets can only by obtained by requesting the
   postdating in the KRB_AS_REQ message.  The life (endtime-starttime)
   of a postdated ticket will be the remaining life of the ticket-
ToP   noToC   RFC1510 - Page 14
   granting ticket at the time of the request, unless the RENEWABLE
   option is also set, in which case it can be the full life (endtime-
   starttime) of the ticket-granting ticket.  The KDC may limit how far
   in the future a ticket may be postdated.

   The POSTDATED flag indicates that a ticket has been postdated.  The
   application server can check the authtime field in the ticket to see
   when the original authentication occurred.  Some services may choose
   to reject postdated tickets, or they may only accept them within a
   certain period after the original authentication. When the KDC issues
   a POSTDATED ticket, it will also be marked as INVALID, so that the
   application client must present the ticket to the KDC to be validated
   before use.

2.5.  Proxiable and proxy tickets

   At times it may be necessary for a principal to allow a service  to
   perform an operation on its behalf.  The service must be able to take
   on the identity of the client, but only for  a particular purpose.  A
   principal can allow a service to take on the principal's identity for
   a particular purpose by granting it a proxy.

   The PROXIABLE flag in a ticket is normally only interpreted by the
   ticket-granting service. It can be ignored by application servers.
   When set, this flag tells the ticket-granting server that it is OK to
   issue a new ticket (but not a ticket-granting ticket) with a
   different network address based on this ticket.  This flag is set by
   default.

   This flag allows a client to pass a proxy to a server to perform a
   remote request on its behalf, e.g., a print service client can give
   the print server a proxy to access the client's files on a particular
   file server in order to satisfy a print request.

   In order to complicate the use of stolen credentials, Kerberos
   tickets are usually valid from only those network addresses
   specifically included in the ticket (It is permissible to request or
   issue tickets with no network addresses specified, but we do not
   recommend it).  For this reason, a client wishing to grant a proxy
   must request a new ticket valid for the network address of the
   service to be granted the proxy.

   The PROXY flag is set in a ticket by the  TGS  when  it issues a
   proxy ticket.  Application servers may check this flag and require
   additional authentication  from  the  agent presenting the proxy in
   order to provide an audit trail.
ToP   noToC   RFC1510 - Page 15
2.6.  Forwardable tickets

   Authentication forwarding is an instance of the proxy case where the
   service is granted complete use of the client's identity.  An example
   where it might be used is when a user logs in to a remote system and
   wants authentication to work from that system as if the login were
   local.

   The FORWARDABLE flag in a ticket is normally only interpreted by the
   ticket-granting service.  It can be ignored by application servers.
   The FORWARDABLE flag has an interpretation similar to that of the
   PROXIABLE flag, except ticket-granting tickets may also be issued
   with different network addresses.  This flag is reset by default, but
   users may request that it be set by setting the FORWARDABLE option in
   the AS request when they request their initial ticket-granting
   ticket.

   This flag allows for authentication forwarding without requiring the
   user to enter a password again.  If the flag is not set, then
   authentication forwarding is not permitted, but the same end result
   can still be achieved if the user engages in the AS exchange with the
   requested network addresses and supplies a password.

   The FORWARDED flag is set by the TGS when a client presents a ticket
   with the FORWARDABLE flag set and requests it be set by specifying
   the FORWARDED KDC option and supplying a set of addresses for the new
   ticket.  It is also set in all tickets issued based on tickets with
   the FORWARDED flag set.  Application servers may wish to process
   FORWARDED tickets differently than non-FORWARDED tickets.

2.7.  Other KDC options

   There are two additional options which may be set in a client's
   request of the KDC.  The RENEWABLE-OK option indicates that the
   client will accept a renewable ticket if a ticket with the requested
   life cannot otherwise be provided.  If a ticket with the requested
   life cannot be provided, then the KDC may issue a renewable ticket
   with a renew-till equal to the the requested endtime.  The value of
   the renew-till field may still be adjusted by site-determined limits
   or limits imposed by the individual principal or server.

   The ENC-TKT-IN-SKEY option is honored only by the ticket-granting
   service.  It indicates that the to-be-issued ticket for the end
   server is to be encrypted in the session key from the additional
   ticket-granting ticket provided with the request.  See section 3.3.3
   for specific details.
ToP   noToC   RFC1510 - Page 16
3.  Message Exchanges

   The following sections describe the interactions between network
   clients and servers and the messages involved in those exchanges.

3.1.  The Authentication Service Exchange

                             Summary

         Message direction       Message type    Section
         1. Client to Kerberos   KRB_AS_REQ      5.4.1
         2. Kerberos to client   KRB_AS_REP or   5.4.2
                                 KRB_ERROR       5.9.1

   The Authentication Service (AS) Exchange between the client and the
   Kerberos Authentication Server is usually initiated by a client when
   it wishes to obtain authentication credentials for a given server but
   currently holds no credentials.  The client's secret key is used for
   encryption and decryption.  This exchange is typically used at the
   initiation of a login session, to obtain credentials for a Ticket-
   Granting Server, which will subsequently be used to obtain
   credentials for other servers (see section 3.3) without requiring
   further use of the client's secret key.  This exchange is also used
   to request credentials for services which must not be mediated
   through the Ticket-Granting Service, but rather require a principal's
   secret key, such as the password-changing service.  (The password-
   changing request must not be honored unless the requester can provide
   the old password (the user's current secret key).  Otherwise, it
   would be possible for someone to walk up to an unattended session and
   change another user's password.)  This exchange does not by itself
   provide any assurance of the the identity of the user.  (To
   authenticate a user logging on to a local system, the credentials
   obtained in the AS exchange may first be used in a TGS exchange to
   obtain credentials for a local server.  Those credentials must then
   be verified by the local server through successful completion of the
   Client/Server exchange.)

   The exchange consists of two messages: KRB_AS_REQ from the client to
   Kerberos, and KRB_AS_REP or KRB_ERROR in reply. The formats for these
   messages are described in sections 5.4.1, 5.4.2, and 5.9.1.

   In the request, the client sends (in cleartext) its own identity and
   the identity of the server for which it is requesting credentials.
   The response, KRB_AS_REP, contains a ticket for the client to present
   to the server, and a session key that will be shared by the client
   and the server.  The session key and additional information are
   encrypted in the client's secret key.  The KRB_AS_REP message
   contains information which can be used to detect replays, and to
ToP   noToC   RFC1510 - Page 17
   associate it with the message to which it replies.  Various errors
   can occur; these are indicated by an error response (KRB_ERROR)
   instead of the KRB_AS_REP response.  The error message is not
   encrypted.  The KRB_ERROR message also contains information which can
   be used to associate it with the message to which it replies.  The
   lack of encryption in the KRB_ERROR message precludes the ability to
   detect replays or fabrications of such messages.

   In the normal case the authentication server does not know whether
   the client is actually the principal named in the request.  It simply
   sends a reply without knowing or caring whether they are the same.
   This is acceptable because nobody but the principal whose identity
   was given in the request will be able to use the reply. Its critical
   information is encrypted in that principal's key.  The initial
   request supports an optional field that can be used to pass
   additional information that might be needed for the initial exchange.
   This field may be used for preauthentication if desired, but the
   mechanism is not currently specified.

3.1.1. Generation of KRB_AS_REQ message

   The client may specify a number of options in the initial request.
   Among these options are whether preauthentication is to be performed;
   whether the requested ticket is to be renewable, proxiable, or
   forwardable; whether it should be postdated or allow postdating of
   derivative tickets; and whether a renewable ticket will be accepted
   in lieu of a non-renewable ticket if the requested ticket expiration
   date cannot be satisfied by a nonrenewable ticket (due to
   configuration constraints; see section 4).  See section A.1 for
   pseudocode.

   The client prepares the KRB_AS_REQ message and sends it to the KDC.

3.1.2. Receipt of KRB_AS_REQ message

   If all goes well, processing the KRB_AS_REQ message will result in
   the creation of a ticket for the client to present to the server.
   The format for the ticket is described in section 5.3.1.  The
   contents of the ticket are determined as follows.

3.1.3. Generation of KRB_AS_REP message

   The authentication server looks up the client and server principals
   named in the KRB_AS_REQ in its database, extracting their respective
   keys.  If required, the server pre-authenticates the request, and if
   the pre-authentication check fails, an error message with the code
   KDC_ERR_PREAUTH_FAILED is returned. If the server cannot accommodate
   the requested encryption type, an error message with code
ToP   noToC   RFC1510 - Page 18
   KDC_ERR_ETYPE_NOSUPP is returned. Otherwise it generates a "random"
   session key ("Random" means that, among other things, it should be
   impossible to guess the next session key based on knowledge of past
   session keys.  This can only be achieved in a pseudo-random number
   generator if it is based on cryptographic principles.  It would be
   more desirable to use a truly random number generator, such as one
   based on measurements of random physical phenomena.).

   If the requested start time is absent or indicates a time in the
   past, then the start time of the ticket is set to the authentication
   server's current time. If it indicates a time in the future, but the
   POSTDATED option has not been specified, then the error
   KDC_ERR_CANNOT_POSTDATE is returned.  Otherwise the requested start
   time is checked against the policy of the local realm (the
   administrator might decide to prohibit certain types or ranges of
   postdated tickets), and if acceptable, the ticket's start time is set
   as requested and the INVALID flag is set in the new ticket. The
   postdated ticket must be validated before use by presenting it to the
   KDC after the start time has been reached.

   The expiration time of the ticket will be set to the minimum of the
   following:

   +The expiration time (endtime) requested in the KRB_AS_REQ
    message.

   +The ticket's start time plus the maximum allowable lifetime
    associated with the client principal (the authentication
    server's database includes a maximum ticket lifetime field
    in each principal's record; see section 4).

   +The ticket's start time plus the maximum allowable lifetime
    associated with the server principal.

   +The ticket's start time plus the maximum lifetime set by
    the policy of the local realm.

   If the requested expiration time minus the start time (as determined
   above) is less than a site-determined minimum lifetime, an error
   message with code KDC_ERR_NEVER_VALID is returned.  If the requested
   expiration time for the ticket exceeds what was determined as above,
   and if the "RENEWABLE-OK" option was requested, then the "RENEWABLE"
   flag is set in the new ticket, and the renew-till value is set as if
   the "RENEWABLE" option were requested (the field and option names are
   described fully in section 5.4.1).  If the RENEWABLE option has been
   requested or if the RENEWABLE-OK option has been set and a renewable
   ticket is to be issued, then the renew-till field is set to the
   minimum of:
ToP   noToC   RFC1510 - Page 19
   +Its requested value.

   +The start time of the ticket plus the minimum of the two
    maximum renewable lifetimes associated with the principals'
    database entries.

   +The start time of the ticket plus the maximum renewable
    lifetime set by the policy of the local realm.

   The flags field of the new ticket will have the following options set
   if they have been requested and if the policy of the local realm
   allows: FORWARDABLE, MAY-POSTDATE, POSTDATED, PROXIABLE, RENEWABLE.
   If the new ticket is postdated (the start time is in the future), its
   INVALID flag will also be set.

   If all of the above succeed, the server formats a KRB_AS_REP message
   (see section 5.4.2), copying the addresses in the request into the
   caddr of the response, placing any required pre-authentication data
   into the padata of the response, and encrypts the ciphertext part in
   the client's key using the requested encryption method, and sends it
   to the client.  See section A.2 for pseudocode.

3.1.4. Generation of KRB_ERROR message

   Several errors can occur, and the Authentication Server responds by
   returning an error message, KRB_ERROR, to the client, with the
   error-code and e-text fields set to appropriate values.  The error
   message contents and details are described in Section 5.9.1.

3.1.5. Receipt of KRB_AS_REP message

   If the reply message type is KRB_AS_REP, then the client verifies
   that the cname and crealm fields in the cleartext portion of the
   reply match what it requested.  If any padata fields are present,
   they may be used to derive the proper secret key to decrypt the
   message.  The client decrypts the encrypted part of the response
   using its secret key, verifies that the nonce in the encrypted part
   matches the nonce it supplied in its request (to detect replays).  It
   also verifies that the sname and srealm in the response match those
   in the request, and that the host address field is also correct.  It
   then stores the ticket, session key, start and expiration times, and
   other information for later use.  The key-expiration field from the
   encrypted part of the response may be checked to notify the user of
   impending key expiration (the client program could then suggest
   remedial action, such as a password change).  See section A.3 for
   pseudocode.

   Proper decryption of the KRB_AS_REP message is not sufficient to
ToP   noToC   RFC1510 - Page 20
   verify the identity of the user; the user and an attacker could
   cooperate to generate a KRB_AS_REP format message which decrypts
   properly but is not from the proper KDC.  If the host wishes to
   verify the identity of the user, it must require the user to present
   application credentials which can be verified using a securely-stored
   secret key.  If those credentials can be verified, then the identity
   of the user can be assured.

3.1.6. Receipt of KRB_ERROR message

   If the reply message type is KRB_ERROR, then the client interprets it
   as an error and performs whatever application-specific tasks are
   necessary to recover.



(page 20 continued on part 2)

Next Section