1 2 3 4Kerberos Working Group L. Zhu 5Internet-Draft Microsoft Corporation 6Updates: 4120 (if approved) S. Hartman 7Intended status: Standards Track MIT 8Expires: January 9, 2008 July 8, 2007 9 10 11 A Generalized Framework for Kerberos Pre-Authentication 12 draft-ietf-krb-wg-preauth-framework-06 13 14Status of this Memo 15 16 By submitting this Internet-Draft, each author represents that any 17 applicable patent or other IPR claims of which he or she is aware 18 have been or will be disclosed, and any of which he or she becomes 19 aware will be disclosed, in accordance with Section 6 of BCP 79. 20 21 Internet-Drafts are working documents of the Internet Engineering 22 Task Force (IETF), its areas, and its working groups. Note that 23 other groups may also distribute working documents as Internet- 24 Drafts. 25 26 Internet-Drafts are draft documents valid for a maximum of six months 27 and may be updated, replaced, or obsoleted by other documents at any 28 time. It is inappropriate to use Internet-Drafts as reference 29 material or to cite them other than as "work in progress." 30 31 The list of current Internet-Drafts can be accessed at 32 http://www.ietf.org/ietf/1id-abstracts.txt. 33 34 The list of Internet-Draft Shadow Directories can be accessed at 35 http://www.ietf.org/shadow.html. 36 37 This Internet-Draft will expire on January 9, 2008. 38 39Copyright Notice 40 41 Copyright (C) The IETF Trust (2007). 42 43Abstract 44 45 Kerberos is a protocol for verifying the identity of principals 46 (e.g., a workstation user or a network server) on an open network. 47 The Kerberos protocol provides a mechanism called pre-authentication 48 for proving the identity of a principal and for better protecting the 49 long-term secret of the principal. 50 51 This document describes a model for Kerberos pre-authentication 52 53 54 55Zhu & Hartman Expires January 9, 2008 [Page 1] 56 57Internet-Draft Kerberos Preauth Framework July 2007 58 59 60 mechanisms. The model describes what state in the Kerberos request a 61 pre-authentication mechanism is likely to change. It also describes 62 how multiple pre-authentication mechanisms used in the same request 63 will interact. 64 65 This document also provides common tools needed by multiple pre- 66 authentication mechanisms. One of these tools is a secure channel 67 between the client and the KDC with a reply key delivery mechanism; 68 this secure channel can be used to protect the authentication 69 exchange thus eliminate offline dictionary attacks. With these 70 tools, it is relatively straightforward to chain multiple 71 authentication mechanisms, utilize a different key management system, 72 or support a new key agreement algorithm. 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111Zhu & Hartman Expires January 9, 2008 [Page 2] 112 113Internet-Draft Kerberos Preauth Framework July 2007 114 115 116Table of Contents 117 118 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 4 119 2. Conventions and Terminology Used in This Document . . . . . . 5 120 3. Model for Pre-Authentication . . . . . . . . . . . . . . . . . 5 121 3.1. Information Managed by the Pre-authentication Model . . . 6 122 3.2. Initial Pre-authentication Required Error . . . . . . . . 8 123 3.3. Client to KDC . . . . . . . . . . . . . . . . . . . . . . 9 124 3.4. KDC to Client . . . . . . . . . . . . . . . . . . . . . . 10 125 4. Pre-Authentication Facilities . . . . . . . . . . . . . . . . 10 126 4.1. Client-authentication Facility . . . . . . . . . . . . . . 12 127 4.2. Strengthening-reply-key Facility . . . . . . . . . . . . . 12 128 4.3. Replacing-reply-key Facility . . . . . . . . . . . . . . . 13 129 4.4. KDC-authentication Facility . . . . . . . . . . . . . . . 14 130 5. Requirements for Pre-Authentication Mechanisms . . . . . . . . 14 131 6. Tools for Use in Pre-Authentication Mechanisms . . . . . . . . 15 132 6.1. Combining Keys . . . . . . . . . . . . . . . . . . . . . . 15 133 6.2. Protecting Requests/Responses . . . . . . . . . . . . . . 16 134 6.3. Managing States for the KDC . . . . . . . . . . . . . . . 17 135 6.4. Pre-authentication Set . . . . . . . . . . . . . . . . . . 19 136 6.5. Definition of Kerberos FAST Padata . . . . . . . . . . . . 21 137 6.5.1. FAST Armors . . . . . . . . . . . . . . . . . . . . . 22 138 6.5.2. FAST Request . . . . . . . . . . . . . . . . . . . . . 23 139 6.5.3. FAST Response . . . . . . . . . . . . . . . . . . . . 27 140 6.5.4. Authenticated Kerberos Error Messages using 141 Kerberos FAST . . . . . . . . . . . . . . . . . . . . 29 142 6.5.5. The Authenticated Timestamp FAST Factor . . . . . . . 30 143 6.6. Authentication Strength Indication . . . . . . . . . . . . 32 144 7. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 33 145 8. Security Considerations . . . . . . . . . . . . . . . . . . . 33 146 9. Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . 34 147 10. References . . . . . . . . . . . . . . . . . . . . . . . . . . 34 148 10.1. Normative References . . . . . . . . . . . . . . . . . . . 34 149 10.2. Informative References . . . . . . . . . . . . . . . . . . 34 150 Appendix A. ASN.1 module . . . . . . . . . . . . . . . . . . . . 35 151 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 38 152 Intellectual Property and Copyright Statements . . . . . . . . . . 39 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167Zhu & Hartman Expires January 9, 2008 [Page 3] 168 169Internet-Draft Kerberos Preauth Framework July 2007 170 171 1721. Introduction 173 174 The core Kerberos specification [RFC4120] treats pre-authentication 175 data as an opaque typed hole in the messages to the KDC that may 176 influence the reply key used to encrypt the KDC reply. This 177 generality has been useful: pre-authentication data is used for a 178 variety of extensions to the protocol, many outside the expectations 179 of the initial designers. However, this generality makes designing 180 more common types of pre-authentication mechanisms difficult. Each 181 mechanism needs to specify how it interacts with other mechanisms. 182 Also, problems like combining a key with the long-term secret or 183 proving the identity of the user are common to multiple mechanisms. 184 Where there are generally well-accepted solutions to these problems, 185 it is desirable to standardize one of these solutions so mechanisms 186 can avoid duplication of work. In other cases, a modular approach to 187 these problems is appropriate. The modular approach will allow new 188 and better solutions to common pre-authentication problems to be used 189 by existing mechanisms as they are developed. 190 191 This document specifies a framework for Kerberos pre-authentication 192 mechanisms. It defines the common set of functions that pre- 193 authentication mechanisms perform as well as how these functions 194 affect the state of the request and reply. In addition several 195 common tools needed by pre-authentication mechanisms are provided. 196 Unlike [RFC3961], this framework is not complete--it does not 197 describe all the inputs and outputs for the pre-authentication 198 mechanisms. Pre-Authentication mechanism designers should try to be 199 consistent with this framework because doing so will make their 200 mechanisms easier to implement. Kerberos implementations are likely 201 to have plugin architectures for pre-authentication; such 202 architectures are likely to support mechanisms that follow this 203 framework plus commonly used extensions. 204 205 One of these common tools is the flexible authentication secure 206 tunneling (FAST) padata type. FAST provides a protected channel 207 between the client and the KDC, and it can optionally deliver a reply 208 key within the protected channel. Based on FAST, pre-authentication 209 mechanisms can extend Kerberos with ease, to support, for example, 210 password authenticated key exchange (PAKE) protocols with zero 211 knowledge password proof (ZKPP) [EKE] [IEEE1363.2]. Any pre- 212 authentication mechanism can be encapsulated in the FAST messages as 213 defined in Section 6.5. A pre-authentication type carried within 214 FAST is called a FAST factor. Creating a FAST factor is the easiest 215 path to create a new pre-authentication mechanism. FAST factors are 216 significantly easier to analyze from a security standpoint than other 217 pre-authentication mechanisms. 218 219 Mechanism designers should design FAST factors, instead of new pre- 220 221 222 223Zhu & Hartman Expires January 9, 2008 [Page 4] 224 225Internet-Draft Kerberos Preauth Framework July 2007 226 227 228 authentication mechanisms outside of FAST. 229 230 2312. Conventions and Terminology Used in This Document 232 233 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 234 "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this 235 document are to be interpreted as described in [RFC2119]. 236 237 The word padata is used as a shorthand for pre-authentication data. 238 239 A conversation is the set of all authentication messages exchanged 240 between the client and the KDCs in order to authenticate the client 241 principal. A conversation as defined here consists of all messages 242 that are necessary to complete the authentication between the client 243 and the KDC. 244 245 Lastly, this document should be read only after reading the documents 246 describing the Kerberos cryptography framework [RFC3961] and the core 247 Kerberos protocol [RFC4120]. This document may freely use 248 terminology and notation from these documents without reference or 249 further explanation. 250 251 2523. Model for Pre-Authentication 253 254 When a Kerberos client wishes to obtain a ticket using the 255 authentication server, it sends an initial Authentication Service 256 (AS) request. If pre-authentication is required but not being used, 257 then the KDC will respond with a KDC_ERR_PREAUTH_REQUIRED error. 258 Alternatively, if the client knows what pre-authentication to use, it 259 MAY optimize away a round-trip and send an initial request with 260 padata included in the initial request. If the client includes the 261 padata computed using the wrong pre-authentication mechanism or 262 incorrect keys, the KDC MAY return KDC_ERR_PREAUTH_FAILED with no 263 indication of what padata should have been included. In that case, 264 the client MUST retry with no padata and examine the error data of 265 the KDC_ERR_PREAUTH_REQUIRED error. If the KDC includes pre- 266 authentication information in the accompanying error data of 267 KDC_ERR_PREAUTH_FAILED, the client SHOULD process the error data, and 268 then retry. 269 270 The conventional KDC maintains no state between two requests; 271 subsequent requests may even be processed by a different KDC. On the 272 other hand, the client treats a series of exchanges with KDCs as a 273 single conversation. Each exchange accumulates state and hopefully 274 brings the client closer to a successful authentication. 275 276 277 278 279Zhu & Hartman Expires January 9, 2008 [Page 5] 280 281Internet-Draft Kerberos Preauth Framework July 2007 282 283 284 These models for state management are in apparent conflict. For many 285 of the simpler pre-authentication scenarios, the client uses one 286 round trip to find out what mechanisms the KDC supports. Then the 287 next request contains sufficient pre-authentication for the KDC to be 288 able to return a successful reply. For these simple scenarios, the 289 client only sends one request with pre-authentication data and so the 290 conversation is trivial. For more complex conversations, the KDC 291 needs to provide the client with a cookie to include in future 292 requests to capture the current state of the authentication session. 293 Handling of multiple round-trip mechanisms is discussed in 294 Section 6.3. 295 296 This framework specifies the behavior of Kerberos pre-authentication 297 mechanisms used to identify users or to modify the reply key used to 298 encrypt the KDC reply. The PA-DATA typed hole may be used to carry 299 extensions to Kerberos that have nothing to do with proving the 300 identity of the user or establishing a reply key. Such extensions 301 are outside the scope of this framework. However mechanisms that do 302 accomplish these goals should follow this framework. 303 304 This framework specifies the minimum state that a Kerberos 305 implementation needs to maintain while handling a request in order to 306 process pre-authentication. It also specifies how Kerberos 307 implementations process the padata at each step of the AS request 308 process. 309 3103.1. Information Managed by the Pre-authentication Model 311 312 The following information is maintained by the client and KDC as each 313 request is being processed: 314 315 o The reply key used to encrypt the KDC reply 316 317 o How strongly the identity of the client has been authenticated 318 319 o Whether the reply key has been used in this conversation 320 321 o Whether the reply key has been replaced in this conversation 322 323 o Whether the contents of the KDC reply can be verified by the 324 client principal 325 326 327 Conceptually, the reply key is initially the long-term key of the 328 principal. However, principals can have multiple long-term keys 329 because of support for multiple encryption types, salts and 330 string2key parameters. As described in Section 5.2.7.5 of the 331 Kerberos protocol [RFC4120], the KDC sends PA-ETYPE-INFO2 to notify 332 333 334 335Zhu & Hartman Expires January 9, 2008 [Page 6] 336 337Internet-Draft Kerberos Preauth Framework July 2007 338 339 340 the client what types of keys are available. Thus in full 341 generality, the reply key in the pre-authentication model is actually 342 a set of keys. At the beginning of a request, it is initialized to 343 the set of long-term keys advertised in the PA-ETYPE-INFO2 element on 344 the KDC. If multiple reply keys are available, the client chooses 345 which one to use. Thus the client does not need to treat the reply 346 key as a set. At the beginning of a request, the client picks a 347 reply key to use. 348 349 KDC implementations MAY choose to offer only one key in the PA-ETYPE- 350 INFO2 element. Since the KDC already knows the client's list of 351 supported enctypes from the request, no interoperability problems are 352 created by choosing a single possible reply key. This way, the KDC 353 implementation avoids the complexity of treating the reply key as a 354 set. 355 356 When the padata in the request is verified by the KDC, then the 357 client is known to have that key, therefore the KDC SHOULD pick the 358 same key as the reply key. 359 360 At the beginning of handling a message on both the client and the 361 KDC, the client's identity is not authenticated. A mechanism may 362 indicate that it has successfully authenticated the client's 363 identity. This information is useful to keep track of on the client 364 in order to know what pre-authentication mechanisms should be used. 365 The KDC needs to keep track of whether the client is authenticated 366 because the primary purpose of pre-authentication is to authenticate 367 the client identity before issuing a ticket. The handling of 368 authentication strength using various authentication mechanisms is 369 discussed in Section 6.6. 370 371 Initially the reply key has not been used. A pre-authentication 372 mechanism that uses the reply key to encrypt or checksum some data in 373 the generation of new keys MUST indicate that the reply key is used. 374 This state is maintained by the client and the KDC to enforce the 375 security requirement stated in Section 4.3 that the reply key cannot 376 be replaced after it is used. 377 378 Initially the reply key has not been replaced. If a mechanism 379 implements the Replace Reply Key facility discussed in Section 4.3, 380 then the state MUST be updated to indicate that the reply key has 381 been replaced. Once the reply key has been replaced, knowledge of 382 the reply key is insufficient to authenticate the client. The reply 383 key is marked replaced in exactly the same situations as the KDC 384 reply is marked as not being verified to the client principal. 385 However, while mechanisms can verify the KDC reply to the client, 386 once the reply key is replaced, then the reply key remains replaced 387 for the remainder of the conversation. 388 389 390 391Zhu & Hartman Expires January 9, 2008 [Page 7] 392 393Internet-Draft Kerberos Preauth Framework July 2007 394 395 396 Without pre-authentication, the client knows that the KDC reply is 397 authentic and has not been modified because it is encrypted in a 398 long-term key of the client. Only the KDC and the client know that 399 key. So at the start of handling any message the KDC reply is 400 presumed to be verified using the client principal's long-term key. 401 Any pre-authentication mechanism that sets a new reply key not based 402 on the principal's long-term secret MUST either verify the KDC reply 403 some other way or indicate that the reply is not verified. If a 404 mechanism indicates that the reply is not verified then the client 405 implementation MUST return an error unless a subsequent mechanism 406 verifies the reply. The KDC needs to track this state so it can 407 avoid generating a reply that is not verified. 408 409 The typical Kerberos request does not provide a way for the client 410 machine to know that it is talking to the correct KDC. Someone who 411 can inject packets into the network between the client machine and 412 the KDC and who knows the password that the user will give to the 413 client machine can generate a KDC reply that will decrypt properly. 414 So, if the client machine needs to authenticate that the user is in 415 fact the named principal, then the client machine needs to do a TGS 416 request for itself as a service. Some pre-authentication mechanisms 417 may provide a way for the client to authenticate the KDC. Examples 418 of this include signing the reply that can be verified using a well- 419 known public key or providing a ticket for the client machine as a 420 service. 421 4223.2. Initial Pre-authentication Required Error 423 424 Typically a client starts a conversation by sending an initial 425 request with no pre-authentication. If the KDC requires pre- 426 authentication, then it returns a KDC_ERR_PREAUTH_REQUIRED message. 427 After the first reply with the KDC_ERR_PREAUTH_REQUIRED error code, 428 the KDC returns the error code KDC_ERR_MORE_PREAUTH_DATA_NEEDED 429 (defined in Section 6.3) for pre-authentication configurations that 430 use multi-round-trip mechanisms; see Section 3.4 for details of that 431 case. 432 433 The KDC needs to choose which mechanisms to offer the client. The 434 client needs to be able to choose what mechanisms to use from the 435 first message. For example consider the KDC that will accept 436 mechanism A followed by mechanism B or alternatively the single 437 mechanism C. A client that supports A and C needs to know that it 438 should not bother trying A. 439 440 Mechanisms can either be sufficient on their own or can be part of an 441 authentication set--a group of mechanisms that all need to 442 successfully complete in order to authenticate a client. Some 443 mechanisms may only be useful in authentication sets; others may be 444 445 446 447Zhu & Hartman Expires January 9, 2008 [Page 8] 448 449Internet-Draft Kerberos Preauth Framework July 2007 450 451 452 useful alone or in authentication sets. For the second group of 453 mechanisms, KDC policy dictates whether the mechanism will be part of 454 an authentication set or offered alone. For each mechanism that is 455 offered alone, the KDC includes the pre-authentication type ID of the 456 mechanism in the padata sequence returned in the 457 KDC_ERR_PREAUTH_REQUIRED error. 458 459 The KDC SHOULD NOT send data that is encrypted in the long-term 460 password-based key of the principal. Doing so has the same security 461 exposures as the Kerberos protocol without pre-authentication. There 462 are few situations where pre-authentication is desirable and where 463 the KDC needs to expose cipher text encrypted in a weak key before 464 the client has proven knowledge of that key. 465 4663.3. Client to KDC 467 468 This description assumes that a client has already received a 469 KDC_ERR_PREAUTH_REQUIRED from the KDC. If the client performs 470 optimistic pre-authentication then the client needs to optimistically 471 guess values for the information it would normally receive from that 472 error response. 473 474 The client starts by initializing the pre-authentication state as 475 specified. It then processes the padata in the 476 KDC_ERR_PREAUTH_REQUIRED. 477 478 When processing the response to the KDC_ERR_PREAUTH_REQUIRED, the 479 client MAY ignore any padata it chooses unless doing so violates a 480 specification to which the client conforms. Clients conforming to 481 this specification MUST NOT ignore the padata defined in Section 6.3. 482 Clients SHOULD process padata unrelated to this framework or other 483 means of authenticating the user. Clients SHOULD choose one 484 authentication set or mechanism that could lead to authenticating the 485 user and ignore the rest. Since the list of mechanisms offered by 486 the KDC is in the decreasing preference order, clients typically 487 choose the first mechanism or authentication set that the client can 488 usefully perform. If a client chooses to ignore a padata it MUST NOT 489 process the padata, allow the padata to affect the pre-authentication 490 state, nor respond to the padata. 491 492 For each padata the client chooses to process, the client processes 493 the padata and modifies the pre-authentication state as required by 494 that mechanism. Padata are processed in the order received from the 495 KDC. 496 497 After processing the padata in the KDC error, the client generates a 498 new request. It processes the pre-authentication mechanisms in the 499 order in which they will appear in the next request, updating the 500 501 502 503Zhu & Hartman Expires January 9, 2008 [Page 9] 504 505Internet-Draft Kerberos Preauth Framework July 2007 506 507 508 state as appropriate. The request is sent when it is complete. 509 5103.4. KDC to Client 511 512 When a KDC receives an AS request from a client, it needs to 513 determine whether it will respond with an error or an AS reply. 514 There are many causes for an error to be generated that have nothing 515 to do with pre-authentication; they are discussed in the core 516 Kerberos specification. 517 518 From the standpoint of evaluating the pre-authentication, the KDC 519 first starts by initializing the pre-authentication state. It then 520 processes the padata in the request. As mentioned in Section 3.3, 521 the KDC MAY ignore padata that is inappropriate for the configuration 522 and MUST ignore padata of an unknown type. 523 524 At this point the KDC decides whether it will issue a pre- 525 authentication required error or a reply. Typically a KDC will issue 526 a reply if the client's identity has been authenticated to a 527 sufficient degree. 528 529 In the case of a KDC_ERR_MORE_PREAUTH_DATA_NEEDED error, the KDC 530 first starts by initializing the pre-authentication state. Then it 531 processes any padata in the client's request in the order provided by 532 the client. Mechanisms that are not understood by the KDC are 533 ignored. Mechanisms that are inappropriate for the client principal 534 or the request SHOULD also be ignored. Next, it generates padata for 535 the error response, modifying the pre-authentication state 536 appropriately as each mechanism is processed. The KDC chooses the 537 order in which it will generate padata (and thus the order of padata 538 in the response), but it needs to modify the pre-authentication state 539 consistently with the choice of order. For example, if some 540 mechanism establishes an authenticated client identity, then the 541 subsequent mechanisms in the generated response receive this state as 542 input. After the padata is generated, the error response is sent. 543 Typically the errors with the code KDC_ERR_MORE_PREAUTH_DATA_NEEDED 544 in a converstation will include KDC state as discussed in 545 Section 6.3. 546 547 To generate a final reply, the KDC generates the padata modifying the 548 pre-authentication state as necessary. Then it generates the final 549 response, encrypting it in the current pre-authentication reply key. 550 551 5524. Pre-Authentication Facilities 553 554 Pre-Authentication mechanisms can be thought of as providing various 555 conceptual facilities. This serves two useful purposes. First, 556 557 558 559Zhu & Hartman Expires January 9, 2008 [Page 10] 560 561Internet-Draft Kerberos Preauth Framework July 2007 562 563 564 mechanism authors can choose only to solve one specific small 565 problem. It is often useful for a mechanism designed to offer key 566 management not to directly provide client authentication but instead 567 to allow one or more other mechanisms to handle this need. Secondly, 568 thinking about the abstract services that a mechanism provides yields 569 a minimum set of security requirements that all mechanisms providing 570 that facility must meet. These security requirements are not 571 complete; mechanisms will have additional security requirements based 572 on the specific protocol they employ. 573 574 A mechanism is not constrained to only offering one of these 575 facilities. While such mechanisms can be designed and are sometimes 576 useful, many pre-authentication mechanisms implement several 577 facilities. By combining multiple facilities in a single mechanism, 578 it is often easier to construct a secure, simple solution than by 579 solving the problem in full generality. Even when mechanisms provide 580 multiple facilities, they need to meet the security requirements for 581 all the facilities they provide. If the FAST factor approach is 582 used, it is likely that one or a small number of facilities can be 583 provided by a single mechanism without complicating the security 584 analysis. 585 586 According to Kerberos extensibility rules (Section 1.5 of the 587 Kerberos specification [RFC4120]), an extension MUST NOT change the 588 semantics of a message unless a recipient is known to understand that 589 extension. Because a client does not know that the KDC supports a 590 particular pre-authentication mechanism when it sends an initial 591 request, a pre-authentication mechanism MUST NOT change the semantics 592 of the request in a way that will break a KDC that does not 593 understand that mechanism. Similarly, KDCs MUST NOT send messages to 594 clients that affect the core semantics unless the client has 595 indicated support for the message. 596 597 The only state in this model that would break the interpretation of a 598 message is changing the expected reply key. If one mechanism changed 599 the reply key and a later mechanism used that reply key, then a KDC 600 that interpreted the second mechanism but not the first would fail to 601 interpret the request correctly. In order to avoid this problem, 602 extensions that change core semantics are typically divided into two 603 parts. The first part proposes a change to the core semantic--for 604 example proposes a new reply key. The second part acknowledges that 605 the extension is understood and that the change takes effect. 606 Section 4.2 discusses how to design mechanisms that modify the reply 607 key to be split into a proposal and acceptance without requiring 608 additional round trips to use the new reply key in subsequent pre- 609 authentication. Other changes in the state described in Section 3.1 610 can safely be ignored by a KDC that does not understand a mechanism. 611 Mechanisms that modify the behavior of the request outside the scope 612 613 614 615Zhu & Hartman Expires January 9, 2008 [Page 11] 616 617Internet-Draft Kerberos Preauth Framework July 2007 618 619 620 of this framework need to carefully consider the Kerberos 621 extensibility rules to avoid similar problems. 622 6234.1. Client-authentication Facility 624 625 The client authentication facility proves the identity of a user to 626 the KDC before a ticket is issued. Examples of mechanisms 627 implementing this facility include the encrypted timestamp facility 628 defined in Section 5.2.7.2 of the Kerberos specification [RFC4120]. 629 Mechanisms that provide this facility are expected to mark the client 630 as authenticated. 631 632 Mechanisms implementing this facility SHOULD require the client to 633 prove knowledge of the reply key before transmitting a successful KDC 634 reply. Otherwise, an attacker can intercept the pre-authentication 635 exchange and get a reply to attack. One way of proving the client 636 knows the reply key is to implement the Replace Reply Key facility 637 along with this facility. The PKINIT mechanism [RFC4556] implements 638 Client Authentication alongside Replace Reply Key. 639 640 If the reply key has been replaced, then mechanisms such as 641 encrypted-timestamp that rely on knowledge of the reply key to 642 authenticate the client MUST NOT be used. 643 6444.2. Strengthening-reply-key Facility 645 646 Particularly, when dealing with keys based on passwords, it is 647 desirable to increase the strength of the key by adding additional 648 secrets to it. Examples of sources of additional secrets include the 649 results of a Diffie-Hellman key exchange or key bits from the output 650 of a smart card [KRB-WG.SAM]. Typically these additional secrets can 651 be first combined with the existing reply key and then converted to a 652 protocol key using tools defined in Section 6.1. 653 654 If a mechanism implementing this facility wishes to modify the reply 655 key before knowing that the other party in the exchange supports the 656 mechanism, it proposes modifying the reply key. The other party then 657 includes a message indicating that the proposal is accepted if it is 658 understood and meets policy. In many cases it is desirable to use 659 the new reply key for client authentication and for other facilities. 660 Waiting for the other party to accept the proposal and actually 661 modify the reply key state would add an additional round trip to the 662 exchange. Instead, mechanism designers are encouraged to include a 663 typed hole for additional padata in the message that proposes the 664 reply key change. The padata included in the typed hole are 665 generated assuming the new reply key. If the other party accepts the 666 proposal, then these padata are considered as an inner level. As 667 with the outer level, one authentication set or mechanism is 668 669 670 671Zhu & Hartman Expires January 9, 2008 [Page 12] 672 673Internet-Draft Kerberos Preauth Framework July 2007 674 675 676 typically chosen for client authentication, along with auxiliary 677 mechanisms such as KDC cookies, and other mechanisms are ignored. 678 [[anchor5: Containers like this need more thought. For example if 679 you are constructing an authentication set do you expect to use a 680 strengthen reply key mechanism in conjunction with something else, do 681 you include the something else in the hint of the strengthen 682 mechanism or as its own entry. It's easier to configure and express 683 the authentication set as its own entry. However if you do that' the 684 composition of the mechanisms looks in practice than it appears in 685 the authentication set.]] The party generating the proposal can 686 determine whether the padata were processed based on whether the 687 proposal for the reply key is accepted. 688 689 The specific formats of the proposal message, including where padata 690 are included is a matter for the mechanism specification. Similarly, 691 the format of the message accepting the proposal is mechanism- 692 specific. 693 694 Mechanisms implementing this facility and including a typed hole for 695 additional padata MUST checksum that padata using a keyed checksum or 696 encrypt the padata. This requirement protects against modification 697 of the contents of the typed hole. By modifying these contents an 698 attacker might be able to choose which mechanism is used to 699 authenticate the client, or to convince a party to provide text 700 encrypted in a key that the attacker had manipulated. It is 701 important that mechanisms strengthen the reply key enough that using 702 it to checksum padata is appropriate. 703 7044.3. Replacing-reply-key Facility 705 706 The Replace Reply Key facility replaces the key in which a successful 707 AS reply will be encrypted. This facility can only be used in cases 708 where knowledge of the reply key is not used to authenticate the 709 client. The new reply key MUST be communicated to the client and the 710 KDC in a secure manner. Mechanisms implementing this facility MUST 711 mark the reply key as replaced in the pre-authentication state. 712 Mechanisms implementing this facility MUST either provide a mechanism 713 to verify the KDC reply to the client or mark the reply as unverified 714 in the pre-authentication state. Mechanisms implementing this 715 facility SHOULD NOT be used if a previous mechanism has used the 716 reply key. 717 718 As with the strengthening-reply-key facility, Kerberos extensibility 719 rules require that the reply key not be changed unless both sides of 720 the exchange understand the extension. In the case of this facility 721 it will likely be more common for both sides to know that the 722 facility is available by the time that the new key is available to be 723 used. However, mechanism designers can use a container for padata in 724 725 726 727Zhu & Hartman Expires January 9, 2008 [Page 13] 728 729Internet-Draft Kerberos Preauth Framework July 2007 730 731 732 a proposal message as discussed in Section 4.2 if appropriate. 733 7344.4. KDC-authentication Facility 735 736 This facility verifies that the reply comes from the expected KDC. 737 In traditional Kerberos, the KDC and the client share a key, so if 738 the KDC reply can be decrypted then the client knows that a trusted 739 KDC responded. Note that the client machine cannot trust the client 740 unless the machine is presented with a service ticket for it 741 (typically the machine can retrieve this ticket by itself). However, 742 if the reply key is replaced, some mechanism is required to verify 743 the KDC. Pre-authentication mechanisms providing this facility allow 744 a client to determine that the expected KDC has responded even after 745 the reply key is replaced. They mark the pre-authentication state as 746 having been verified. 747 748 7495. Requirements for Pre-Authentication Mechanisms 750 751 This section lists requirements for specifications of pre- 752 authentication mechanisms. 753 754 For each message in the pre-authentication mechanism, the 755 specification describes the pa-type value to be used and the contents 756 of the message. The processing of the message by the sender and 757 recipient is also specified. This specification needs to include all 758 modifications to the pre-authentication state. 759 760 Generally mechanisms have a message that can be sent in the error 761 data of the KDC_ERR_PREAUTH_REQUIRED error message or in an 762 authentication set. If the client needs information such as trusted 763 certificate authorities in order to determine if it can use the 764 mechanism, then this information should be in that message. In 765 addition, such mechanisms should also define a pa-hint to be included 766 in authentication sets. Often, the same information included in the 767 padata-value is appropriate to include in the pa-hint (as defined in 768 Section 6.4). 769 770 In order to ease security analysis the mechanism specification should 771 describe what facilities from this document are offered by the 772 mechanism. For each facility, the security consideration section of 773 the mechanism specification should show that the security 774 requirements of that facility are met. This requirement is 775 applicable to any FAST factor that provides authentication 776 information. 777 778 Significant problems have resulted in the specification of Kerberos 779 protocols because much of the KDC exchange is not protected against 780 781 782 783Zhu & Hartman Expires January 9, 2008 [Page 14] 784 785Internet-Draft Kerberos Preauth Framework July 2007 786 787 788 authentication. The security considerations section should discuss 789 unauthenticated plaintext attacks. It should either show that 790 plaintext is protected or discuss what harm an attacker could do by 791 modifying the plaintext. It is generally acceptable for an attacker 792 to be able to cause the protocol negotiation to fail by modifying 793 plaintext. More significant attacks should be evaluated carefully. 794 795 As discussed in Section 6.3, there is no guarantee that a client will 796 use the same KDCs for all messages in a conversation. The mechanism 797 specification needs to show why the mechanism is secure in this 798 situation. The hardest problem to deal with, especially for 799 challenge/response mechanisms is to make sure that the same response 800 cannot be replayed against two KDCs while allowing the client to talk 801 to any KDC. 802 803 8046. Tools for Use in Pre-Authentication Mechanisms 805 806 This section describes common tools needed by multiple pre- 807 authentication mechanisms. By using these tools mechanism designers 808 can use a modular approach to specify mechanism details and ease 809 security analysis. 810 8116.1. Combining Keys 812 813 Frequently a weak key needs to be combined with a stronger key before 814 use. For example, passwords are typically limited in size and 815 insufficiently random, therefore it is desirable to increase the 816 strength of the keys based on passwords by adding additional secrets. 817 Additional source of secrecy may come from hardware tokens. 818 819 This section provides standard ways to combine two keys into one. 820 821 KRB-FX-CF1() is defined to combine two pass-phrases. 822 823 KRB-FX-CF1(UTF-8 string, UTF-8 string) -> (UTF-8 string) 824 KRB-FX-CF1(x, y) -> x || y 825 826 Where || denotes concatenation. The strength of the final key is 827 roughly the total strength of the individual keys being combined 828 assuming that the string_to_key() function [RFC3961] uses all its 829 input evenly. 830 831 An example usage of KRB-FX-CF1() is when a device provides random but 832 short passwords, the password is often combined with a personal 833 identification number (PIN). The password and the PIN can be 834 combined using KRB-FX-CF1(). 835 836 837 838 839Zhu & Hartman Expires January 9, 2008 [Page 15] 840 841Internet-Draft Kerberos Preauth Framework July 2007 842 843 844 KRB-FX-CF2() combines two protocol keys based on the pseudo-random() 845 function defined in [RFC3961]. 846 847 Given two input keys, K1 and K2, where K1 and K2 can be of two 848 different enctypes, the output key of KRB-FX-CF2(), K3, is derived as 849 follows: 850 851 KRB-FX-CF2(protocol key, protocol key, octet string, 852 octet string) -> (protocol key) 853 854 PRF+(K1, pepper1) -> octet-string-1 855 PRF+(K2, pepper2) -> octet-string-2 856 KRB-FX-CF2(K1, K2, pepper1, pepper2) -> 857 random-to-key(octet-string-1 ^ octet-string-2) 858 859 Where ^ denotes the exclusive-OR operation. PRF+() is defined as 860 follows: 861 862 PRF+(protocol key, octet string) -> (octet string) 863 864 PRF+(key, shared-info) -> pseudo-random( key, 1 || shared-info ) || 865 pseudo-random( key, 2 || shared-info ) || 866 pseudo-random( key, 3 || shared-info ) || ... 867 868 Here the counter value 1, 2, 3 and so on are encoded as a one-octet 869 integer. The pseudo-random() operation is specified by the enctype 870 of the protocol key. PRF+() uses the counter to generate enough bits 871 as needed by the random-to-key() [RFC3961] function for the 872 encryption type specified for the resulting key; unneeded bits are 873 removed from the tail. 874 875 Mechanism designers MUST specify the values for the input parameter 876 pepper1 and pepper2 when combining two keys using KRB-FX-CF2(). The 877 pepper1 and pepper2 MUST be distinct so that if the two keys being 878 combined are the same, the resulting key is not a trivial key. 879 8806.2. Protecting Requests/Responses 881 882 Mechanism designers SHOULD protect clear text portions of pre- 883 authentication data. Various denial of service attacks and downgrade 884 attacks against Kerberos are possible unless plaintexts are somehow 885 protected against modification. An early design goal of Kerberos 886 Version 5 [RFC4120] was to avoid encrypting more of the 887 authentication exchange that was required. (Version 4 doubly- 888 encrypted the encrypted part of a ticket in a KDC reply, for 889 example.) This minimization of encryption reduces the load on the 890 KDC and busy servers. Also, during the initial design of Version 5, 891 the existence of legal restrictions on the export of cryptography 892 893 894 895Zhu & Hartman Expires January 9, 2008 [Page 16] 896 897Internet-Draft Kerberos Preauth Framework July 2007 898 899 900 made it desirable to minimize of the number of uses of encryption in 901 the protocol. Unfortunately, performing this minimization created 902 numerous instances of unauthenticated security-relevant plaintext 903 fields. 904 905 If there is more than one roundtrip for an authentication exchange, 906 mechanism designers need to allow either the client or the KDC to 907 provide a checksum of all the messages exchanged on the wire in the 908 conversation, and the checksum is then verified by the receiver. 909 910 New mechanisms MUST NOT be hard-wired to use a specific algorithm. 911 912 Primitives defined in [RFC3961] are RECOMMENDED for integrity 913 protection and confidentiality. Mechanisms based on these primitives 914 are crypto-agile as the result of using [RFC3961] along with 915 [RFC4120]. The advantage afforded by crypto-agility is the ability 916 to avoid a multi-year standardization and deployment cycle to fix a 917 problem that is specific to a particular algorithm, when real attacks 918 do arise against that algorithm. 919 920 Note that data used by FAST factors (defined in Section 6.5) is 921 encrypted in a protected channel, thus they do not share the un- 922 authenticated-text issues with mechanisms designed as full-blown pre- 923 authentication mechanisms. 924 9256.3. Managing States for the KDC 926 927 Kerberos KDCs are stateless. There is no requirement that clients 928 will choose the same KDC for the second request in a conversation. 929 Proxies or other intermediate nodes may also influence KDC selection. 930 So, each request from a client to a KDC must include sufficient 931 information that the KDC can regenerate any needed state. This is 932 accomplished by giving the client a potentially long opaque cookie in 933 responses to include in future requests in the same conversation. 934 The KDC MAY respond that a conversation is too old and needs to 935 restart by responding with a KDC_ERR_PREAUTH_EXPIRED error. 936 937 KDC_ERR_PREAUTH_EXPIRED TBA 938 939 When a client receives this error, the client SHOULD abort the 940 existing conversation, and restart a new one. 941 942 An example, where more than one message from the client is needed, is 943 when the client is authenticated based on a challenge-response 944 scheme. In that case, the KDC needs to keep track of the challenge 945 issued for a client authentication request. 946 947 The PA-FX-COOKIE pdata type is defined in this section to facilitate 948 949 950 951Zhu & Hartman Expires January 9, 2008 [Page 17] 952 953Internet-Draft Kerberos Preauth Framework July 2007 954 955 956 state management. This padata is sent by the KDC when the KDC 957 requires state for a future transaction. The client includes this 958 opaque token in the next message in the conversation. The token may 959 be relatively large; clients MUST be prepared for tokens somewhat 960 larger than the size of all messages in a conversation. 961 962 PA_FX_COOKIE TBA 963 -- Stateless cookie that is not tied to a specific KDC. 964 965 The corresponding padata-value field [RFC4120] contains the 966 Distinguished Encoding Rules (DER) [X60] [X690] encoding of the 967 following Abstract Syntax Notation One (ASN.1) type PA-FX-COOKIE: 968 969 PA-FX-COOKIE ::= SEQUENCE { 970 conversationId [0] OCTET STRING, 971 -- Contains the identifier of this conversation. This field 972 -- must contain the same value for all the messages 973 -- within the same conversation. 974 enc-binding-key [1] EncryptedData OPTIONAL, 975 -- EncryptionKey -- 976 -- This field is present when and only when a FAST 977 -- padata as defined in Section 6.5 is included. 978 -- The encrypted data, when decrypted, contains an 979 -- EncryptionKey structure. 980 -- This encryption key is encrypted using the armor key 981 -- (defined in Section 6.5.1), and the key usage for the 982 -- encryption is KEY_USAGE_FAST_BINDING_KEY. 983 -- Present only once in a converstation. 984 cookie [2] OCTET STRING OPTIONAL, 985 -- Opaque data, for use to associate all the messages in 986 -- a single conversation between the client and the KDC. 987 -- This is generated by the KDC and the client MUST copy 988 -- the exact cookie encapsulated in a PA_FX_COOKIE data 989 -- element into the next message of the same conversation. 990 ... 991 } 992 KEY_USAGE_FAST_BINDING_KEY TBA 993 994 The conversationId field contains a sufficiently-long rand number 995 that uniquely identifies the conversation. If a PA_FX_COOKIE padata 996 is present in one message, a PA_FX_COOKIE structure MUST be present 997 in all subsequent messages of the same converstation between the 998 client and the KDC, with the same conversationId value. 999 1000 The enc-binding-key field is present when and only when a FAST padata 1001 (defined in Section 6.5) is included. The enc-binding-key field is 1002 present only once in a conversation. It MUST be ignored if it is 1003 present in a subsequent message of the same conversation. The 1004 1005 1006 1007Zhu & Hartman Expires January 9, 2008 [Page 18] 1008 1009Internet-Draft Kerberos Preauth Framework July 2007 1010 1011 1012 encrypted data, when decrypted, contains an EncryptionKey structure 1013 that is called the binding key. The binding key is encrypted using 1014 the armor key (defined in Section 6.5.1), and the key usage for the 1015 encryption is KEY_USAGE_FAST_BINDING_KEY. 1016 1017 If a Kerberos FAST padata as defined in Section 6.5 is included in 1018 one message, it MUST be included in all subsequent messages of the 1019 same conversation. 1020 1021 When FAST padata as defined Section 6.5 is included, the PA-FX-COOKIE 1022 padata MUST be included. 1023 1024 The cookie token is generated by the KDC and the client MUST copy the 1025 exact cookie encapsulated in a PA_FX_COOKIE data element into the 1026 next message of the same conversation. The content of the cookie 1027 field is a local matter of the KDC. However the KDC MUST construct 1028 the cookie token in such a manner that a malicious client cannot 1029 subvert the authentication process by manipulating the token. The 1030 KDC implementation needs to consider expiration of tokens, key 1031 rollover and other security issues in token design. The content of 1032 the cookie field is likely specific to the pre-authentication 1033 mechanisms used to authenticate the client. If a client 1034 authentication response can be replayed to multiple KDCs via the 1035 PA_FX_COOKIE mechanism, an expiration in the cookie is RECOMMENDED to 1036 prevent the response being presented indefinitely. 1037 1038 If at least one more message for a mechanism or a mechanism set is 1039 expected by the KDC, the KDC returns a 1040 KDC_ERR_MORE_PREAUTH_DATA_NEEDED error with a PA_FX_COOKIE to 1041 identify the conversation with the client according to Section 6.5.4. 1042 1043 KDC_ERR_MORE_PREAUTH_DATA_NEEDED TBA 1044 10456.4. Pre-authentication Set 1046 1047 If all mechanisms in a group need to successfully complete in order 1048 to authenticate a client, the client and the KDC SHOULD use the 1049 PA_AUTHENTICATION_SET padata element. 1050 1051 A PA_AUTHENTICATION_SET padata element contains the ASN.1 DER 1052 encoding of the PA-AUTHENTICATION-SET structure: 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063Zhu & Hartman Expires January 9, 2008 [Page 19] 1064 1065Internet-Draft Kerberos Preauth Framework July 2007 1066 1067 1068 PA-AUTHENTICATION-SET ::= SEQUENCE OF PA-AUTHENTICATION-SET-ELEM 1069 1070 PA-AUTHENTICATION-SET-ELEM ::= SEQUENCE { 1071 pa-type [0] Int32, 1072 -- same as padata-type. 1073 pa-hint [1] OCTET STRING, 1074 -- hint data. 1075 ... 1076 } 1077 1078 The pa-type field of the PA-AUTHENTICATION-SET-ELEM structure 1079 contains the corresponding value of padata-type in PA-DATA [RFC4120]. 1080 Associated with the pa-type is a pa-hint, which is an octet-string 1081 specified by the pre-authentication mechanism. This hint may provide 1082 information for the client which helps it determine whether the 1083 mechanism can be used. For example a public-key mechanism might 1084 include the certificate authorities it trusts in the hint info. Most 1085 mechanisms today do not specify hint info; if a mechanism does not 1086 specify hint info the KDC MUST NOT send a hint for that mechanism. 1087 To allow future revisions of mechanism specifications to add hint 1088 info, clients MUST ignore hint info received for mechanisms that the 1089 client believes do not support hint info. If a member of the pre- 1090 authentication mechanism set that requires a challenge, a separate 1091 padata that carries the challenge SHOULD be included along with the 1092 pre-authentication set padata. 1093 1094 The PA-AUTHENTICATION-SET appears only in the first message from the 1095 KDC to the client. In particular, the client should not be prepared 1096 for the future authentication mechanisms to change as the 1097 conversation progresses. [[anchor9: I think this is correct; we 1098 should discuss and if the WG agrees the text should reflect this.]] 1099 1100 When indicating which sets of pre-authentication mechanisms are 1101 supported, the KDC includes a PA-AUTHENTICATION-SET padata element 1102 for each pre-authentication mechanism set. 1103 1104 The client sends the padata-value for the first mechanism it picks in 1105 the pre-authentication set, when the first mechanism completes, the 1106 client and the KDC will proceed with the second mechanism, and so on 1107 until all mechanisms complete successfully. The PA_FX_COOKIE as 1108 defined in Section 6.3 MUST be sent by the KDC along with the first 1109 message that contains a PA-AUTHENTICATION-SET, in order to keep track 1110 of KDC states. 1111 1112 Before the authentication succeeds and a ticket is returned, the 1113 message that the client sends is an AS_REQ and the message that the 1114 KDC sends is a KRB-ERROR message. The error code in the KRB-ERROR 1115 message from the KDC is KDC_ERR_MORE_PREAUTH_DATA_NEEDED as defined 1116 1117 1118 1119Zhu & Hartman Expires January 9, 2008 [Page 20] 1120 1121Internet-Draft Kerberos Preauth Framework July 2007 1122 1123 1124 in Section 6.3 and the accompanying e-data contains the DER encoding 1125 of ASN.1 type METHOD-DATA. The KDC includes the padata elements in 1126 the METHOD-DATA. If there is no padata, the e-data field is absent 1127 in the KRB-ERROR message. 1128 1129 If one mechanism completes on the client side, and the client expects 1130 the KDC to send the next padata for the next pre-authentication 1131 mechanism before the authentication succeeds, the client sends an 1132 AS_REQ with a padata of type PA_FX_HEARTBEAT. 1133 1134 PA_FX_HEARTBEAT TBA 1135 1136 The padata-value for the PA_FX_HEARTBEAT is empty. 1137 1138 If one mechanism completes on the KDC side, and the KDC expects the 1139 client to send the next padata for the next pre-authentication 1140 mechanism before the authentication succeeds, the KDC sends a KRB- 1141 ERROR message with the code KDC_ERR_MORE_PREAUTH_DATA_NEEDED and 1142 includes a padata of type PA_FX_HEARTBEAT. 1143 1144 [[anchor10: It's much easier to design UIs if you can determine ahead 1145 of time what all the elements of your dialogue will need to be. If 1146 we mandate that the pa-hints need to be sufficient that you can 1147 determine what information you will require from a user ahead of time 1148 we can simplify the UI for login. I propose that we make this 1149 requirement. WG agreement required.]] 1150 11516.5. Definition of Kerberos FAST Padata 1152 1153 As described in [RFC4120], Kerberos is vulnerable to offline 1154 dictionary attacks. An attacker can request an AS-REP and try 1155 various passwords to see if they can decrypt the resulting ticket. 1156 RFC 4120 provides the entrypted timestap pre-authentication method 1157 that ameliorates the situation somewhat by requiring that an attacker 1158 observe a successful authentication. However stronger security is 1159 desired in many environments. The Kerberos FAST pre-authentication 1160 padata defined in this section provides a tool to significantly 1161 reduce vulnerability to offline dictionary attack. When combined 1162 with encrypted timestamp, FAST requires an attacker to mount a 1163 successful man-in-the-middle attack to observe ciphertext. When 1164 combined with host keys, FAST can even protect against active 1165 attacks. FAST also provides solutions to common problems for pre- 1166 authentication mechanisms such as binding of the request and the 1167 reply, freshness guarantee of the authentication. FAST itself, 1168 however, does not authenticate the client or the KDC, instead, it 1169 provides a typed hole to allow pre-authentication data be tunneled. 1170 A pre-authentication data element used within FAST is called a FAST 1171 factor. A FAST factor captures the minimal work required for 1172 1173 1174 1175Zhu & Hartman Expires January 9, 2008 [Page 21] 1176 1177Internet-Draft Kerberos Preauth Framework July 2007 1178 1179 1180 extending Kerberos to support a new pre-authentication scheme. 1181 1182 A FAST factor MUST NOT be used outside of FAST unless its 1183 specification explicitly allows so. The typed holes in FAST messages 1184 can also be used as generic holes for other padata that are not 1185 intended to prove the client's identity, or establish the reply key. 1186 1187 New pre-authentication mechanisms SHOULD be designed as FAST factors, 1188 instead of full-blown pre-authentication mechanisms. 1189 1190 FAST factors that are pre-authentication mechanisms MUST meet the 1191 requirements in Section 5. 1192 1193 FAST employs an armoring scheme. The armor can be a Ticket Granting 1194 Ticket (TGT) obtained by the client's machine using the host keys to 1195 pre-authenticate with the KDC, or an anonymous TGT obtained based on 1196 anonymous PKINIT [KRB-ANON] [RFC4556]. 1197 1198 The rest of this section describes the types of armors and the syntax 1199 of the messages used by FAST. Conforming implementations MUST 1200 support Kerberos FAST padata. 1201 12026.5.1. FAST Armors 1203 1204 An armor key is used to encrypt pre-authentication data in the FAST 1205 request and the response. The KrbFastArmor structure is defined to 1206 identify the armor key. This structure contains the following two 1207 fields: the armor-type identifies the type of armors, and the armor- 1208 value as an OCTET STRING contains the description of the armor scheme 1209 and the armor key. 1210 1211 KrbFastArmor ::= SEQUENCE { 1212 armor-type [0] Int32, 1213 -- Type of the armor. 1214 armor-value [1] OCTET STRING, 1215 -- Value of the armor. 1216 ... 1217 } 1218 1219 The value of the armor key is a matter of the armor type 1220 specification. Only one armor type is defined in this document. 1221 1222 FX_FAST_ARMOR_AP_REQUEST TBA 1223 1224 The FX_FAST_ARMOR_AP_REQUEST armor is based on Kerberos tickets. 1225 1226 Conforming implementations MUST implement the 1227 FX_FAST_ARMOR_AP_REQUEST armor type. 1228 1229 1230 1231Zhu & Hartman Expires January 9, 2008 [Page 22] 1232 1233Internet-Draft Kerberos Preauth Framework July 2007 1234 1235 12366.5.1.1. Ticket-based Armors 1237 1238 This is a ticket-based armoring scheme. The armor-type is 1239 FX_FAST_ARMOR_AP_REQUEST, the armor-value contains an ASN.1 DER 1240 encoded AP-REQ. The ticket in the AP-REQ is called an armor ticket 1241 or an armor TGT. The subkey field in the AP-REQ MUST be present. 1242 The armor key is the subkey in the AP-REQ authenticator. 1243 1244 The server name field of the armor ticket MUST identify the TGS of 1245 the target realm. Here are three ways in the decreasing preference 1246 order how an armor TGT SHOULD be obtained: 1247 1248 1. If the client is authenticating from a host machine whose 1249 Kerberos realm has a trust path to the client's realm, the host 1250 machine obtains a TGT by pre-authenticating intitialy the realm 1251 of the host machine using the host keys. If the client's realm 1252 is different than the realm of the local host, the machine then 1253 obtains a cross-realm TGT to the client's realm as the armor 1254 ticket. Otherwise, the host's primary TGT is the armor ticket. 1255 1256 2. If the client's host machine cannot obtain a host ticket strictly 1257 based on RFC4120, but the KDC has an asymmetric signing key that 1258 the client can verify the binding between the public key of the 1259 signing key and the expected KDC, the client can use anonymous 1260 PKINIT [KRB-ANON] [RFC4556] to authenticate the KDC and obtain an 1261 anonymous TGT as the armor ticket. The armor key can be a cross- 1262 team TGT obtained based on the initial primary TGT obtained using 1263 anonymous PKINIT with KDC authentication. 1264 1265 3. Otherwise, the client uses anonymous PKINIT to get an anonymous 1266 TGT without KDC authentication and that TGT is the armor ticket. 1267 Note that this mode of operation is vulnerable to man-in-the- 1268 middle attacks at the time of obtaining the initial anonymous 1269 armor TGT. The armor key can be a cross-team TGT obtained based 1270 on the initial primary TGT obtained using anonymous PKINIT 1271 without KDC authentication. 1272 1273 Because the KDC does not know if the client is able to trust the 1274 ticket it has, the KDC MUST initialize the pre-authentication state 1275 to an unverified KDC. 1276 12776.5.2. FAST Request 1278 1279 A padata type PA_FX_FAST is defined for the Kerberos FAST pre- 1280 authentication padata. The corresponding padata-value field 1281 [RFC4120] contains the DER encoding of the ASN.1 type PA-FX-FAST- 1282 REQUEST. 1283 1284 1285 1286 1287Zhu & Hartman Expires January 9, 2008 [Page 23] 1288 1289Internet-Draft Kerberos Preauth Framework July 2007 1290 1291 1292 PA_FX_FAST TBA 1293 -- Padata type for Kerberos FAST 1294 1295 PA-FX-FAST-REQUEST ::= CHOICE { 1296 armored-data [0] KrbFastArmoredReq, 1297 ... 1298 } 1299 1300 KrbFastArmoredReq ::= SEQUENCE { 1301 armor [0] KrbFastArmor OPTIONAL, 1302 -- Contains the armor that identifies the armor key. 1303 -- MUST be present in AS-REQ. 1304 -- MUST be absent in TGS-REQ. 1305 req-checksum [1] Checksum, 1306 -- Checksum performed over the type KDC-REQ-BODY for 1307 -- the req-body field of the KDC-REQ structure defined in 1308 -- [RFC4120] 1309 -- The checksum key is the armor key, the checksum 1310 -- type is the required checksum type for the enctype of 1311 -- the armor key, and the key usage number is 1312 -- KEY_USAGE_FAST_REA_CHKSUM. 1313 enc-fast-req [2] EncryptedData, -- KrbFastReq -- 1314 -- The encryption key is the armor key, and the key usage 1315 -- number is KEY_USAGE_FAST_ENC. 1316 ... 1317 } 1318 1319 KEY_USAGE_FAST_REA_CHKSUM TBA 1320 KEY_USAGE_FAST_ENC TBA 1321 1322 The PA-FX-FAST-REQUEST structure contains a KrbFastArmoredReq type. 1323 The KrbFastArmoredReq encapsulates the encrypted padata. 1324 1325 The enc-fast-req field contains an encrypted KrbFastReq structure. 1326 The armor key is used to encrypt the KrbFastReq structure, and the 1327 key usage number for that encryption is KEY_USAGE_FAST_ARMOR. 1328 1329 KEY_USAGE_FAST_ARMOR TBA 1330 1331 The armor key is selected as follows: 1332 1333 o In an AS request, the armor field in the KrbFastArmoredReq 1334 structure MUST be present and the armor key is identified 1335 according to the specification of the armor type. 1336 1337 o In a TGS request, the armor field in the KrbFastArmoredReq 1338 structure MUST NOT be present and the subkey in the AP-REQ 1339 authenticator in the PA-TGS-REQ PA-DATA MUST be present. In this 1340 1341 1342 1343Zhu & Hartman Expires January 9, 2008 [Page 24] 1344 1345Internet-Draft Kerberos Preauth Framework July 2007 1346 1347 1348 case, the armor key is that subkey in the AP-REQ authenticator. 1349 1350 The req-checksum field contains a checksum that is performed over the 1351 type KDC-REQ-BODY for the req-body field of the KDC-REQ [RFC4120] 1352 structure of the containing message. The checksum key is the armor 1353 key, and the checksum type is the required checksum type for the 1354 enctype of the armor key per [RFC3961]. [[anchor12: Is this checksum 1355 still needed if we include a full kdc-req-body]] 1356 1357 The KrbFastReq structure contains the following information: 1358 1359 KrbFastReq ::= SEQUENCE { 1360 fast-options [0] FastOptions, 1361 -- Additional options. 1362 padata [1] SEQUENCE OF PA-DATA, 1363 -- padata typed holes. 1364 req-body [2] KDC-REQ-BODY, 1365 -- Contains the KDC request body as defined in Section 1366 -- 5.4.1 of [RFC4120]. The req-body field in the KDC-REQ 1367 -- structure [RFC4120] MUST be ignored. 1368 -- The client name and realm in the KDC-REQ [RFC4120] 1369 -- MUST NOT be present for AS-REQ and TGS-REQ when 1370 -- Kerberos FAST padata is included in the request. 1371 ... 1372 } 1373 1374 [[anchor13: See mailing list discussion about whether client name 1375 absent is correct.]] 1376 1377 The fast-options field indicates various options that are to modify 1378 the behavior of the KDC. The following options are defined: 1379 1380 FastOptions ::= KerberosFlags 1381 -- reserved(0), 1382 -- anonymous(1), 1383 -- kdc-referrals(16) 1384 1385 1386 Bits Name Description 1387 ----------------------------------------------------------------- 1388 0 RESERVED Reserved for future expansion of this field. 1389 1 anonymous Requesting the KDC to hide client names in 1390 the KDC response, as described next in this 1391 section. 1392 16 kdc-referrals Requesting the KDC to follow referrals, as 1393 described next in this section. 1394 1395 Bits 1 through 15 (with bit 2 and bit 15 included) are critical 1396 1397 1398 1399Zhu & Hartman Expires January 9, 2008 [Page 25] 1400 1401Internet-Draft Kerberos Preauth Framework July 2007 1402 1403 1404 options. If the KDC does not support a critical option, it MUST fail 1405 the request with KDC_ERR_UNKNOWN_CRITICAL_FAST_OPTIONS (there is no 1406 accompanying e-data defined in this document for this error code). 1407 Bit 16 and onward (with bit 16 included) are non-critical options. 1408 KDCs conforming to this specification ignores unknown non-critical 1409 options. 1410 1411 KDC_ERR_UNKNOWN_FAST_OPTIONS TBA 1412 1413 The anonymous Option 1414 1415 The Kerberos response defined in [RFC4120] contains the client 1416 identity in clear text, This makes traffic analysis 1417 straightforward. The anonymous option is designed to complicate 1418 traffic analysis. If the anonymous option is set, the KDC 1419 implementing PA_FX_FAST MUST identify the client as the anonymous 1420 principal in the KDC reply and the error response. Hence this 1421 option is set by the client if it wishes to conceal the client 1422 identity in the KDC response. 1423 1424 The kdc-referrals Option 1425 1426 The Kerberos client described in [RFC4120] has to request referral 1427 TGTs along the authentication path in order to get a service 1428 ticket for the target service. The Kerberos client described in 1429 the [REFERRALS] need to contact the AS specified in the error 1430 response in order to complete client referrals. The kdc-referrals 1431 option is designed to minimize the number of messages that need to 1432 be processed by the client. This option is useful when, for 1433 example, the client may contact the KDC via a satellite link that 1434 has high network latency, or the client has limited computational 1435 capabilities. If the kdc-referrals option is set, the KDC that 1436 honors this option acts as the client to follow AS referrals and 1437 TGS referrals [REFERRALS], and return the service ticket to the 1438 named server principal in the client request using the reply key 1439 expected by the client. The kdc-referrals option can be 1440 implemented when the KDC knows the reply key. The KDC can ignore 1441 kdc-referrals option when it does not understand it or it does not 1442 allow this option based on local policy. The client SHOULD be 1443 able to process the KDC responses when this option is not honored 1444 by the KDC. 1445 1446 The padata field contains a list of PA-DATA structures as described 1447 in Section 5.2.7 of [RFC4120]. These PA-DATA structures can contain 1448 FAST factors. They can also be used as generic typed-holes to 1449 contain data not intended for proving the client's identity or 1450 establishing a reply key, but for protocol extensibility. 1451 1452 1453 1454 1455Zhu & Hartman Expires January 9, 2008 [Page 26] 1456 1457Internet-Draft Kerberos Preauth Framework July 2007 1458 1459 1460 The KDC-REQ-BODY in the FAST structure is used in preference to the 1461 KDC-REQ-BODY outside of the FAST pre-authentication. This outer 1462 structure SHOULD be filled in for backwards compatibility with KDCs 1463 that do not support FAST. The client MAY fill in the cname and 1464 crealm fields in the kdc-req-body in the KrbFastReq structure and 1465 leave the cname field and the crealm field in KDC-REQ absent, in 1466 order to conceal the client's identity in the AS-REQ.[[anchor14: 1467 Absent is probably wrong. Presumably we want a name similar to the 1468 anonymous principal name.]] 1469 14706.5.3. FAST Response 1471 1472 The KDC that supports the PA_FX_FAST padata MUST include a PA_FX_FAST 1473 padata element in the KDC reply. In the case of an error, the 1474 PA_FX_FAST padata is included in the KDC responses according to 1475 Section 6.5.4. 1476 1477 The corresponding padata-value field [RFC4120] for the PA_FX_FAST in 1478 the KDC response contains the DER encoding of the ASN.1 type PA-FX- 1479 FAST-REPLY. 1480 1481 PA-FX-FAST-REPLY ::= CHOICE { 1482 armored-data [0] KrbFastArmoredRep, 1483 ... 1484 } 1485 1486 KrbFastArmoredRep ::= SEQUENCE { 1487 enc-fast-rep [0] EncryptedData, -- KrbFastResponse -- 1488 -- The encryption key is the armor key in the request, and 1489 -- the key usage number is KEY_USAGE_FAST_REP. 1490 ... 1491 } 1492 KEY_USAGE_FAST_REP TBA 1493 1494 The PA-FX-FAST-REPLY structure contains a KrbFastArmoredRep 1495 structure. The KrbFastArmoredRep structure encapsulates the padata 1496 in the KDC reply in the encrypted form. The KrbFastResponse is 1497 encrypted with the armor key used in the corresponding request, and 1498 the key usage number is KEY_USAGE_FAST_REP. 1499 1500 The Kerberos client who does not receive a PA-FX-FAST-REPLY in the 1501 KDC response MUST support a local policy that rejects the response. 1502 Clients MAY also support policies that fall back to other mechanisms 1503 or that do not use pre-authentication when FAST is unavailable. It 1504 is important to consider the potential downgrade attacks when 1505 deploying such a policy. 1506 1507 The KrbFastResponse structure contains the following information: 1508 1509 1510 1511Zhu & Hartman Expires January 9, 2008 [Page 27] 1512 1513Internet-Draft Kerberos Preauth Framework July 2007 1514 1515 1516 KrbFastResponse ::= SEQUENCE { 1517 padata [0] SEQUENCE OF PA-DATA, 1518 -- padata typed holes. 1519 rep-key [1] EncryptionKey OPTIONAL, 1520 -- This, if present, replaces the reply key for AS and TGS. 1521 -- MUST be absent in KRB-ERROR. 1522 finished [2] KrbFastFinished OPTIONAL, 1523 -- MUST be present if the client is authenticated, 1524 -- absent otherwise. 1525 -- Typically this is present if and only if the containing 1526 -- message is the last one in a conversation. 1527 ... 1528 } 1529 1530 The padata field in the KrbFastResponse structure contains a list of 1531 PA-DATA structures as described in Section 5.2.7 of [RFC4120]. These 1532 PA-DATA structures are used to carry data advancing the exchange 1533 specific for the FAST factors. They can also be used as generic 1534 typed-holes for protocol extensibility. 1535 1536 The rep-key field, if present, contains the reply key that is used to 1537 encrypted the KDC reply. The rep-key field MUST be absent in the 1538 case where an error occurs. The enctype of the rep-key is the 1539 strongest mutually supported by the KDC and the client. 1540 1541 The finished field contains a KrbFastFinished structure. It is 1542 filled by the KDC in the final message in the conversation; it MUST 1543 be absent otherwise. In other words, this field can only be present 1544 in an AS-REP or a TGS-REP when a ticket is returned. 1545 1546 The KrbFastFinished structure contains the following information: 1547 1548 KrbFastFinished ::= SEQUENCE { 1549 timestamp [0] KerberosTime, 1550 usec [1] Microseconds, 1551 -- timestamp and usec represent the time on the KDC when 1552 -- the reply was generated. 1553 crealm [2] Realm, 1554 cname [3] PrincipalName, 1555 -- Contains the client realm and the client name. 1556 checksum [4] Checksum, 1557 -- Checksum performed over all the messages in the 1558 -- conversation, except the containing message. 1559 -- The checksum key is the binding key as defined in 1560 -- Section 6.3, and the checksum type is the required 1561 -- checksum type of the binding key. 1562 ... 1563 } 1564 1565 1566 1567Zhu & Hartman Expires January 9, 2008 [Page 28] 1568 1569Internet-Draft Kerberos Preauth Framework July 2007 1570 1571 1572 KEY_USAGE_FAST_FINISHED TBA 1573 1574 The timestamp and usec fields represent the time on the KDC when the 1575 reply ticket was generated, these fields have the same semantics as 1576 the corresponding-identically-named fields in Section 5.6.1 of 1577 [RFC4120]. The client MUST use the KDC's time in these fields 1578 thereafter when using the returned ticket. Note that the KDC's time 1579 in AS-REP may not match the authtime in the reply ticket if the kdc- 1580 referrals option is requested and honored by the KDC. 1581 1582 The cname and crealm fields identify the authenticated client. 1583 1584 The checksum field contains a checksum of all the messages in the 1585 conversation prior to the containing message (the containing message 1586 is excluded). The checksum key is the binding key as defined in 1587 Section 6.3, and the checksum type is the required checksum type of 1588 the enctype of that key, and the key usage number is 1589 KEY_USAGE_FAST_FINISHED. [[anchor15: Examples would be good here; 1590 what all goes into the checksum?]] 1591 1592 When FAST padata is included, the PA-FX-COOKIE padata as defined in 1593 Section 6.3 MUST also be included if the KDC expects at least one 1594 more message from the client in order to complete the authentication. 1595 15966.5.4. Authenticated Kerberos Error Messages using Kerberos FAST 1597 1598 If the Kerberos FAST padata was included in the request, unless 1599 otherwise specified, the e-data field of the KRB-ERROR message 1600 [RFC4120] contains the ASN.1 DER encoding of the type METHOD-DATA 1601 [RFC4120] and a PA_FX_FAST is included in the METHOD-DATA. The KDC 1602 MUST include all the padata elements such as PA-ETYPE-INFO2 and 1603 padata elments that indicate acceptable pre-authentication mechanisms 1604 [RFC4120] and in the KrbFastResponse structure. 1605 1606 If the Kerberos FAST padata is included in the request but not 1607 included in the error reply, it is a matter of the local policy on 1608 the client to accept the information in the error message without 1609 integrity protection. The Kerberos client MAY process an error 1610 message without a PA-FX-FAST-REPLY, if that is only intended to 1611 return better error information to the application, typically for 1612 trouble-shooting purposes. 1613 1614 In the cases where the e-data field of the KRB-ERROR message is 1615 expected to carry a TYPED-DATA [RFC4120] element, the 1616 PA_FX_TYPED_DATA padata is included in the KrbFastResponse structure 1617 to encapsulate the TYPED-DATA [RFC4120] elements. For example, the 1618 TD_TRUSTED_CERTIFIERS structure is expected to be in the KRB-ERROR 1619 message when the error code is KDC_ERR_CANT_VERIFY_CERTIFICATE 1620 1621 1622 1623Zhu & Hartman Expires January 9, 2008 [Page 29] 1624 1625Internet-Draft Kerberos Preauth Framework July 2007 1626 1627 1628 [RFC4556]. 1629 1630 PA_FX_TYPED_DATA TBA 1631 -- This is the padata element that encapsulates a TYPED-DATA 1632 -- structure. 1633 1634 The corresponding padata-value for the PA_FX_TYPED_DATA padata type 1635 contains the DER encoding of the ASN.1 type TYPED-DATA [RFC4120]. 1636 16376.5.5. The Authenticated Timestamp FAST Factor 1638 1639 The encrypted time stamp [RFC4120] padata can be used as a FAST 1640 factor to authenticate the client and it does not expose the cipher 1641 text derived using the client's long term keys. However this FAST 1642 factor is not risk-free from current intellectual property claims as 1643 of the time of this writing. To provide a clearn replacement FAST 1644 factor that closely matches the encrypted timestamp FAST factor, the 1645 authenticated timestamp pre-authentication is introduced in this 1646 section. 1647 1648 The authenticated timestamp FAST factor authenticates a client by 1649 means of computing a checksum over a time-stamped structure using the 1650 client's long term keys. The padata-type is 1651 PA_AUTHENTICATED_TIMESTAMP and the corresponding padata-value 1652 contains the DER encoding of ASN.1 type AuthenticatedTimestamp. 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679Zhu & Hartman Expires January 9, 2008 [Page 30] 1680 1681Internet-Draft Kerberos Preauth Framework July 2007 1682 1683 1684 AuthenticatedTimestampToBeSigned ::= SEQUENCE { 1685 timestamp [0] PA-ENC-TS-ENC, 1686 -- Contains the timestamp field of the corresponding 1687 -- AuthenticatedTimestamp structure. 1688 req-body [1] KDC-REQ-BODY OPTIONAL, 1689 -- MUST contain the req-body field of the KDC-REQ 1690 -- structure in the containing AS-REQ for the client 1691 -- request. 1692 -- MUST be Absent for the KDC reply. 1693 ... 1694 } 1695 1696 AuthenticatedTimestamp ::= SEQUENCE { 1697 timestamp [0] PA-ENC-TS-ENC, 1698 -- Filled out according to Section 5.2.7.2 of [RFC4120]. 1699 -- Contains the client's current time for the client, 1700 -- and the KDC's current time for the KDC. 1701 checksum [1] CheckSum, 1702 -- The checksum is performed over the type 1703 -- AuthenticatedTimestampToBeSigned and the key usage is 1704 -- KEY_USAGE_AUTHENTICATED_TS_CLIENT for the client and 1705 _ KEY_USAGE_AUTHENTICATED_TS_KDC for the KDC 1706 ... 1707 } 1708 1709 KEY_USAGE_AUTHENTICATED_TS_CLIENT TBA 1710 KEY_USAGE_AUTHENTICATED_TS_KDC TBA 1711 1712 The client fills out the AuthenticatedTimestamp structure as follows: 1713 1714 o The timestamp field in the AuthenticatedTimestamp structure is 1715 filled out with the client's current time according to Section 1716 5.2.7.2 of [RFC4120]. 1717 1718 o The checksum field in the AuthenticatedTimestamp structure is 1719 performed over the type AuthenticatedTimestampToBeSigned. The 1720 checksum key is one of the client's long term keys. The key usage 1721 for the checksum operation is KEY_USAGE_AUTHENTICATED_TS_CLIENT. 1722 The checksum type is the required checksum type for the strongest 1723 enctype mutually supported by the client and the KDC. 1724 1725 o Within the AuthenticatedTimestampToBeSigned structure, the 1726 timestamp field contains the timestamp field of the corresponding 1727 AuthenticatedTimestamp structure, and the req-body field MUST 1728 contain the req-body field of the KDC-REQ structure in the 1729 containing AS-REQ. 1730 1731 Upon receipt of the PA_AUTHENTICATED_TIMESTAMP FAST factor, the KDC 1732 1733 1734 1735Zhu & Hartman Expires January 9, 2008 [Page 31] 1736 1737Internet-Draft Kerberos Preauth Framework July 2007 1738 1739 1740 MUST process the padata in a way similar to that of the encrypted 1741 timestamp padata. The KDC MUST verify the checksum in the 1742 AuthenticatedTimestamp structure and the timestamp is within the 1743 window of acceptable clock skew for the KDC. 1744 1745 When the authenticated timestamp FAST factor is accepted by the KDC, 1746 the KDC MUST include a PA_AUTHENTICATED_TIMESTAMP as a FAST factor in 1747 in a successful KDC reply and it MUST include the rep-key field as 1748 defined in Section 6.5.3. 1749 1750 The KDC fills out the AuthenticatedTimestamp structure as follows: 1751 1752 o The timestamp field in the AuthenticatedTimestamp structure is 1753 filled out with the KDC's current time according to Section 1754 5.2.7.2 of [RFC4120]. 1755 1756 o The checksum field in the AuthenticatedTimestamp structure is 1757 performed over the type AuthenticatedTimestampToBeSigned. The 1758 checksum key is the reply key picked from the client's long term 1759 keys according to [RFC4120]. The key usage for the checksum 1760 operation is KEY_USAGE_AUTHENTICATED_TS_KDC. The checksum type is 1761 the required checksum type for the checksum key. 1762 1763 o Within the AuthenticatedTimestampToBeSigned structure, the 1764 timestamp field contains the timestamp field of the corresponding 1765 AuthenticatedTimestamp structure, and the req-body field MUST be 1766 absent. 1767 1768 Upon receipt of the PA_AUTHENTICATED_TIMESTAMP FAST factor in the KDC 1769 reply, the client MUST verify the checksum in the 1770 AuthenticatedTimestamp structure and the timestamp is within the 1771 window of acceptable clock skew for the client. The successful 1772 verificaiton of the PA_AUTHENTICATED_TIMESTAMP padata authenticates 1773 the KDC. 1774 1775 The authenticated timestamp FAST factor provides the following 1776 facilities: client-authentication, replacing-reply-key, KDC- 1777 authentication. It does not provide the strengthening-reply-key 1778 facility. The security considerations section of this document 1779 provides an explanation why the security requirements are met. 1780 1781 Conforming implementations MUST support the authenticated timestamp 1782 FAST factor. 1783 17846.6. Authentication Strength Indication 1785 1786 Implementations that have pre-authentication mechanisms offering 1787 significantly different strengths of client authentication MAY choose 1788 1789 1790 1791Zhu & Hartman Expires January 9, 2008 [Page 32] 1792 1793Internet-Draft Kerberos Preauth Framework July 2007 1794 1795 1796 to keep track of the strength of the authentication used as an input 1797 into policy decisions. For example, some principals might require 1798 strong pre-authentication, while less sensitive principals can use 1799 relatively weak forms of pre-authentication like encrypted timestamp. 1800 1801 An AuthorizationData data type AD-Authentication-Strength is defined 1802 for this purpose. 1803 1804 AD-authentication-strength TBA 1805 1806 The corresponding ad-data field contains the DER encoding of the pre- 1807 authentication data set as defined in Section 6.4. This set contains 1808 all the pre-authentication mechanisms that were used to authenticate 1809 the client. If only one pre-authentication mechanism was used to 1810 authenticate the client, the pre-authentication set contains one 1811 element. 1812 1813 The AD-authentication-strength element MUST be included in the AD-IF- 1814 RELEVANT, thus it can be ignored if it is unknown to the receiver. 1815 1816 18177. IANA Considerations 1818 1819 This document defines several new pa-data types, key usages and error 1820 codes. In addition it would be good to track which pa-data items are 1821 only to be used as FAST factors. 1822 1823 18248. Security Considerations 1825 1826 The kdc-referrals option in the Kerberos FAST padata requests the KDC 1827 to act as the client to follow referrals. This can overload the KDC. 1828 To limit the damages of denied of service using this option, KDCs MAY 1829 restrict the number of simultaneous active requests with this option 1830 for any given client principal. 1831 1832 Because the client secrets are known only to the client and the KDC, 1833 the verification of the authenticated timestamp proves the client's 1834 identity, the verification of the authenticated timestamp in the KDC 1835 reply proves that the expected KDC responded. The encrypted reply 1836 key is contained in the rep-key in the PA-FX-FAST-REPLY. Therefore, 1837 the authenticated timestamp FAST factor as a pre-authentication 1838 mechanism offers the following facilities: client-authentication, 1839 replacing-reply-key, KDC-authentication. There is no un- 1840 authenticated clear text introduced by the authenticated timestamp 1841 FAST factor. 1842 1843 1844 1845 1846 1847Zhu & Hartman Expires January 9, 2008 [Page 33] 1848 1849Internet-Draft Kerberos Preauth Framework July 2007 1850 1851 18529. Acknowledgements 1853 1854 Several suggestions from Jeffery Hutzman based on early revisions of 1855 this documents led to significant improvements of this document. 1856 1857 The proposal to ask one KDC to chase down the referrals and return 1858 the final ticket is based on requirements in [ID.CROSS]. 1859 1860 Joel Webber had a proposal for a mechanism similar to FAST that 1861 created a protected tunnel for Kerberos pre-authentication. 1862 1863 186410. References 1865 186610.1. Normative References 1867 1868 [KRB-ANON] 1869 Zhu, L. and P. Leach, "Kerberos Anonymity Support", 1870 draft-ietf-krb-wg-anon-04.txt (work in progress), 2007. 1871 1872 [REFERRALS] 1873 Raeburn, K. and L. Zhu, "Generating KDC Referrals to 1874 Locate Kerberos Realms", 1875 draft-ietf-krb-wg-kerberos-referrals-10.txt (work in 1876 progress), 2007. 1877 1878 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 1879 Requirement Levels", BCP 14, RFC 2119, March 1997. 1880 1881 [RFC3961] Raeburn, K., "Encryption and Checksum Specifications for 1882 Kerberos 5", RFC 3961, February 2005. 1883 1884 [RFC4120] Neuman, C., Yu, T., Hartman, S., and K. Raeburn, "The 1885 Kerberos Network Authentication Service (V5)", RFC 4120, 1886 July 2005. 1887 1888 [RFC4556] Zhu, L. and B. Tung, "Public Key Cryptography for Initial 1889 Authentication in Kerberos (PKINIT)", RFC 4556, June 2006. 1890 189110.2. Informative References 1892 1893 [ID.CROSS] 1894 Sakane, S., Zrelli, S., and M. Ishiyama , "Problem 1895 Statement on the Operation of Kerberos in a Specific 1896 System", draft-sakane-krb-cross-problem-statement-02.txt 1897 (work in progress), April 2007. 1898 1899 [KRB-WG.SAM] 1900 1901 1902 1903Zhu & Hartman Expires January 9, 2008 [Page 34] 1904 1905Internet-Draft Kerberos Preauth Framework July 2007 1906 1907 1908 Hornstein, K., Renard, K., Neuman, C., and G. Zorn, 1909 "Integrating Single-use Authentication Mechanisms with 1910 Kerberos", draft-ietf-krb-wg-kerberos-sam-02.txt (work in 1911 progress), October 2003. 1912 1913 1914Appendix A. ASN.1 module 1915 1916 KerberosPreauthFramework { 1917 iso(1) identified-organization(3) dod(6) internet(1) 1918 security(5) kerberosV5(2) modules(4) preauth-framework(3) 1919 } DEFINITIONS EXPLICIT TAGS ::= BEGIN 1920 1921 IMPORTS 1922 KerberosTime, PrincipalName, Realm, EncryptionKey, Checksum, 1923 Int32, EncryptedData, PA-ENC-TS-ENC, PA-DATA, KDC-REQ-BODY 1924 FROM KerberosV5Spec2 { iso(1) identified-organization(3) 1925 dod(6) internet(1) security(5) kerberosV5(2) 1926 modules(4) krb5spec2(2) }; 1927 -- as defined in RFC 4120. 1928 1929 PA-FX-COOKIE ::= SEQUENCE { 1930 conversationId [0] OCTET STRING, 1931 -- Contains the identifier of this conversation. This field 1932 -- must contain the same value for all the messages 1933 -- within the same conversation. 1934 enc-binding-key [1] EncryptedData OPTIONAL, 1935 -- EncryptionKey -- 1936 -- This field is present when and only when a FAST 1937 -- padata as defined in Section 6.5 is included. 1938 -- The encrypted data, when decrypted, contains an 1939 -- EncryptionKey structure. 1940 -- This encryption key is encrypted using the armor key 1941 -- (defined in Section 6.5.1), and the key usage for the 1942 -- encryption is KEY_USAGE_FAST_BINDING_KEY. 1943 cookie [2] OCTET STRING OPTIONAL, 1944 -- Opaque data, for use to associate all the messages in 1945 -- a single conversation between the client and the KDC. 1946 -- This is generated by the KDC and the client MUST copy 1947 -- the exact cookie encapsulated in a PA_FX_COOKIE data 1948 -- element into the next message of the same conversation. 1949 ... 1950 } 1951 1952 PA-AUTHENTICATION-SET ::= SEQUENCE OF PA-AUTHENTICATION-SET-ELEM 1953 1954 PA-AUTHENTICATION-SET-ELEM ::= SEQUENCE { 1955 pa-type [0] Int32, 1956 1957 1958 1959Zhu & Hartman Expires January 9, 2008 [Page 35] 1960 1961Internet-Draft Kerberos Preauth Framework July 2007 1962 1963 1964 -- same as padata-type. 1965 pa-hint [1] OCTET STRING, 1966 -- hint data. 1967 ... 1968 } 1969 1970 KrbFastArmor ::= SEQUENCE { 1971 armor-type [0] Int32, 1972 -- Type of the armor. 1973 armor-value [1] OCTET STRING, 1974 -- Value of the armor. 1975 ... 1976 } 1977 1978 PA-FX-FAST-REQUEST ::= CHOICE { 1979 armored-data [0] KrbFastArmoredReq, 1980 ... 1981 } 1982 1983 KrbFastArmoredReq ::= SEQUENCE { 1984 armor [0] KrbFastArmor OPTIONAL, 1985 -- Contains the armor that identifies the armor key. 1986 -- MUST be present in AS-REQ. 1987 -- MUST be absent in TGS-REQ. 1988 req-checksum [1] Checksum, 1989 -- Checksum performed over the type KDC-REQ-BODY for 1990 -- the req-body field of the KDC-REQ structure defined in 1991 -- [RFC4120] 1992 -- The checksum key is the armor key, the checksum 1993 -- type is the required checksum type for the enctype of 1994 -- the armor key, and the key usage number is 1995 -- KEY_USAGE_FAST_REA_CHKSUM. 1996 enc-fast-req [2] EncryptedData, -- KrbFastReq -- 1997 -- The encryption key is the armor key, and the key usage 1998 -- number is KEY_USAGE_FAST_ENC. 1999 ... 2000 } 2001 2002 KrbFastReq ::= SEQUENCE { 2003 fast-options [0] FastOptions, 2004 -- Additional options. 2005 padata [1] SEQUENCE OF PA-DATA, 2006 -- padata typed holes. 2007 req-body [2] KDC-REQ-BODY, 2008 -- Contains the KDC request body as defined in Section 2009 -- 5.4.1 of [RFC4120]. The req-body field in the KDC-REQ 2010 -- structure [RFC4120] MUST be ignored. 2011 -- The client name and realm in the KDC-REQ [RFC4120] 2012 2013 2014 2015Zhu & Hartman Expires January 9, 2008 [Page 36] 2016 2017Internet-Draft Kerberos Preauth Framework July 2007 2018 2019 2020 -- MUST NOT be present for AS-REQ and TGS-REQ when 2021 -- Kerberos FAST padata is included in the request. 2022 ... 2023 } 2024 2025 FastOptions ::= KerberosFlags 2026 -- reserved(0), 2027 -- anonymous(1), 2028 -- kdc-referrals(16) 2029 2030 PA-FX-FAST-REPLY ::= CHOICE { 2031 armored-data [0] KrbFastArmoredRep, 2032 ... 2033 } 2034 2035 KrbFastArmoredRep ::= SEQUENCE { 2036 enc-fast-rep [0] EncryptedData, -- KrbFastResponse -- 2037 -- The encryption key is the armor key in the request, and 2038 -- the key usage number is KEY_USAGE_FAST_REP. 2039 ... 2040 } 2041 2042 KrbFastResponse ::= SEQUENCE { 2043 padata [0] SEQUENCE OF PA-DATA, 2044 -- padata typed holes. 2045 rep-key [1] EncryptionKey OPTIONAL, 2046 -- This, if present, replaces the reply key for AS and TGS. 2047 -- MUST be absent in KRB-ERROR. 2048 finished [2] KrbFastFinished OPTIONAL, 2049 -- MUST be present if the client is authenticated, 2050 -- absent otherwise. 2051 -- Typically this is present if and only if the containing 2052 -- message is the last one in a conversation. 2053 ... 2054 } 2055 2056 KrbFastFinished ::= SEQUENCE { 2057 timestamp [0] KerberosTime, 2058 usec [1] Microseconds, 2059 -- timestamp and usec represent the time on the KDC when 2060 -- the reply was generated. 2061 crealm [2] Realm, 2062 cname [3] PrincipalName, 2063 -- Contains the client realm and the client name. 2064 checksum [4] Checksum, 2065 -- Checksum performed over all the messages in the 2066 -- conversation, except the containing message. 2067 -- The checksum key is the binding key as defined in 2068 2069 2070 2071Zhu & Hartman Expires January 9, 2008 [Page 37] 2072 2073Internet-Draft Kerberos Preauth Framework July 2007 2074 2075 2076 -- Section 6.3, and the checksum type is the required 2077 -- checksum type of the binding key. 2078 ... 2079 } 2080 2081 AuthenticatedTimestampToBeSigned ::= SEQUENCE { 2082 timestamp [0] PA-ENC-TS-ENC, 2083 -- Contains the timestamp field of the corresponding 2084 -- AuthenticatedTimestamp structure. 2085 req-body [1] KDC-REQ-BODY OPTIONAL, 2086 -- MUST contain the req-body field of the KDC-REQ 2087 -- structure in the containing AS-REQ for the client 2088 -- request. 2089 -- MUST be Absent for the KDC reply. 2090 ... 2091 } 2092 2093 AuthenticatedTimestamp ::= SEQUENCE { 2094 timestamp [0] PA-ENC-TS-ENC, 2095 -- Filled out according to Section 5.2.7.2 of [RFC4120]. 2096 -- Contains the client's current time for the client, 2097 -- and the KDC's current time for the KDC. 2098 checksum [1] CheckSum, 2099 -- The checksum is performed over the type 2100 -- AuthenticatedTimestampToBeSigned and the key usage is 2101 -- KEY_USAGE_AUTHENTICATED_TS_CLIENT for the client and 2102 _ KEY_USAGE_AUTHENTICATED_TS_KDC for the KDC 2103 ... 2104 } 2105 END 2106 2107 2108Authors' Addresses 2109 2110 Larry Zhu 2111 Microsoft Corporation 2112 One Microsoft Way 2113 Redmond, WA 98052 2114 US 2115 2116 Email: lzhu@microsoft.com 2117 2118 2119 Sam hartman 2120 MIT 2121 2122 Email: hartmans@mit.edu 2123 2124 2125 2126 2127Zhu & Hartman Expires January 9, 2008 [Page 38] 2128 2129Internet-Draft Kerberos Preauth Framework July 2007 2130 2131 2132Full Copyright Statement 2133 2134 Copyright (C) The IETF Trust (2007). 2135 2136 This document is subject to the rights, licenses and restrictions 2137 contained in BCP 78, and except as set forth therein, the authors 2138 retain all their rights. 2139 2140 This document and the information contained herein are provided on an 2141 "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS 2142 OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY, THE IETF TRUST AND 2143 THE INTERNET ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS 2144 OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF 2145 THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED 2146 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 2147 2148 2149Intellectual Property 2150 2151 The IETF takes no position regarding the validity or scope of any 2152 Intellectual Property Rights or other rights that might be claimed to 2153 pertain to the implementation or use of the technology described in 2154 this document or the extent to which any license under such rights 2155 might or might not be available; nor does it represent that it has 2156 made any independent effort to identify any such rights. Information 2157 on the procedures with respect to rights in RFC documents can be 2158 found in BCP 78 and BCP 79. 2159 2160 Copies of IPR disclosures made to the IETF Secretariat and any 2161 assurances of licenses to be made available, or the result of an 2162 attempt made to obtain a general license or permission for the use of 2163 such proprietary rights by implementers or users of this 2164 specification can be obtained from the IETF on-line IPR repository at 2165 http://www.ietf.org/ipr. 2166 2167 The IETF invites any interested party to bring to its attention any 2168 copyrights, patents or patent applications, or other proprietary 2169 rights that may cover technology that may be required to implement 2170 this standard. Please address the information to the IETF at 2171 ietf-ipr@ietf.org. 2172 2173 2174Acknowledgment 2175 2176 Funding for the RFC Editor function is provided by the IETF 2177 Administrative Support Activity (IASA). 2178 2179 2180 2181 2182 2183Zhu & Hartman Expires January 9, 2008 [Page 39] 2184 2185