1 2 3 4Kerberos Working Group S. Hartman 5Internet-Draft Painless Security 6Updates: 4120 (if approved) L. Zhu 7Intended status: Standards Track Microsoft Corporation 8Expires: August 15, 2009 February 11, 2009 9 10 11 A Generalized Framework for Kerberos Pre-Authentication 12 draft-ietf-krb-wg-preauth-framework-09 13 14Status of this Memo 15 16 This Internet-Draft is submitted to IETF in full conformance with the 17 provisions of BCP 78 and BCP 79. 18 19 Internet-Drafts are working documents of the Internet Engineering 20 Task Force (IETF), its areas, and its working groups. Note that 21 other groups may also distribute working documents as Internet- 22 Drafts. 23 24 Internet-Drafts are draft documents valid for a maximum of six months 25 and may be updated, replaced, or obsoleted by other documents at any 26 time. It is inappropriate to use Internet-Drafts as reference 27 material or to cite them other than as "work in progress." 28 29 The list of current Internet-Drafts can be accessed at 30 http://www.ietf.org/ietf/1id-abstracts.txt. 31 32 The list of Internet-Draft Shadow Directories can be accessed at 33 http://www.ietf.org/shadow.html. 34 35 This Internet-Draft will expire on August 15, 2009. 36 37Copyright Notice 38 39 Copyright (c) 2009 IETF Trust and the persons identified as the 40 document authors. All rights reserved. 41 42 This document is subject to BCP 78 and the IETF Trust's Legal 43 Provisions Relating to IETF Documents 44 (http://trustee.ietf.org/license-info) in effect on the date of 45 publication of this document. Please review these documents 46 carefully, as they describe your rights and restrictions with respect 47 to this document. 48 49Abstract 50 51 Kerberos is a protocol for verifying the identity of principals 52 53 54 55Hartman & Zhu Expires August 15, 2009 [Page 1] 56 57Internet-Draft Kerberos Preauth Framework February 2009 58 59 60 (e.g., a workstation user or a network server) on an open network. 61 The Kerberos protocol provides a mechanism called pre-authentication 62 for proving the identity of a principal and for better protecting the 63 long-term secrets of the principal. 64 65 This document describes a model for Kerberos pre-authentication 66 mechanisms. The model describes what state in the Kerberos request a 67 pre-authentication mechanism is likely to change. It also describes 68 how multiple pre-authentication mechanisms used in the same request 69 will interact. 70 71 This document also provides common tools needed by multiple pre- 72 authentication mechanisms. One of these tools is a secure channel 73 between the client and the KDC with a reply key delivery mechanism; 74 this secure channel can be used to protect the authentication 75 exchange thus eliminate offline dictionary attacks. With these 76 tools, it is relatively straightforward to chain multiple 77 authentication mechanisms, utilize a different key management system, 78 or support a new key agreement algorithm. 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 111Hartman & Zhu Expires August 15, 2009 [Page 2] 112 113Internet-Draft Kerberos Preauth Framework February 2009 114 115 116Table of Contents 117 118 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 5 119 2. Conventions and Terminology Used in This Document . . . . . . 6 120 3. Model for Pre-Authentication . . . . . . . . . . . . . . . . . 6 121 3.1. Information Managed by the Pre-authentication Model . . . 7 122 3.2. Initial Pre-authentication Required Error . . . . . . . . 9 123 3.3. Client to KDC . . . . . . . . . . . . . . . . . . . . . . 10 124 3.4. KDC to Client . . . . . . . . . . . . . . . . . . . . . . 11 125 4. Pre-Authentication Facilities . . . . . . . . . . . . . . . . 12 126 4.1. Client-authentication Facility . . . . . . . . . . . . . . 13 127 4.2. Strengthening-reply-key Facility . . . . . . . . . . . . . 13 128 4.3. Replacing-reply-key Facility . . . . . . . . . . . . . . . 14 129 4.4. KDC-authentication Facility . . . . . . . . . . . . . . . 15 130 5. Requirements for Pre-Authentication Mechanisms . . . . . . . . 15 131 6. Tools for Use in Pre-Authentication Mechanisms . . . . . . . . 16 132 6.1. Combining Keys . . . . . . . . . . . . . . . . . . . . . . 16 133 6.2. Protecting Requests/Responses . . . . . . . . . . . . . . 18 134 6.3. Managing States for the KDC . . . . . . . . . . . . . . . 18 135 6.4. Pre-authentication Set . . . . . . . . . . . . . . . . . . 20 136 6.5. Definition of Kerberos FAST Padata . . . . . . . . . . . . 22 137 6.5.1. FAST Armors . . . . . . . . . . . . . . . . . . . . . 23 138 6.5.2. FAST Request . . . . . . . . . . . . . . . . . . . . . 25 139 6.5.3. FAST Response . . . . . . . . . . . . . . . . . . . . 29 140 6.5.4. Authenticated Kerberos Error Messages using 141 Kerberos FAST . . . . . . . . . . . . . . . . . . . . 32 142 6.5.5. Outer and Inner Requests . . . . . . . . . . . . . . . 33 143 6.5.6. The Encrypted Challenge FAST Factor . . . . . . . . . 33 144 6.6. Authentication Strength Indication . . . . . . . . . . . . 35 145 7. Assigned Constants . . . . . . . . . . . . . . . . . . . . . . 35 146 7.1. New Errors . . . . . . . . . . . . . . . . . . . . . . . . 36 147 7.2. Key Usage Numbers . . . . . . . . . . . . . . . . . . . . 36 148 7.3. Authorization Data Elements . . . . . . . . . . . . . . . 36 149 7.4. New PA-DATA Types . . . . . . . . . . . . . . . . . . . . 36 150 8. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 36 151 8.1. Pre-authentication and Typed Data . . . . . . . . . . . . 36 152 8.2. Fast Armor Types . . . . . . . . . . . . . . . . . . . . . 38 153 8.3. FAST Options . . . . . . . . . . . . . . . . . . . . . . . 39 154 9. Security Considerations . . . . . . . . . . . . . . . . . . . 39 155 10. Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . 39 156 11. References . . . . . . . . . . . . . . . . . . . . . . . . . . 40 157 11.1. Normative References . . . . . . . . . . . . . . . . . . . 40 158 11.2. Informative References . . . . . . . . . . . . . . . . . . 40 159 Appendix A. Change History . . . . . . . . . . . . . . . . . . . 41 160 A.1. Changes since 08 . . . . . . . . . . . . . . . . . . . . . 41 161 A.2. Changes since 07 . . . . . . . . . . . . . . . . . . . . . 42 162 A.3. Changes since 06 . . . . . . . . . . . . . . . . . . . . . 42 163 Appendix B. ASN.1 module . . . . . . . . . . . . . . . . . . . . 42 164 165 166 167Hartman & Zhu Expires August 15, 2009 [Page 3] 168 169Internet-Draft Kerberos Preauth Framework February 2009 170 171 172 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 45 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223Hartman & Zhu Expires August 15, 2009 [Page 4] 224 225Internet-Draft Kerberos Preauth Framework February 2009 226 227 2281. Introduction 229 230 The core Kerberos specification [RFC4120] treats pre-authentication 231 data as an opaque typed hole in the messages to the KDC that may 232 influence the reply key used to encrypt the KDC reply. This 233 generality has been useful: pre-authentication data is used for a 234 variety of extensions to the protocol, many outside the expectations 235 of the initial designers. However, this generality makes designing 236 more common types of pre-authentication mechanisms difficult. Each 237 mechanism needs to specify how it interacts with other mechanisms. 238 Also, problems like combining a key with the long-term secrets or 239 proving the identity of the user are common to multiple mechanisms. 240 Where there are generally well-accepted solutions to these problems, 241 it is desirable to standardize one of these solutions so mechanisms 242 can avoid duplication of work. In other cases, a modular approach to 243 these problems is appropriate. The modular approach will allow new 244 and better solutions to common pre-authentication problems to be used 245 by existing mechanisms as they are developed. 246 247 This document specifies a framework for Kerberos pre-authentication 248 mechanisms. It defines the common set of functions that pre- 249 authentication mechanisms perform as well as how these functions 250 affect the state of the request and reply. In addition several 251 common tools needed by pre-authentication mechanisms are provided. 252 Unlike [RFC3961], this framework is not complete--it does not 253 describe all the inputs and outputs for the pre-authentication 254 mechanisms. Pre-Authentication mechanism designers should try to be 255 consistent with this framework because doing so will make their 256 mechanisms easier to implement. Kerberos implementations are likely 257 to have plugin architectures for pre-authentication; such 258 architectures are likely to support mechanisms that follow this 259 framework plus commonly used extensions. This framework also 260 facilitates combining multiple pre-authentication mechanisms, each of 261 which may represent an authentication factor, into a single multi- 262 factor pre-authentication mechanism. 263 264 One of these common tools is the flexible authentication secure 265 tunneling (FAST) padata type. FAST provides a protected channel 266 between the client and the KDC, and it can optionally deliver a reply 267 key within the protected channel. Based on FAST, pre-authentication 268 mechanisms can extend Kerberos with ease, to support, for example, 269 password authenticated key exchange (PAKE) protocols with zero 270 knowledge password proof (ZKPP) [EKE] [IEEE1363.2]. Any pre- 271 authentication mechanism can be encapsulated in the FAST messages as 272 defined in Section 6.5. A pre-authentication type carried within 273 FAST is called a FAST factor. Creating a FAST factor is the easiest 274 path to create a new pre-authentication mechanism. FAST factors are 275 significantly easier to analyze from a security standpoint than other 276 277 278 279Hartman & Zhu Expires August 15, 2009 [Page 5] 280 281Internet-Draft Kerberos Preauth Framework February 2009 282 283 284 pre-authentication mechanisms. 285 286 Mechanism designers should design FAST factors, instead of new pre- 287 authentication mechanisms outside of FAST. 288 289 2902. Conventions and Terminology Used in This Document 291 292 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 293 "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this 294 document are to be interpreted as described in [RFC2119]. 295 296 The word padata is used as a shorthand for pre-authentication data. 297 298 A conversation is the set of all authentication messages exchanged 299 between the client and the client's KDCs in order to authenticate the 300 client principal. A conversation as defined here consists of all 301 messages that are necessary to complete the authentication between 302 the client and the client's KDCs. 303 304 If the KDC reply in an Authentication Service (AS) exchange is 305 verified, the KDC is authenticated by the client. In this document, 306 verification of the KDC reply is used as a synonym of authentication 307 of the KDC. 308 309 Lastly, this document should be read only after reading the documents 310 describing the Kerberos cryptography framework [RFC3961] and the core 311 Kerberos protocol [RFC4120]. This document may freely use 312 terminology and notation from these documents without reference or 313 further explanation. 314 315 3163. Model for Pre-Authentication 317 318 When a Kerberos client wishes to obtain a ticket using the 319 authentication server, it sends an initial Authentication Service 320 (AS) request. If pre-authentication is required but not being used, 321 then the KDC will respond with a KDC_ERR_PREAUTH_REQUIRED error. 322 Alternatively, if the client knows what pre-authentication to use, it 323 MAY optimize away a round-trip and send an initial request with 324 padata included in the initial request. If the client includes the 325 padata computed using the wrong pre-authentication mechanism or 326 incorrect keys, the KDC MAY return KDC_ERR_PREAUTH_FAILED with no 327 indication of what padata should have been included. In that case, 328 the client MUST retry with no padata and examine the error data of 329 the KDC_ERR_PREAUTH_REQUIRED error. If the KDC includes pre- 330 authentication information in the accompanying error data of 331 KDC_ERR_PREAUTH_FAILED, the client SHOULD process the error data, and 332 333 334 335Hartman & Zhu Expires August 15, 2009 [Page 6] 336 337Internet-Draft Kerberos Preauth Framework February 2009 338 339 340 then retry. 341 342 The conventional KDC maintains no state between two requests; 343 subsequent requests may even be processed by a different KDC. On the 344 other hand, the client treats a series of exchanges with KDCs as a 345 single conversation. Each exchange accumulates state and hopefully 346 brings the client closer to a successful authentication. 347 348 These models for state management are in apparent conflict. For many 349 of the simpler pre-authentication scenarios, the client uses one 350 round trip to find out what mechanisms the KDC supports. Then the 351 next request contains sufficient pre-authentication for the KDC to be 352 able to return a successful reply. For these simple scenarios, the 353 client only sends one request with pre-authentication data and so the 354 conversation is trivial. For more complex conversations, the KDC 355 needs to provide the client with a cookie to include in future 356 requests to capture the current state of the authentication session. 357 Handling of multiple round-trip mechanisms is discussed in 358 Section 6.3. 359 360 This framework specifies the behavior of Kerberos pre-authentication 361 mechanisms used to identify users or to modify the reply key used to 362 encrypt the KDC reply. The PA-DATA typed hole may be used to carry 363 extensions to Kerberos that have nothing to do with proving the 364 identity of the user or establishing a reply key. Such extensions 365 are outside the scope of this framework. However mechanisms that do 366 accomplish these goals should follow this framework. 367 368 This framework specifies the minimum state that a Kerberos 369 implementation needs to maintain while handling a request in order to 370 process pre-authentication. It also specifies how Kerberos 371 implementations process the padata at each step of the AS request 372 process. 373 3743.1. Information Managed by the Pre-authentication Model 375 376 The following information is maintained by the client and KDC as each 377 request is being processed: 378 379 o The reply key used to encrypt the KDC reply 380 381 o How strongly the identity of the client has been authenticated 382 383 o Whether the reply key has been used in this conversation 384 385 o Whether the reply key has been replaced in this conversation 386 387 388 389 390 391Hartman & Zhu Expires August 15, 2009 [Page 7] 392 393Internet-Draft Kerberos Preauth Framework February 2009 394 395 396 o Whether the contents of the KDC reply can be verified by the 397 client principal 398 399 400 Conceptually, the reply key is initially the long-term key of the 401 principal. However, principals can have multiple long-term keys 402 because of support for multiple encryption types, salts and 403 string2key parameters. As described in Section 5.2.7.5 of the 404 Kerberos protocol [RFC4120], the KDC sends PA-ETYPE-INFO2 to notify 405 the client what types of keys are available. Thus in full 406 generality, the reply key in the pre-authentication model is actually 407 a set of keys. At the beginning of a request, it is initialized to 408 the set of long-term keys advertised in the PA-ETYPE-INFO2 element on 409 the KDC. If multiple reply keys are available, the client chooses 410 which one to use. Thus the client does not need to treat the reply 411 key as a set. At the beginning of a request, the client picks a key 412 to use. 413 414 KDC implementations MAY choose to offer only one key in the PA-ETYPE- 415 INFO2 element. Since the KDC already knows the client's list of 416 supported enctypes from the request, no interoperability problems are 417 created by choosing a single possible reply key. This way, the KDC 418 implementation avoids the complexity of treating the reply key as a 419 set. 420 421 When the padata in the request is verified by the KDC, then the 422 client is known to have that key, therefore the KDC SHOULD pick the 423 same key as the reply key. 424 425 At the beginning of handling a message on both the client and the 426 KDC, the client's identity is not authenticated. A mechanism may 427 indicate that it has successfully authenticated the client's 428 identity. This information is useful to keep track of on the client 429 in order to know what pre-authentication mechanisms should be used. 430 The KDC needs to keep track of whether the client is authenticated 431 because the primary purpose of pre-authentication is to authenticate 432 the client identity before issuing a ticket. The handling of 433 authentication strength using various authentication mechanisms is 434 discussed in Section 6.6. 435 436 Initially the reply key has not been used. A pre-authentication 437 mechanism that uses the reply key to encrypt or checksum some data in 438 the generation of new keys MUST indicate that the reply key is used. 439 This state is maintained by the client and the KDC to enforce the 440 security requirement stated in Section 4.3 that the reply key SHOULD 441 NOT be replaced after it is used. 442 443 Initially the reply key has not been replaced. If a mechanism 444 445 446 447Hartman & Zhu Expires August 15, 2009 [Page 8] 448 449Internet-Draft Kerberos Preauth Framework February 2009 450 451 452 implements the Replace Reply Key facility discussed in Section 4.3, 453 then the state MUST be updated to indicate that the reply key has 454 been replaced. Once the reply key has been replaced, knowledge of 455 the reply key is insufficient to authenticate the client. The reply 456 key is marked replaced in exactly the same situations as the KDC 457 reply is marked as not being verified to the client principal. 458 However, while mechanisms can verify the KDC reply to the client, 459 once the reply key is replaced, then the reply key remains replaced 460 for the remainder of the conversation. 461 462 Without pre-authentication, the client knows that the KDC reply is 463 authentic and has not been modified because it is encrypted in a 464 long-term key of the client. Only the KDC and the client know that 465 key. So at the start of a conversation, the KDC reply is presumed to 466 be verified using the client principal's long-term key. It should be 467 noted that in this document, verifying the KDC reply means 468 authenticating the KDC, and these phrases are used interchangeably. 469 Any pre-authentication mechanism that sets a new reply key not based 470 on the principal's long-term secret MUST either verify the KDC reply 471 some other way or indicate that the reply is not verified. If a 472 mechanism indicates that the reply is not verified then the client 473 implementation MUST return an error unless a subsequent mechanism 474 verifies the reply. The KDC needs to track this state so it can 475 avoid generating a reply that is not verified. 476 477 The typical Kerberos request does not provide a way for the client 478 machine to know that it is talking to the correct KDC. Someone who 479 can inject packets into the network between the client machine and 480 the KDC and who knows the password that the user will give to the 481 client machine can generate a KDC reply that will decrypt properly. 482 So, if the client machine needs to authenticate that the user is in 483 fact the named principal, then the client machine needs to do a TGS 484 request for itself as a service. Some pre-authentication mechanisms 485 may provide a way for the client machine to authenticate the KDC. 486 Examples of this include signing the reply that can be verified using 487 a well-known public key or providing a ticket for the client machine 488 as a service. 489 4903.2. Initial Pre-authentication Required Error 491 492 Typically a client starts a conversation by sending an initial 493 request with no pre-authentication. If the KDC requires pre- 494 authentication, then it returns a KDC_ERR_PREAUTH_REQUIRED message. 495 After the first reply with the KDC_ERR_PREAUTH_REQUIRED error code, 496 the KDC returns the error code KDC_ERR_MORE_PREAUTH_DATA_NEEDED 497 (defined in Section 6.3) for pre-authentication configurations that 498 use multi-round-trip mechanisms; see Section 3.4 for details of that 499 case. 500 501 502 503Hartman & Zhu Expires August 15, 2009 [Page 9] 504 505Internet-Draft Kerberos Preauth Framework February 2009 506 507 508 The KDC needs to choose which mechanisms to offer the client. The 509 client needs to be able to choose what mechanisms to use from the 510 first message. For example consider the KDC that will accept 511 mechanism A followed by mechanism B or alternatively the single 512 mechanism C. A client that supports A and C needs to know that it 513 should not bother trying A. 514 515 Mechanisms can either be sufficient on their own or can be part of an 516 authentication set--a group of mechanisms that all need to 517 successfully complete in order to authenticate a client. Some 518 mechanisms may only be useful in authentication sets; others may be 519 useful alone or in authentication sets. For the second group of 520 mechanisms, KDC policy dictates whether the mechanism will be part of 521 an authentication set or offered alone. For each mechanism that is 522 offered alone, the KDC includes the pre-authentication type ID of the 523 mechanism in the padata sequence returned in the 524 KDC_ERR_PREAUTH_REQUIRED error. 525 526 The KDC SHOULD NOT send data that is encrypted in the long-term 527 password-based key of the principal. Doing so has the same security 528 exposures as the Kerberos protocol without pre-authentication. There 529 are few situations where the KDC needs to expose cipher text 530 encrypted in a weak key before the client has proven knowledge of 531 that key, and pre-authentication is desirable. 532 5333.3. Client to KDC 534 535 This description assumes that a client has already received a 536 KDC_ERR_PREAUTH_REQUIRED from the KDC. If the client performs 537 optimistic pre-authentication then the client needs to guess values 538 for the information it would normally receive from that error 539 response or use cached information obtained in prior interactions 540 with the KDC. 541 542 The client starts by initializing the pre-authentication state as 543 specified. It then processes the padata in the 544 KDC_ERR_PREAUTH_REQUIRED. 545 546 When processing the response to the KDC_ERR_PREAUTH_REQUIRED, the 547 client MAY ignore any padata it chooses unless doing so violates a 548 specification to which the client conforms. Clients conforming to 549 this specification MUST NOT ignore the padata defined in Section 6.3. 550 Clients SHOULD process padata unrelated to this framework or other 551 means of authenticating the user. Clients SHOULD choose one 552 authentication set or mechanism that could lead to authenticating the 553 user and ignore the rest. Since the list of mechanisms offered by 554 the KDC is in the decreasing preference order, clients typically 555 choose the first mechanism or authentication set that the client can 556 557 558 559Hartman & Zhu Expires August 15, 2009 [Page 10] 560 561Internet-Draft Kerberos Preauth Framework February 2009 562 563 564 usefully perform. If a client chooses to ignore a padata it MUST NOT 565 process the padata, allow the padata to affect the pre-authentication 566 state, nor respond to the padata. 567 568 For each padata the client chooses to process, the client processes 569 the padata and modifies the pre-authentication state as required by 570 that mechanism. Padata are processed in the order received from the 571 KDC. 572 573 After processing the padata in the KDC error, the client generates a 574 new request. It processes the pre-authentication mechanisms in the 575 order in which they will appear in the next request, updating the 576 state as appropriate. The request is sent when it is complete. 577 5783.4. KDC to Client 579 580 When a KDC receives an AS request from a client, it needs to 581 determine whether it will respond with an error or an AS reply. 582 There are many causes for an error to be generated that have nothing 583 to do with pre-authentication; they are discussed in the core 584 Kerberos specification. 585 586 From the standpoint of evaluating the pre-authentication, the KDC 587 first starts by initializing the pre-authentication state. If a PA- 588 FX-COOKIE pre-authentication data item is present, it is processed 589 first; see Section 6.3 for a definition. It then processes the 590 padata in the request. As mentioned in Section 3.3, the KDC MAY 591 ignore padata that is inappropriate for the configuration and MUST 592 ignore padata of an unknown type. The KDC MUST NOT ignore padata of 593 types used in previous messages. For example, if a KDC issues a 594 KDC_ERR_PREAUTH_REQUIRED error including padata of type x, then the 595 KDC cannot ignore padata of type x received in an AS-REQ message from 596 the client. 597 598 At this point the KDC decides whether it will issue an error or a 599 reply. Typically a KDC will issue a reply if the client's identity 600 has been authenticated to a sufficient degree. 601 602 In the case of a KDC_ERR_MORE_PREAUTH_DATA_NEEDED error, the KDC 603 first starts by initializing the pre-authentication state. Then it 604 processes any padata in the client's request in the order provided by 605 the client. Mechanisms that are not understood by the KDC are 606 ignored. Next, it generates padata for the error response, modifying 607 the pre-authentication state appropriately as each mechanism is 608 processed. The KDC chooses the order in which it will generate 609 padata (and thus the order of padata in the response), but it needs 610 to modify the pre-authentication state consistently with the choice 611 of order. For example, if some mechanism establishes an 612 613 614 615Hartman & Zhu Expires August 15, 2009 [Page 11] 616 617Internet-Draft Kerberos Preauth Framework February 2009 618 619 620 authenticated client identity, then the subsequent mechanisms in the 621 generated response receive this state as input. After the padata is 622 generated, the error response is sent. Typically the errors with the 623 code KDC_ERR_MORE_PREAUTH_DATA_NEEDED in a conversation will include 624 KDC state as discussed in Section 6.3. 625 626 To generate a final reply, the KDC generates the padata modifying the 627 pre-authentication state as necessary. Then it generates the final 628 response, encrypting it in the current pre-authentication reply key. 629 630 6314. Pre-Authentication Facilities 632 633 Pre-Authentication mechanisms can be thought of as providing various 634 conceptual facilities. This serves two useful purposes. First, 635 mechanism authors can choose only to solve one specific small 636 problem. It is often useful for a mechanism designed to offer key 637 management not to directly provide client authentication but instead 638 to allow one or more other mechanisms to handle this need. Secondly, 639 thinking about the abstract services that a mechanism provides yields 640 a minimum set of security requirements that all mechanisms providing 641 that facility must meet. These security requirements are not 642 complete; mechanisms will have additional security requirements based 643 on the specific protocol they employ. 644 645 A mechanism is not constrained to only offering one of these 646 facilities. While such mechanisms can be designed and are sometimes 647 useful, many pre-authentication mechanisms implement several 648 facilities. By combining multiple facilities in a single mechanism, 649 it is often easier to construct a secure, simple solution than by 650 solving the problem in full generality. Even when mechanisms provide 651 multiple facilities, they need to meet the security requirements for 652 all the facilities they provide. If the FAST factor approach is 653 used, it is likely that one or a small number of facilities can be 654 provided by a single mechanism without complicating the security 655 analysis. 656 657 According to Kerberos extensibility rules (Section 1.5 of the 658 Kerberos specification [RFC4120]), an extension MUST NOT change the 659 semantics of a message unless a recipient is known to understand that 660 extension. Because a client does not know that the KDC supports a 661 particular pre-authentication mechanism when it sends an initial 662 request, a pre-authentication mechanism MUST NOT change the semantics 663 of the request in a way that will break a KDC that does not 664 understand that mechanism. Similarly, KDCs MUST NOT send messages to 665 clients that affect the core semantics unless the client has 666 indicated support for the message. 667 668 669 670 671Hartman & Zhu Expires August 15, 2009 [Page 12] 672 673Internet-Draft Kerberos Preauth Framework February 2009 674 675 676 The only state in this model that would break the interpretation of a 677 message is changing the expected reply key. If one mechanism changed 678 the reply key and a later mechanism used that reply key, then a KDC 679 that interpreted the second mechanism but not the first would fail to 680 interpret the request correctly. In order to avoid this problem, 681 extensions that change core semantics are typically divided into two 682 parts. The first part proposes a change to the core semantic--for 683 example proposes a new reply key. The second part acknowledges that 684 the extension is understood and that the change takes effect. 685 Section 4.2 discusses how to design mechanisms that modify the reply 686 key to be split into a proposal and acceptance without requiring 687 additional round trips to use the new reply key in subsequent pre- 688 authentication. Other changes in the state described in Section 3.1 689 can safely be ignored by a KDC that does not understand a mechanism. 690 Mechanisms that modify the behavior of the request outside the scope 691 of this framework need to carefully consider the Kerberos 692 extensibility rules to avoid similar problems. 693 6944.1. Client-authentication Facility 695 696 The client authentication facility proves the identity of a user to 697 the KDC before a ticket is issued. Examples of mechanisms 698 implementing this facility include the encrypted timestamp facility 699 defined in Section 5.2.7.2 of the Kerberos specification [RFC4120]. 700 Mechanisms that provide this facility are expected to mark the client 701 as authenticated. 702 703 Mechanisms implementing this facility SHOULD require the client to 704 prove knowledge of the reply key before transmitting a successful KDC 705 reply. Otherwise, an attacker can intercept the pre-authentication 706 exchange and get a reply to attack. One way of proving the client 707 knows the reply key is to implement the Replace Reply Key facility 708 along with this facility. The PKINIT mechanism [RFC4556] implements 709 Client Authentication alongside Replace Reply Key. 710 711 If the reply key has been replaced, then mechanisms such as 712 encrypted-timestamp that rely on knowledge of the reply key to 713 authenticate the client MUST NOT be used. 714 7154.2. Strengthening-reply-key Facility 716 717 Particularly when dealing with keys based on passwords, it is 718 desirable to increase the strength of the key by adding additional 719 secrets to it. Examples of sources of additional secrets include the 720 results of a Diffie-Hellman key exchange or key bits from the output 721 of a smart card [KRB-WG.SAM]. Typically these additional secrets can 722 be first combined with the existing reply key and then converted to a 723 protocol key using tools defined in Section 6.1. 724 725 726 727Hartman & Zhu Expires August 15, 2009 [Page 13] 728 729Internet-Draft Kerberos Preauth Framework February 2009 730 731 732 Typically a mechanism implementing this facility will know that the 733 other side of the exchange supports the facility before the reply key 734 is changed. For example, a mechanism might need to learn the 735 certificate for a KDC before encrypting a new key in the public key 736 belonging to that certificate. However, if a mechanism implementing 737 this facility wishes to modify the reply key before knowing that the 738 other party in the exchange supports the mechanism, it proposes 739 modifying the reply key. The other party then includes a message 740 indicating that the proposal is accepted if it is understood and 741 meets policy. In many cases it is desirable to use the new reply key 742 for client authentication and for other facilities. Waiting for the 743 other party to accept the proposal and actually modify the reply key 744 state would add an additional round trip to the exchange. Instead, 745 mechanism designers are encouraged to include a typed hole for 746 additional padata in the message that proposes the reply key change. 747 The padata included in the typed hole are generated assuming the new 748 reply key. If the other party accepts the proposal, then these 749 padata are considered as an inner level. As with the outer level, 750 one authentication set or mechanism is typically chosen for client 751 authentication, along with auxiliary mechanisms such as KDC cookies, 752 and other mechanisms are ignored. When mechanisms include such a 753 container, the hint provided for use in authentication sets (as 754 defined in Section 6.4) MUST contain a sequence of inner mechanisms 755 along with hints for those mechanisms. The party generating the 756 proposal can determine whether the padata were processed based on 757 whether the proposal for the reply key is accepted. 758 759 The specific formats of the proposal message, including where padata 760 are included is a matter for the mechanism specification. Similarly, 761 the format of the message accepting the proposal is mechanism- 762 specific. 763 764 Mechanisms implementing this facility and including a typed hole for 765 additional padata MUST checksum that padata using a keyed checksum or 766 encrypt the padata. This requirement protects against modification 767 of the contents of the typed hole. By modifying these contents an 768 attacker might be able to choose which mechanism is used to 769 authenticate the client, or to convince a party to provide text 770 encrypted in a key that the attacker had manipulated. It is 771 important that mechanisms strengthen the reply key enough that using 772 it to checksum padata is appropriate. 773 7744.3. Replacing-reply-key Facility 775 776 The Replace Reply Key facility replaces the key in which a successful 777 AS reply will be encrypted. This facility can only be used in cases 778 where knowledge of the reply key is not used to authenticate the 779 client. The new reply key MUST be communicated to the client and the 780 781 782 783Hartman & Zhu Expires August 15, 2009 [Page 14] 784 785Internet-Draft Kerberos Preauth Framework February 2009 786 787 788 KDC in a secure manner. This facility MUST NOT be used if there can 789 be a man-in-the-middle between the client and the KDC. Mechanisms 790 implementing this facility MUST mark the reply key as replaced in the 791 pre-authentication state. Mechanisms implementing this facility MUST 792 either provide a mechanism to verify the KDC reply to the client or 793 mark the reply as unverified in the pre-authentication state. 794 Mechanisms implementing this facility SHOULD NOT be used if a 795 previous mechanism has used the reply key. 796 797 As with the strengthening-reply-key facility, Kerberos extensibility 798 rules require that the reply key not be changed unless both sides of 799 the exchange understand the extension. In the case of this facility 800 it will likely be the case for both sides to know that the facility 801 is available by the time that the new key is available to be used. 802 However, mechanism designers can use a container for padata in a 803 proposal message as discussed in Section 4.2 if appropriate. 804 8054.4. KDC-authentication Facility 806 807 This facility verifies that the reply comes from the expected KDC. 808 In traditional Kerberos, the KDC and the client share a key, so if 809 the KDC reply can be decrypted then the client knows that a trusted 810 KDC responded. Note that the client machine cannot trust the client 811 unless the machine is presented with a service ticket for it 812 (typically the machine can retrieve this ticket by itself). However, 813 if the reply key is replaced, some mechanism is required to verify 814 the KDC. Pre-authentication mechanisms providing this facility allow 815 a client to determine that the expected KDC has responded even after 816 the reply key is replaced. They mark the pre-authentication state as 817 having been verified. 818 819 8205. Requirements for Pre-Authentication Mechanisms 821 822 This section lists requirements for specifications of pre- 823 authentication mechanisms. 824 825 For each message in the pre-authentication mechanism, the 826 specification describes the pa-type value to be used and the contents 827 of the message. The processing of the message by the sender and 828 recipient is also specified. This specification needs to include all 829 modifications to the pre-authentication state. 830 831 Generally mechanisms have a message that can be sent in the error 832 data of the KDC_ERR_PREAUTH_REQUIRED error message or in an 833 authentication set. If the client needs information such as trusted 834 certificate authorities in order to determine if it can use the 835 mechanism, then this information should be in that message. In 836 837 838 839Hartman & Zhu Expires August 15, 2009 [Page 15] 840 841Internet-Draft Kerberos Preauth Framework February 2009 842 843 844 addition, such mechanisms should also define a pa-hint to be included 845 in authentication sets. Often, the same information included in the 846 padata-value is appropriate to include in the pa-hint (as defined in 847 Section 6.4). 848 849 In order to ease security analysis the mechanism specification should 850 describe what facilities from this document are offered by the 851 mechanism. For each facility, the security consideration section of 852 the mechanism specification should show that the security 853 requirements of that facility are met. This requirement is 854 applicable to any FAST factor that provides authentication 855 information. 856 857 Significant problems have resulted in the specification of Kerberos 858 protocols because much of the KDC exchange is not protected against 859 authentication. The security considerations section should discuss 860 unauthenticated plaintext attacks. It should either show that 861 plaintext is protected or discuss what harm an attacker could do by 862 modifying the plaintext. It is generally acceptable for an attacker 863 to be able to cause the protocol negotiation to fail by modifying 864 plaintext. More significant attacks should be evaluated carefully. 865 866 As discussed in Section 6.3, there is no guarantee that a client will 867 use the same KDCs for all messages in a conversation. The mechanism 868 specification needs to show why the mechanism is secure in this 869 situation. The hardest problem to deal with, especially for 870 challenge/response mechanisms is to make sure that the same response 871 cannot be replayed against two KDCs while allowing the client to talk 872 to any KDC. 873 874 8756. Tools for Use in Pre-Authentication Mechanisms 876 877 This section describes common tools needed by multiple pre- 878 authentication mechanisms. By using these tools mechanism designers 879 can use a modular approach to specify mechanism details and ease 880 security analysis. 881 8826.1. Combining Keys 883 884 Frequently a weak key needs to be combined with a stronger key before 885 use. For example, passwords are typically limited in size and 886 insufficiently random, therefore it is desirable to increase the 887 strength of the keys based on passwords by adding additional secrets. 888 Additional source of secrecy may come from hardware tokens. 889 890 This section provides standard ways to combine two keys into one. 891 892 893 894 895Hartman & Zhu Expires August 15, 2009 [Page 16] 896 897Internet-Draft Kerberos Preauth Framework February 2009 898 899 900 KRB-FX-CF1() is defined to combine two pass-phrases. 901 902 KRB-FX-CF1(UTF-8 string, UTF-8 string) -> (UTF-8 string) 903 KRB-FX-CF1(x, y) -> x || y 904 905 Where || denotes concatenation. The strength of the final key is 906 roughly the total strength of the individual keys being combined 907 assuming that the string_to_key() function [RFC3961] uses all its 908 input evenly. 909 910 An example usage of KRB-FX-CF1() is when a device provides random but 911 short passwords, the password is often combined with a personal 912 identification number (PIN). The password and the PIN can be 913 combined using KRB-FX-CF1(). 914 915 KRB-FX-CF2() combines two protocol keys based on the pseudo-random() 916 function defined in [RFC3961]. 917 918 Given two input keys, K1 and K2, where K1 and K2 can be of two 919 different enctypes, the output key of KRB-FX-CF2(), K3, is derived as 920 follows: 921 922 KRB-FX-CF2(protocol key, protocol key, octet string, 923 octet string) -> (protocol key) 924 925 PRF+(K1, pepper1) -> octet-string-1 926 PRF+(K2, pepper2) -> octet-string-2 927 KRB-FX-CF2(K1, K2, pepper1, pepper2) -> 928 random-to-key(octet-string-1 ^ octet-string-2) 929 930 Where ^ denotes the exclusive-OR operation. PRF+() is defined as 931 follows: 932 933 PRF+(protocol key, octet string) -> (octet string) 934 935 PRF+(key, shared-info) -> pseudo-random( key, 1 || shared-info ) || 936 pseudo-random( key, 2 || shared-info ) || 937 pseudo-random( key, 3 || shared-info ) || ... 938 939 Here the counter value 1, 2, 3 and so on are encoded as a one-octet 940 integer. The pseudo-random() operation is specified by the enctype 941 of the protocol key. PRF+() uses the counter to generate enough bits 942 as needed by the random-to-key() [RFC3961] function for the 943 encryption type specified for the resulting key; unneeded bits are 944 removed from the tail. Unless otherwise specified, the resulting 945 enctype of KRB-FX-CF2 is the enctype of k1. 946 947 Mechanism designers MUST specify the values for the input parameter 948 949 950 951Hartman & Zhu Expires August 15, 2009 [Page 17] 952 953Internet-Draft Kerberos Preauth Framework February 2009 954 955 956 pepper1 and pepper2 when combining two keys using KRB-FX-CF2(). The 957 pepper1 and pepper2 MUST be distinct so that if the two keys being 958 combined are the same, the resulting key is not a trivial key. 959 9606.2. Protecting Requests/Responses 961 962 Mechanism designers SHOULD protect clear text portions of pre- 963 authentication data. Various denial of service attacks and downgrade 964 attacks against Kerberos are possible unless plaintexts are somehow 965 protected against modification. An early design goal of Kerberos 966 Version 5 [RFC4120] was to avoid encrypting more of the 967 authentication exchange that was required. (Version 4 doubly- 968 encrypted the encrypted part of a ticket in a KDC reply, for 969 example.) This minimization of encryption reduces the load on the 970 KDC and busy servers. Also, during the initial design of Version 5, 971 the existence of legal restrictions on the export of cryptography 972 made it desirable to minimize of the number of uses of encryption in 973 the protocol. Unfortunately, performing this minimization created 974 numerous instances of unauthenticated security-relevant plaintext 975 fields. 976 977 If there is more than one round trip for an authentication exchange, 978 mechanism designers need to allow either the client or the KDC to 979 provide a checksum of all the messages exchanged on the wire in the 980 conversation, and the checksum is then verified by the receiver. 981 982 New mechanisms MUST NOT be hard-wired to use a specific algorithm. 983 984 Primitives defined in [RFC3961] are RECOMMENDED for integrity 985 protection and confidentiality. Mechanisms based on these primitives 986 are crypto-agile as the result of using [RFC3961] along with 987 [RFC4120]. The advantage afforded by crypto-agility is the ability 988 to incrementally deploy a fix specific to a particular algorithm thus 989 avoid a multi-year standardization and deployment cycle, when real 990 attacks do arise against that algorithm. 991 992 Note that data used by FAST factors (defined in Section 6.5) is 993 encrypted in a protected channel, thus they do not share the un- 994 authenticated-text issues with mechanisms designed as full-blown pre- 995 authentication mechanisms. 996 9976.3. Managing States for the KDC 998 999 Kerberos KDCs are stateless. There is no requirement that clients 1000 will choose the same KDC for the second request in a conversation. 1001 Proxies or other intermediate nodes may also influence KDC selection. 1002 So, each request from a client to a KDC must include sufficient 1003 information that the KDC can regenerate any needed state. This is 1004 1005 1006 1007Hartman & Zhu Expires August 15, 2009 [Page 18] 1008 1009Internet-Draft Kerberos Preauth Framework February 2009 1010 1011 1012 accomplished by giving the client a potentially long opaque cookie in 1013 responses to include in future requests in the same conversation. 1014 The KDC MAY respond that a conversation is too old and needs to 1015 restart by responding with a KDC_ERR_PREAUTH_EXPIRED error. 1016 1017 KDC_ERR_PREAUTH_EXPIRED TBA 1018 1019 When a client receives this error, the client SHOULD abort the 1020 existing conversation, and restart a new one. 1021 1022 An example, where more than one message from the client is needed, is 1023 when the client is authenticated based on a challenge-response 1024 scheme. In that case, the KDC needs to keep track of the challenge 1025 issued for a client authentication request. 1026 1027 The PA-FX-COOKIE padata type is defined in this section to facilitate 1028 state management. This padata is sent by the KDC when the KDC 1029 requires state for a future transaction. The client includes this 1030 opaque token in the next message in the conversation. The token may 1031 be relatively large; clients MUST be prepared for tokens somewhat 1032 larger than the size of all messages in a conversation. 1033 1034 PA-FX-COOKIE TBA 1035 -- Stateless cookie that is not tied to a specific KDC. 1036 1037 The corresponding padata-value field [RFC4120] contains an opaque 1038 token that will be echoed by the client in its response to an error 1039 from the KDC. 1040 1041 The cookie token is generated by the KDC and transmitted in a PA-FX- 1042 COOKIE pre-authentication data item of a KRB-ERROR message. The 1043 client MUST copy the exact cookie encapsulated in a PA-FX-COOKIE data 1044 element into the next message of the same conversation. The content 1045 of the cookie field is a local matter of the KDC. As a result, it is 1046 not generally possible to mix KDC implementations from different 1047 vendors in the same realm. However the KDC MUST construct the cookie 1048 token in such a manner that a malicious client cannot subvert the 1049 authentication process by manipulating the token. The KDC 1050 implementation needs to consider expiration of tokens, key rollover 1051 and other security issues in token design. The content of the cookie 1052 field is likely specific to the pre-authentication mechanisms used to 1053 authenticate the client. If a client authentication response can be 1054 replayed to multiple KDCs via the PA-FX-COOKIE mechanism, an 1055 expiration in the cookie is RECOMMENDED to prevent the response being 1056 presented indefinitely. 1057 1058 If at least one more message for a mechanism or a mechanism set is 1059 expected by the KDC, the KDC returns a 1060 1061 1062 1063Hartman & Zhu Expires August 15, 2009 [Page 19] 1064 1065Internet-Draft Kerberos Preauth Framework February 2009 1066 1067 1068 KDC_ERR_MORE_PREAUTH_DATA_NEEDED error with a PA-FX-COOKIE to 1069 identify the conversation with the client according to Section 3.2. 1070 The cookie is not expected to stay constant for a conversation: the 1071 KDC is expected to generate a new cookie for each message. 1072 1073 KDC_ERR_MORE_PREAUTH_DATA_NEEDED TBA 1074 10756.4. Pre-authentication Set 1076 1077 If all mechanisms in a group need to successfully complete in order 1078 to authenticate a client, the client and the KDC SHOULD use the PA- 1079 AUTHENTICATION-SET padata element. 1080 1081 PA-AUTHENTICATION-SET TBA 1082 1083 A PA-AUTHENTICATION-SET padata element contains the ASN.1 DER 1084 encoding of the PA-AUTHENTICATION-SET structure: 1085 1086 PA-AUTHENTICATION-SET ::= SEQUENCE OF PA-AUTHENTICATION-SET-ELEM 1087 1088 PA-AUTHENTICATION-SET-ELEM ::= SEQUENCE { 1089 pa-type [0] Int32, 1090 -- same as padata-type. 1091 pa-hint [1] OCTET STRING OPTIONAL, 1092 pa-value [2] OCTET STRING OPTIONAL, 1093 ... 1094 } 1095 1096 The pa-type field of the PA-AUTHENTICATION-SET-ELEM structure 1097 contains the corresponding value of padata-type in PA-DATA [RFC4120]. 1098 Associated with the pa-type is a pa-hint, which is an octet-string 1099 specified by the pre-authentication mechanism. This hint may provide 1100 information for the client which helps it determine whether the 1101 mechanism can be used. For example a public-key mechanism might 1102 include the certificate authorities it trusts in the hint info. Most 1103 mechanisms today do not specify hint info; if a mechanism does not 1104 specify hint info the KDC MUST NOT send a hint for that mechanism. 1105 To allow future revisions of mechanism specifications to add hint 1106 info, clients MUST ignore hint info received for mechanisms that the 1107 client believes do not support hint info. The pa-value element of 1108 the PA-AUTHENTICATION-SET-ELEM sequence is included to carry the 1109 first padata-value from the KDC to the client. If the client chooses 1110 this authentication set then the client MUST process this pa-value. 1111 The pa-value element MUST be absent for all but the first entry in 1112 the authentication set. Clients MUST ignore pa-value for the second 1113 and following entries in the authentication set. 1114 1115 If the client chooses an authentication set, then its first AS-REQ 1116 1117 1118 1119Hartman & Zhu Expires August 15, 2009 [Page 20] 1120 1121Internet-Draft Kerberos Preauth Framework February 2009 1122 1123 1124 message MUST contain a PA-AUTHENTICATION-SET-SELECTED padata element. 1125 This element contains the encoding of the PA-AUTHENTICATION-SET 1126 sequence received from the KDC corresponding to the authentication 1127 set that is chosen. The client MUST use the same octet values 1128 received from the KDC; it cannot re-encode the sequence. This allows 1129 KDCs to use bit-wise comparison to identify the selected 1130 authentication set. The PA-AUTHENTICATION-SET-SELECTED padata 1131 element MUST come before any padata elements from the authentication 1132 set in the padata sequence in the AS-REQ message. The client MAY 1133 cache authentication sets from prior messages and use them to 1134 construct an optimistic initial AS-REQ. If the KDC receives a PA- 1135 AUTHENTICATION-SET-SELECTED padata element that does not correspond 1136 to an authentication set that it would offer, then the KDC returns 1137 the KDC_ERR_PREAUTH_BAD_AUTHENTICATION_SET error. The e-data in this 1138 error contains a sequence of padata just as for the 1139 KDC_ERR_PREAUTH_REQUIRED error. 1140 1141 1142 PA-AUTHENTICATION-SET-SELECTED TBA 1143 KDC_ERR_PREAUTH_BAD_AUTHENTICATION_SET TBA 1144 1145 The PA-AUTHENTICATION-SET appears only in the first message from the 1146 KDC to the client. In particular, the client MAY fail if the 1147 authentication mechanism sets change as the conversation progresses. 1148 Clients MAY assume that the hints provided in the authentication set 1149 contain enough information that the client knows what user interface 1150 elements need to be displayed during the entire authentication 1151 conversation. Exceptional circumstances such as expired passwords or 1152 expired accounts may require that additional user interface be 1153 displayed. Mechanism designers need to carefully consider the design 1154 of their hints so that the client has this information. This way, 1155 clients can construct necessary dialogue boxes or wizards based on 1156 the authentication set and can present a coherent user interface. 1157 Current standards for user interface do not provide an acceptable 1158 experience when the client has to ask additional questions later in 1159 the conversation. 1160 1161 When indicating which sets of pre-authentication mechanisms are 1162 supported, the KDC includes a PA-AUTHENTICATION-SET padata element 1163 for each pre-authentication mechanism set. 1164 1165 The client sends the padata-value for the first mechanism it picks in 1166 the pre-authentication set, when the first mechanism completes, the 1167 client and the KDC will proceed with the second mechanism, and so on 1168 until all mechanisms complete successfully. The PA-FX-COOKIE as 1169 defined in Section 6.3 MUST be sent by the KDC so that the 1170 conversation can continue if the conversation involves multiple KDCs. 1171 The cookie may not be needed in the first message containing the PA- 1172 1173 1174 1175Hartman & Zhu Expires August 15, 2009 [Page 21] 1176 1177Internet-Draft Kerberos Preauth Framework February 2009 1178 1179 1180 AUTHENTICATION-SET sequence as the KDC may be able to reconstruct the 1181 state from the PA-AUTHENTICATION-SET-SELECTED padata. KDCs MUST 1182 support clients that do not include a cookie because they 1183 optimistically choose an authentication set, although they MAY always 1184 return KDC_ERR_PREAUTH_BAD_AUTHENTICATION_SET and include a cookie in 1185 that message. Clients that support PA-AUTHENTICATION-SET MUST 1186 support PA-FX-COOKIE. 1187 1188 Before the authentication succeeds and a ticket is returned, the 1189 message that the client sends is an AS_REQ and the message that the 1190 KDC sends is a KRB-ERROR message. The error code in the KRB-ERROR 1191 message from the KDC is KDC_ERR_MORE_PREAUTH_DATA_NEEDED as defined 1192 in Section 6.3 and the accompanying e-data contains the DER encoding 1193 of ASN.1 type METHOD-DATA. The KDC includes the padata elements in 1194 the METHOD-DATA. If there is no padata, the e-data field is absent 1195 in the KRB-ERROR message. 1196 1197 If the client sends the last message for a given mechanism, then the 1198 KDC sends the first message for the next mechanism. If the next 1199 mechanism does not start with a KDC-side challenge, then the KDC 1200 includes a padata item with the appropriate pa-type and an empty pa- 1201 data. 1202 1203 If the KDC sends the last message for a particular mechanism, the KDC 1204 also includes the first padata for the next mechanism. 1205 12066.5. Definition of Kerberos FAST Padata 1207 1208 As described in [RFC4120], Kerberos is vulnerable to offline 1209 dictionary attacks. An attacker can request an AS-REP and try 1210 various passwords to see if they can decrypt the resulting ticket. 1211 RFC 4120 provides the encrypted timestamp pre-authentication method 1212 that ameliorates the situation somewhat by requiring that an attacker 1213 observe a successful authentication. However stronger security is 1214 desired in many environments. The Kerberos FAST pre-authentication 1215 padata defined in this section provides a tool to significantly 1216 reduce vulnerability to offline dictionary attack. When combined 1217 with encrypted challenge, FAST requires an attacker to mount a 1218 successful man-in-the-middle attack to observe ciphertext. When 1219 combined with host keys, FAST can even protect against active 1220 attacks. FAST also provides solutions to common problems for pre- 1221 authentication mechanisms such as binding of the request and the 1222 reply, freshness guarantee of the authentication. FAST itself, 1223 however, does not authenticate the client or the KDC, instead, it 1224 provides a typed hole to allow pre-authentication data be tunneled. 1225 A pre-authentication data element used within FAST is called a FAST 1226 factor. A FAST factor captures the minimal work required for 1227 extending Kerberos to support a new pre-authentication scheme. 1228 1229 1230 1231Hartman & Zhu Expires August 15, 2009 [Page 22] 1232 1233Internet-Draft Kerberos Preauth Framework February 2009 1234 1235 1236 A FAST factor MUST NOT be used outside of FAST unless its 1237 specification explicitly allows so. The typed holes in FAST messages 1238 can also be used as generic holes for other padata that are not 1239 intended to prove the client's identity, or establish the reply key. 1240 1241 New pre-authentication mechanisms SHOULD be designed as FAST factors, 1242 instead of full-blown pre-authentication mechanisms. 1243 1244 FAST factors that are pre-authentication mechanisms MUST meet the 1245 requirements in Section 5. 1246 1247 FAST employs an armoring scheme. The armor can be a Ticket Granting 1248 Ticket (TGT) obtained by the client's machine using the host keys to 1249 pre-authenticate with the KDC, or an anonymous TGT obtained based on 1250 anonymous PKINIT [KRB-ANON] [RFC4556]. 1251 1252 The rest of this section describes the types of armors and the syntax 1253 of the messages used by FAST. Conforming implementations MUST 1254 support Kerberos FAST padata. 1255 1256 Any FAST armor scheme MUST provide a fresh armor key for each 1257 conversation. Clients and KDCs can assume that if a message is 1258 encrypted and integrity protected with a given armor key then it is 1259 part of the conversation using that armor key. 1260 1261 All KDCs in a realm MUST support FAST if FAST is offered by any KDC 1262 as a pre-authentication mechanism. 1263 12646.5.1. FAST Armors 1265 1266 An armor key is used to encrypt pre-authentication data in the FAST 1267 request and the response. The KrbFastArmor structure is defined to 1268 identify the armor key. This structure contains the following two 1269 fields: the armor-type identifies the type of armors, and the armor- 1270 value is an OCTET STRING that contains the description of the armor 1271 scheme and the armor key. 1272 1273 KrbFastArmor ::= SEQUENCE { 1274 armor-type [0] Int32, 1275 -- Type of the armor. 1276 armor-value [1] OCTET STRING, 1277 -- Value of the armor. 1278 ... 1279 } 1280 1281 The value of the armor key is a matter of the armor type 1282 specification. Only one armor type is defined in this document. 1283 1284 1285 1286 1287Hartman & Zhu Expires August 15, 2009 [Page 23] 1288 1289Internet-Draft Kerberos Preauth Framework February 2009 1290 1291 1292 FX_FAST_ARMOR_AP_REQUEST 1 1293 1294 The FX_FAST_ARMOR_AP_REQUEST armor is based on Kerberos tickets. 1295 1296 Conforming implementations MUST implement the 1297 FX_FAST_ARMOR_AP_REQUEST armor type. 1298 1299 FAST implementations MUST maintain state about whether the armor 1300 mechanism authenticates the KDC. If it does not, then a fast factor 1301 that authenticates the KDC MUST be used if the reply key is replaced. 1302 13036.5.1.1. Ticket-based Armors 1304 1305 This is a ticket-based armoring scheme. The armor-type is 1306 FX_FAST_ARMOR_AP_REQUEST, the armor-value contains an ASN.1 DER 1307 encoded AP-REQ. The ticket in the AP-REQ is called an armor ticket 1308 or an armor TGT. The subkey field in the AP-REQ MUST be present. 1309 The armor key is defined by the following function: 1310 1311 armor_key = KRB-FX-CF2( subkey, ticket_session_key, 1312 "subkeyarmor", "ticketarmor" ) 1313 1314 The `ticket_key' is the session key from the ticket in the ap-req. 1315 The `subkey' is the ap-req subkey. This construction guarantees that 1316 both the KDC (through the session key) and the client (through the 1317 subkey) contribute to the armor key. 1318 1319 The server name field of the armor ticket MUST identify the TGS of 1320 the target realm. Here are three common ways in the decreasing 1321 preference order how an armor TGT SHOULD be obtained: 1322 1323 1. If the client is authenticating from a host machine whose 1324 Kerberos realm has an authentication path to the client's realm, 1325 the host machine obtains a TGT by using the host keys. If the 1326 client's realm is different than the realm of the local host, the 1327 machine then obtains a cross-realm TGT to the client's realm as 1328 the armor ticket. Otherwise, the host's primary TGT is the armor 1329 ticket. 1330 1331 2. If the client's host machine cannot obtain a host ticket strictly 1332 based on RFC4120, but the KDC has an asymmetric signing key whose 1333 binding with the expected KDC can be verified by the client, the 1334 client can use anonymous PKINIT [KRB-ANON] [RFC4556] to 1335 authenticate the KDC and obtain an anonymous TGT as the armor 1336 ticket. The armor ticket can also be a cross-realm TGT obtained 1337 based on the initial primary TGT obtained using anonymous PKINIT 1338 with KDC authentication. 1339 1340 1341 1342 1343Hartman & Zhu Expires August 15, 2009 [Page 24] 1344 1345Internet-Draft Kerberos Preauth Framework February 2009 1346 1347 1348 3. Otherwise, the client uses anonymous PKINIT to get an anonymous 1349 TGT without KDC authentication and that TGT is the armor ticket. 1350 Note that this mode of operation is vulnerable to man-in-the- 1351 middle attacks at the time of obtaining the initial anonymous 1352 armor TGT. 1353 1354 If anonymous PKINIT is used, The KDC cannot know whether its signing 1355 key can be verified by the client, hence the KDC MUST be marked as 1356 unverified from the KDC's point of view while the client could be 1357 able to authenticate the KDC by verifying the KDC's signing key is 1358 bound with the expected KDC. The client needs to carefully consider 1359 the risk and benefit tradeoffs associated with active attacks before 1360 exposing cipher text encrypted using the user's long-term secrets 1361 when the armor does not authenticate the KDC. 1362 1363 The TGS MUST reject a request if there is an AD-fx-fast-armor (TBD) 1364 element in the authenticator of the pa-tgs-req padata or if the 1365 ticket in the authenticator of a pa-tgs-req contains the AD-fx-fast- 1366 armor authorization data element. These tickets and authenticators 1367 MAY be used as FAST armor tickets but not to obtain a ticket via the 1368 TGS. This authorization data is used in a system where the 1369 encryption of the user's pre-authentication data is performed in an 1370 unprivileged user process. A privileged process can provide to the 1371 user process a host ticket, an authenticator for use with that 1372 ticket, and the sub session key contained in the authenticator. In 1373 order for the host process to ensure that the host ticket is not 1374 accidentally or intentionally misused, (i.e. the user process might 1375 use the host ticket to authenticate as the host), it MUST include a 1376 critical authorization data element of the type AD-fx-fast-armor when 1377 providing the authenticator or in the enc-authorization-data field of 1378 the TGS request used to obtain the TGT. The corresponding ad-data 1379 field of the AD-fx-fast-armor element is empty. 1380 1381 As discussed previously, the server of an armor ticket MUST be the 1382 TGS of the realm from whom service is requested. As a result, if 1383 this armor type is used when a ticket is being validated, proxied, or 1384 in other cases where a ticket other than a TGT is presented to the 1385 TGS, a TGT will be used as an armor ticket, while another ticket will 1386 be used in the pa-tgs-req authenticator. 1387 13886.5.2. FAST Request 1389 1390 A padata type PA-FX-FAST is defined for the Kerberos FAST pre- 1391 authentication padata. The corresponding padata-value field 1392 [RFC4120] contains the DER encoding of the ASN.1 type PA-FX-FAST- 1393 REQUEST. As with all pre-authentication types, the KDC SHOULD 1394 advertise PA-FX-FAST with an empty pa-value in a PREAUTH_REQUIRED 1395 error. Clients MUST ignore the pa-value of PA-FX-FAST in an initial 1396 1397 1398 1399Hartman & Zhu Expires August 15, 2009 [Page 25] 1400 1401Internet-Draft Kerberos Preauth Framework February 2009 1402 1403 1404 PREAUTH_REQUIRED error. FAST is not expected to be used in an 1405 authentication set: clients will typically use FAST padata if 1406 available and this decision should not depend on what other pre- 1407 authentication methods are available. As such, no pa-hint is defined 1408 for FAST at this time. 1409 1410 PA-FX-FAST TBA 1411 -- Padata type for Kerberos FAST 1412 1413 PA-FX-FAST-REQUEST ::= CHOICE { 1414 armored-data [0] KrbFastArmoredReq, 1415 ... 1416 } 1417 1418 KrbFastArmoredReq ::= SEQUENCE { 1419 armor [0] KrbFastArmor OPTIONAL, 1420 -- Contains the armor that identifies the armor key. 1421 -- MUST be present in AS-REQ. 1422 req-checksum [1] Checksum, 1423 -- Checksum performed over the type KDC-REQ-BODY for 1424 -- the req-body field of the KDC-REQ structure defined in 1425 -- [RFC4120] 1426 -- The checksum key is the armor key, the checksum 1427 -- type is the required checksum type for the enctype of 1428 -- the armor key, and the key usage number is 1429 -- KEY_USAGE_FAST_REQ_CHKSUM. 1430 enc-fast-req [2] EncryptedData, -- KrbFastReq -- 1431 -- The encryption key is the armor key, and the key usage 1432 -- number is KEY_USAGE_FAST_ENC. 1433 ... 1434 } 1435 1436 KEY_USAGE_FAST_REQ_CHKSUM TBA 1437 KEY_USAGE_FAST_ENC TBA 1438 1439 The PA-FX-FAST-REQUEST structure contains a KrbFastArmoredReq type. 1440 The KrbFastArmoredReq encapsulates the encrypted padata. 1441 1442 The enc-fast-req field contains an encrypted KrbFastReq structure. 1443 The armor key is used to encrypt the KrbFastReq structure, and the 1444 key usage number for that encryption is KEY_USAGE_FAST_ENC. 1445 1446 The armor key is selected as follows: 1447 1448 o In an AS request, the armor field in the KrbFastArmoredReq 1449 structure MUST be present and the armor key is identified 1450 according to the specification of the armor type. 1451 1452 1453 1454 1455Hartman & Zhu Expires August 15, 2009 [Page 26] 1456 1457Internet-Draft Kerberos Preauth Framework February 2009 1458 1459 1460 o There are two possibilities for armor for a TGS request. If the 1461 ticket presented in the PA-TGS-REQ authenticator is a TGT, then 1462 the client SHOULD not include the armor field in the Krbfastreq 1463 and a subkey MUST be included in the PA-TGS-REQ authenticator. In 1464 this case, the armor key is the same armor key that would be 1465 computed if the TGS-REQ authenticator was used in a 1466 FX_FAST_ARMOR_AP_REQUEST armor. If a ticket other than a TGT is 1467 being presented to the TGS, a client SHOULD use some form of FAST 1468 armor such as a ticket-based armor with a TGT as an armor ticket. 1469 Clients MAY present a non-TGT in the PA-TGS-REQ authenticator and 1470 omit the armor field, in which case the armor key is the same that 1471 would be computed if the authenticator were used in a 1472 FX_FAST_ARMOR_AP_REQUEST armor. This is the only case where a 1473 ticket other than a TGT can be used to establish an armor key; 1474 even though the armor key is computed the same as a 1475 FX_FAST_ARMOR_AP_REQUEST, a non-TGT cannot be used as an armor 1476 ticket in FX_FAST_ARMOR_AP_REQUEST. 1477 1478 The req-checksum field contains a checksum that is performed over the 1479 type KDC-REQ-BODY for the req-body field of the KDC-REQ [RFC4120] 1480 structure of the containing message. The checksum key is the armor 1481 key, and the checksum type is the required checksum type for the 1482 enctype of the armor key per [RFC3961]. This checksum is included in 1483 order to bind the FAST padata to the outer request. A KDC that 1484 implements FAST will ignore the outer request, but including a 1485 checksum is relatively cheap and may prevent confusing behavior. 1486 1487 The KrbFastReq structure contains the following information: 1488 1489 KrbFastReq ::= SEQUENCE { 1490 fast-options [0] FastOptions, 1491 -- Additional options. 1492 padata [1] SEQUENCE OF PA-DATA, 1493 -- padata typed holes. 1494 req-body [2] KDC-REQ-BODY, 1495 -- Contains the KDC request body as defined in Section 1496 -- 5.4.1 of [RFC4120]. 1497 -- This req-body field is preferred over the outer field 1498 -- in the KDC request. 1499 ... 1500 } 1501 1502 The fast-options field indicates various options that are to modify 1503 the behavior of the KDC. The following options are defined: 1504 1505 FastOptions ::= KerberosFlags 1506 -- reserved(0), 1507 -- hide-client-names(1), 1508 1509 1510 1511Hartman & Zhu Expires August 15, 2009 [Page 27] 1512 1513Internet-Draft Kerberos Preauth Framework February 2009 1514 1515 1516 -- kdcfollow--referrals(16) 1517 1518 1519 Bits Name Description 1520 ----------------------------------------------------------------- 1521 0 RESERVED Reserved for future expansion of this 1522 field. 1523 1 hide-client-names Requesting the KDC to hide client 1524 names in the KDC response, as 1525 described next in this section. 1526 16 kdc-follow-referrals Requesting the KDC to follow referrals. 1527 1528 Bits 1 through 15 inclusive (with bit 1 and bit 15 included) are 1529 critical options. If the KDC does not support a critical option, it 1530 MUST fail the request with KDC_ERR_UNKNOWN_CRITICAL_FAST_OPTIONS, and 1531 there is no accompanying e-data defined in this document for this 1532 error code. Bit 16 and onward (with bit 16 included) are non- 1533 critical options. KDCs conforming to this specification ignore 1534 unknown non-critical options. 1535 1536 KDC_ERR_UNKNOWN_FAST_OPTIONS TBA 1537 1538 The hide-client-names Option 1539 1540 The Kerberos response defined in [RFC4120] contains the client 1541 identity in clear text, This makes traffic analysis 1542 straightforward. The hide-client-names option is designed to 1543 complicate traffic analysis. If the hide-client-names option is 1544 set, the KDC implementing PA-FX-FAST MUST identify the client as 1545 the anonymous principal [KRB-ANON] in the KDC reply and the error 1546 response. Hence this option is set by the client if it wishes to 1547 conceal the client identity in the KDC response. A conforming KDC 1548 ignores the client principal name in the outer KDC-REQ-BODY field, 1549 and identifies the client using the cname and crealm fields in the 1550 req-body field of the KrbFastReq structure. 1551 1552 The kdc-follow-referrals Option 1553 1554 The Kerberos client described in [RFC4120] has to request referral 1555 TGTs along the authentication path in order to get a service 1556 ticket for the target service. The Kerberos client described in 1557 the [REFERRALS] needs to contact the AS specified in the error 1558 response in order to complete client referrals. The kdc-follow- 1559 referrals option is designed to minimize the number of messages 1560 that need to be processed by the client. This option is useful 1561 when, for example, the client may contact the KDC via a satellite 1562 link that has high network latency, or the client has limited 1563 computational capabilities. If the kdc-follow-referrals option is 1564 1565 1566 1567Hartman & Zhu Expires August 15, 2009 [Page 28] 1568 1569Internet-Draft Kerberos Preauth Framework February 2009 1570 1571 1572 set, the KDC MAY act as the client to follow TGS referrals 1573 [REFERRALS], and return the service ticket to the named server 1574 principal in the client request using the reply key expected by 1575 the client. That is, rather than returning a referral, the KDC 1576 follows that referral by contacting a remote KDC and processing 1577 the referral. The kdc-referrals option can be implemented when 1578 the KDC knows the reply key. The KDC can ignore kdc-referrals 1579 option when it does not understand it or it does not allow this 1580 option based on local policy. The client SHOULD be capable of 1581 processing the KDC responses when this option is not honored by 1582 the KDC. Clients SHOULD use TCP to contact a KDC if this option 1583 is going to be used to avoid problems when the client's UDP 1584 retransmit algorithm has timeouts insufficient to allow the KDC to 1585 interact with remote KDCs. 1586 1587 The padata field contains a list of PA-DATA structures as described 1588 in Section 5.2.7 of [RFC4120]. These PA-DATA structures can contain 1589 FAST factors. They can also be used as generic typed-holes to 1590 contain data not intended for proving the client's identity or 1591 establishing a reply key, but for protocol extensibility. 1592 1593 The KDC-REQ-BODY in the FAST structure is used in preference to the 1594 KDC-REQ-BODY outside of the FAST pre-authentication. The outer KDC- 1595 REQ-BODY structure SHOULD be filled in for backwards compatibility 1596 with KDCs that do not support FAST. A conforming KDC ignores the 1597 outer KDC-REQ-BODY field in the KDC request. However pre- 1598 authentication data methods such as [RFC4556] that include a checksum 1599 of the KDC-REQ-BODY should checksum the outer KDC-REQ-BODY. These 1600 methods will already be bound to the inner body through the integrity 1601 protection in the FAST request. 1602 16036.5.3. FAST Response 1604 1605 The KDC that supports the PA-FX-FAST padata MUST include a PA-FX-FAST 1606 padata element in the KDC reply. In the case of an error, the PA-FX- 1607 FAST padata is included in the KDC responses according to 1608 Section 6.5.4. 1609 1610 The corresponding padata-value field [RFC4120] for the PA-FX-FAST in 1611 the KDC response contains the DER encoding of the ASN.1 type PA-FX- 1612 FAST-REPLY. 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623Hartman & Zhu Expires August 15, 2009 [Page 29] 1624 1625Internet-Draft Kerberos Preauth Framework February 2009 1626 1627 1628 PA-FX-FAST-REPLY ::= CHOICE { 1629 armored-data [0] KrbFastArmoredRep, 1630 ... 1631 } 1632 1633 KrbFastArmoredRep ::= SEQUENCE { 1634 enc-fast-rep [0] EncryptedData, -- KrbFastResponse -- 1635 -- The encryption key is the armor key in the request, and 1636 -- the key usage number is KEY_USAGE_FAST_REP. 1637 ... 1638 } 1639 KEY_USAGE_FAST_REP TBA 1640 1641 The PA-FX-FAST-REPLY structure contains a KrbFastArmoredRep 1642 structure. The KrbFastArmoredRep structure encapsulates the padata 1643 in the KDC reply in the encrypted form. The KrbFastResponse is 1644 encrypted with the armor key used in the corresponding request, and 1645 the key usage number is KEY_USAGE_FAST_REP. 1646 1647 The Kerberos client who does not receive a PA-FX-FAST-REPLY in the 1648 KDC response MUST support a local policy that rejects the response. 1649 Clients MAY also support policies that fall back to other mechanisms 1650 or that do not use pre-authentication when FAST is unavailable. It 1651 is important to consider the potential downgrade attacks when 1652 deploying such a policy. 1653 1654 The KrbFastResponse structure contains the following information: 1655 1656 KrbFastResponse ::= SEQUENCE { 1657 padata [0] SEQUENCE OF PA-DATA, 1658 -- padata typed holes. 1659 rep-key [1] EncryptionKey OPTIONAL, 1660 -- This, if present, replaces the reply key for AS and TGS. 1661 -- MUST be absent in KRB-ERROR. 1662 finished [2] KrbFastFinished OPTIONAL, 1663 -- MUST be present if the client is authenticated, 1664 -- absent otherwise. 1665 -- Typically this is present if and only if the containing 1666 -- message is the last one in a conversation. 1667 ... 1668 } 1669 1670 The padata field in the KrbFastResponse structure contains a list of 1671 PA-DATA structures as described in Section 5.2.7 of [RFC4120]. These 1672 PA-DATA structures are used to carry data advancing the exchange 1673 specific for the FAST factors. They can also be used as generic 1674 typed-holes for protocol extensibility. Unless otherwise specified, 1675 the KDC MUST include any padata otherwise in the outer KDC reply into 1676 1677 1678 1679Hartman & Zhu Expires August 15, 2009 [Page 30] 1680 1681Internet-Draft Kerberos Preauth Framework February 2009 1682 1683 1684 this field. The padata field in the KDC reply structure outside of 1685 the PA-FX-FAST-REPLY structure typically includes only the PA-FX- 1686 FAST-REPLY padata and optionally the PA-FX-COOKIE padata. 1687 1688 The rep-key field, if present, contains the reply key that is used to 1689 encrypted the KDC reply. The rep-key field MUST be absent in the 1690 case where an error occurs. The enctype of the rep-key is the 1691 strongest mutually supported by the KDC and the client. 1692 1693 The finished field contains a KrbFastFinished structure. It is 1694 filled by the KDC in the final message in the conversation; it MUST 1695 be absent otherwise. In other words, this field can only be present 1696 in an AS-REP or a TGS-REP when a ticket is returned. 1697 1698 The KrbFastFinished structure contains the following information: 1699 1700 KrbFastFinished ::= SEQUENCE { 1701 timestamp [0] KerberosTime, 1702 usec [1] Microseconds, 1703 -- timestamp and usec represent the time on the KDC when 1704 -- the reply was generated. 1705 crealm [2] Realm, 1706 cname [3] PrincipalName, 1707 -- Contains the client realm and the client name. 1708 checksum [4] Checksum, 1709 -- Checksum performed over all the messages in the 1710 -- conversation, except the containing message. 1711 -- The checksum key is the armor key as defined in 1712 -- Section 6.5.1, and the checksum type is the required 1713 -- checksum type of the armor key. 1714 ticket-checksum [5] Checksum, 1715 -- checksum of the ticket in the KDC-REP using the armor 1716 -- and the key usage is KEY_USAGE_FAST_FINISH. 1717 -- The checksum type is the required checksum type 1718 -- of the armor key. 1719 ... 1720 } 1721 KEY_USAGE_FAST_FINISHED TBA 1722 1723 The timestamp and usec fields represent the time on the KDC when the 1724 reply ticket was generated, these fields have the same semantics as 1725 the corresponding-identically-named fields in Section 5.6.1 of 1726 [RFC4120]. The client MUST use the KDC's time in these fields 1727 thereafter when using the returned ticket. Note that the KDC's time 1728 in AS-REP may not match the authtime in the reply ticket if the kdc- 1729 follow-referrals option is requested and honored by the KDC. The 1730 client need not confirm that the timestamp returned is within 1731 allowable clock skew: the armor key guarantees that the reply is 1732 1733 1734 1735Hartman & Zhu Expires August 15, 2009 [Page 31] 1736 1737Internet-Draft Kerberos Preauth Framework February 2009 1738 1739 1740 fresh. The client MAY trust the time stamp returned. 1741 1742 The cname and crealm fields identify the authenticated client. If 1743 facilities described in [REFERRALS] are used, the authenticated 1744 client may differ from the client in the FAST request. 1745 1746 The checksum field contains a checksum of all the messages in the 1747 conversation prior to the containing message (the containing message 1748 is excluded). The checksum key is the armor key, and the checksum 1749 type is the required checksum type of the enctype of that key, and 1750 the key usage number is KEY_USAGE_FAST_FINISHED. The ticket-checksum 1751 is a checksum of the issued ticket using the same key and key usage. 1752 1753 When FAST padata is included, the PA-FX-COOKIE padata as defined in 1754 Section 6.3 MUST also be included if the KDC expects at least one 1755 more message from the client in order to complete the authentication. 1756 17576.5.4. Authenticated Kerberos Error Messages using Kerberos FAST 1758 1759 If the Kerberos FAST padata was included in the request, unless 1760 otherwise specified, the e-data field of the KRB-ERROR message 1761 [RFC4120] contains the ASN.1 DER encoding of the type METHOD-DATA 1762 [RFC4120] and a PA-FX-FAST is included in the METHOD-DATA. The KDC 1763 MUST include all the padata elements such as PA-ETYPE-INFO2 and 1764 padata elements that indicate acceptable pre-authentication 1765 mechanisms [RFC4120] in the KrbFastResponse structure. 1766 1767 The KDC MUST also include a PA-FX-ERROR padata item in the 1768 KRBFastResponse structure. The padata-value element of this sequence 1769 is the ASN.1 DER encoding of the type KRB-ERROR. The e-data field 1770 MUST be absent in the PA-FX-ERROR padata. All other fields should be 1771 the same as the outer KRB-ERROR. The client ignores the outer error 1772 and uses the combination of the padata in the KRBFastResponse and the 1773 error information in the PA-FX-ERROR. 1774 1775 PA-FX-ERROR TBA 1776 1777 If the Kerberos FAST padata is included in the request but not 1778 included in the error reply, it is a matter of the local policy on 1779 the client to accept the information in the error message without 1780 integrity protection. The Kerberos client MAY process an error 1781 message without a PA-FX-FAST-REPLY, if that is only intended to 1782 return better error information to the application, typically for 1783 trouble-shooting purposes. 1784 1785 In the cases where the e-data field of the KRB-ERROR message is 1786 expected to carry a TYPED-DATA [RFC4120] element, then that 1787 information should be transmitted in a pa-data element within the 1788 1789 1790 1791Hartman & Zhu Expires August 15, 2009 [Page 32] 1792 1793Internet-Draft Kerberos Preauth Framework February 2009 1794 1795 1796 KRBFastResponse structure. The padata-type is the same as the data- 1797 type would be in the typed data element and the padata-value is the 1798 same as the data-value. As discussed in Section 8, data-types and 1799 padata-types are drawn from the same namespace. For example, the 1800 TD_TRUSTED_CERTIFIERS structure is expected to be in the KRB-ERROR 1801 message when the error code is KDC_ERR_CANT_VERIFY_CERTIFICATE 1802 [RFC4556]. 1803 18046.5.5. Outer and Inner Requests 1805 1806 Typically, a client will know that FAST is being used before a 1807 request containing PA-FX-FAST is sent. So, the outer AS request 1808 typically only includes two pa-data items: PA-FX-FAST and PA-FX- 1809 COOKIE. The client MAY include additional pa-data, but the KDC MUST 1810 ignore the outer request body and any padata besides PA-FX-FAST and 1811 PA-FX-COOKIE if PA-FX-FAST is processed. In the case of the TGS 1812 request, the outer request should include PA-FX-FAST and PA-TGS-REQ. 1813 1814 When an AS generates a response, all padata besides PA-FX-FAST and 1815 PA-FX-COOKIE should be included in PA-FX-FAST. The client MUST 1816 ignore other padata outside of PA-FX-FAST. 1817 18186.5.6. The Encrypted Challenge FAST Factor 1819 1820 The encrypted challenge FAST factor authenticates a client using the 1821 client's long-term key. This factor works similarly to the encrypted 1822 time stamp pre-authentication option described in [RFC4120]. The 1823 client encrypts a structure containing a timestamp in the challenge 1824 key. The challenge key used by the client to send a message to the 1825 KDC is KRB-FX-CF2(armor_key,long_term_key, "clientchallengearmor", 1826 "challengelongterm"). The challenge key used by the KDC encrypting 1827 to the client is KRB-FX-CF2(armor_key, long_term_key, 1828 "kdcchallengearmor", "challengelongterm"). Because the armor key is 1829 fresh and random, the challenge key is fresh and random. The only 1830 purpose of the timestamp is to limit the validity of the 1831 authentication so that a request cannot be replayed. A client MAY 1832 base the timestamp on the KDC time in a KDC error and need not 1833 maintain accurate time synchronization itself. If a client bases its 1834 time on an untrusted source, an attacker may trick the client into 1835 producing an authentication request that is valid at some future 1836 time. The attacker may be able to use this authentication request to 1837 make it appear that a client has authenticated at that future time. 1838 If ticket-based armor is used, then the lifetime of the ticket will 1839 limit the window in which an attacker can make the client appear to 1840 have authenticated. For many situations, the ability of an attacker 1841 to cause a client to appear to have authenticated is not a 1842 significant concern; the ability to avoid requiring time 1843 synchronization on clients is more valuable. 1844 1845 1846 1847Hartman & Zhu Expires August 15, 2009 [Page 33] 1848 1849Internet-Draft Kerberos Preauth Framework February 2009 1850 1851 1852 The client sends a padata of type PA-ENCRYPTED-CHALLENGE the 1853 corresponding padata-value contains the DER encoding of ASN.1 type 1854 EncryptedChallenge. 1855 1856 EncryptedChallenge ::= EncryptedData 1857 -- Encrypted PA-ENC-TS-ENC, encrypted in the challenge key 1858 -- using key usage KEY_USAGE_ENC_CHALLENGE_CLIENT for the 1859 -- client and KEY_USAGE_ENC_CHALLENGE_KDC for the KDC. 1860 1861 PA-ENCRYPTED-CHALLENGE TBA 1862 KEY_USAGE_ENC_CHALLENGE_CLIENT TBA 1863 KEY_USAGE_ENC_CHALLENGE_KDC TBA 1864 1865 The client includes some time stamp reasonably close to the KDC's 1866 current time and encrypts it in the challenge key. Clients MAY use 1867 the current time; doing so prevents the exposure where an attacker 1868 can cause a client to appear to authenticate in the future. The 1869 client sends the request including this factor. 1870 1871 On receiving an AS-REQ containing the PA-ENCRYPTED-CHALLENGE fast 1872 factor, the KDC decrypts the timestamp. If the decryption fails the 1873 KDC SHOULD return KDC_ERR_PREAUTH_FAILED, including PA-ETYPE-INFO2 in 1874 the KRBFastResponse in the error. The KDC confirms that the 1875 timestamp falls within its current clock skew returning 1876 KRB_APP_ERR_SKEW if not. The KDC then SHOULD check to see if the 1877 encrypted challenge is a replay. The KDC MUST NOT consider two 1878 encrypted challenges replays simply because the time stamps are the 1879 same; to be a replay, the ciphertext MUST be identical. Allowing 1880 clients to re-use time stamps avoids requiring that clients maintain 1881 state about which time stamps have been used. 1882 1883 If the KDC accepts the encrypted challenge, it MUST include a padata 1884 element of type PA-ENCRYPTED-CHALLENGE. The KDC encrypts its current 1885 time in the challenge key. The KDC MUST replace the reply key before 1886 issuing a ticket. The client MUST check that the timestamp decrypts 1887 properly. The client MAY check that the timestamp is winthin the 1888 window of acceptable clock skew for the client. The client MUST NOT 1889 require that the timestamp be identical to the timestamp in the 1890 issued credentials or the returned message. 1891 1892 The encrypted challenge FAST factor provides the following 1893 facilities: client-authentication and KDC authentication. This FAST 1894 factor also takes advantage of the FAST facility to replace the reply 1895 key. It does not provide the strengthening-reply-key facility. The 1896 security considerations section of this document provides an 1897 explanation why the security requirements are met. 1898 1899 The encrypted challenge FAST factor can be useful in an 1900 1901 1902 1903Hartman & Zhu Expires August 15, 2009 [Page 34] 1904 1905Internet-Draft Kerberos Preauth Framework February 2009 1906 1907 1908 authentication set. No pa-hint is defined because the only 1909 information needed by this mechanism is information contained in the 1910 PA-ETYPE-INFO2 pre-authentication data. KDCs are already required to 1911 send PA-ETYPE-INFO2. If KDCs were not required to send PA-ETYPE- 1912 INFO2 then that information would need to be part of a hint for 1913 encrypted challenge. 1914 1915 Conforming implementations MUST support the encrypted challenge FAST 1916 factor. 1917 19186.6. Authentication Strength Indication 1919 1920 Implementations that have pre-authentication mechanisms offering 1921 significantly different strengths of client authentication MAY choose 1922 to keep track of the strength of the authentication used as an input 1923 into policy decisions. For example, some principals might require 1924 strong pre-authentication, while less sensitive principals can use 1925 relatively weak forms of pre-authentication like encrypted timestamp. 1926 1927 An AuthorizationData data type AD-Authentication-Strength is defined 1928 for this purpose. 1929 1930 AD-authentication-strength TBA 1931 1932 The corresponding ad-data field contains the DER encoding of the pre- 1933 authentication data set as defined in Section 6.4. This set contains 1934 all the pre-authentication mechanisms that were used to authenticate 1935 the client. If only one pre-authentication mechanism was used to 1936 authenticate the client, the pre-authentication set contains one 1937 element. 1938 1939 The AD-authentication-strength element MUST be included in the AD-IF- 1940 RELEVANT, thus it can be ignored if it is unknown to the receiver. 1941 1942 19437. Assigned Constants 1944 1945 The pre-authentication framework and FAST involve using a number of 1946 Kerberos protocol constants. This section lists protocol constants 1947 first introduced in this specification drawn from registries not 1948 managed by IANA. Many of these registries would best be managed by 1949 IANA; that is a known issue that is out of scope for this document. 1950 The constants described in this section have been accounted for and 1951 will appear in the next revision of the Kerberos core specification 1952 or in a document creating IANA registries. 1953 1954 Section 8 creates IANA registries for a different set of constants 1955 used by the extensions described in this document. 1956 1957 1958 1959Hartman & Zhu Expires August 15, 2009 [Page 35] 1960 1961Internet-Draft Kerberos Preauth Framework February 2009 1962 1963 19647.1. New Errors 1965 1966 KDC_ERR_PREAUTH_EXPIRED TBA 1967 KDC_ERR_MORE_PREAUTH_DATA_NEEDED TBA 1968 KDC_ERR_PREAUTH_BAD_AUTHENTICATION_SET TBA 1969 KDC_ERR_UNKNOWN_FAST_OPTIONS TBA 1970 19717.2. Key Usage Numbers 1972 1973 KEY_USAGE_FAST_REQ_CHKSUM TBA 1974 KEY_USAGE_FAST_ENC TBA 1975 KEY_USAGE_FAST_REP TBA 1976 KEY_USAGE_FAST_FINISHED TBA 1977 KEY_USAGE_ENC_CHALLENGE_CLIENT TBA 1978 KEY_USAGE_ENC_CHALLENGE_KDC TBA 1979 19807.3. Authorization Data Elements 1981 1982 AD-authentication-strength TBA 1983 AD-fx-fast-armor TBA 1984 19857.4. New PA-DATA Types 1986 1987 PA-FX-COOKIE TBA 1988 PA-AUTHENTICATION-SET TBA 1989 PA-AUTHENTICATION-SET-SELECTED TBA 1990 PA-FX-FAST TBA 1991 PA-FX-ERROR TBA 1992 PA-ENCRYPTED-CHALLENGE TBA 1993 1994 19958. IANA Considerations 1996 1997 This document creates a number of IANA registries. These registries 1998 should all be located under 1999 http://www.iana.org/assignments/kerberos-parameters. 2000 20018.1. Pre-authentication and Typed Data 2002 2003 RFC 4120 defines pre-authentication data, which can be included in a 2004 KDC request or response in order to authenticate the client or extend 2005 the protocol. In addition, it defines Typed-Data which is an 2006 extension mechanism for errors. Both pre-authentication data and 2007 typed data are carried as a 32-bit signed integer along with an octet 2008 string. The encoding of typed data and pre-authentication data is 2009 slightly different. However the types for pre-authentication data 2010 and typed-data are drawn from the same namespace. By convention, 2011 registrations starting with TD- are typed data and registration 2012 2013 2014 2015Hartman & Zhu Expires August 15, 2009 [Page 36] 2016 2017Internet-Draft Kerberos Preauth Framework February 2009 2018 2019 2020 starting with PA- are pre-authentication data. It is important that 2021 these data types be drawn from the same namespace, because some 2022 errors where it would be desirable to include typed data require the 2023 e-data field to be formatted as pre-authentication data. 2024 2025 When Kerberos FAST is used, pre-authentication data encoding is 2026 always used. 2027 2028 There is one apparently conflicting registration between typed data 2029 and pre-authentication data. PA-GET-FROM-TYPED-DATA and TD-PADATA 2030 are both assigned the value 22. However this registration is simply 2031 a mechanism to include an element of the other encoding. The use of 2032 both should be deprecated. 2033 2034 This document creates a registry for pre-authentication and typed 2035 data. The registration procedures are as follows. Expert review for 2036 pre-authentication mechanisms designed to authenticate users, KDCs, 2037 or establish the reply key. The expert first determines that the 2038 purpose of the method is to authenticate clients, KDCs, or to 2039 establish the reply key. If so, expert review is appropriate. The 2040 expert evaluates the security and interoperability of the 2041 specification. 2042 2043 IETF review is required if the expert believes that the pre- 2044 authentication method is broader than these three areas. Pre- 2045 authentication methods that change the Kerberos state machine or 2046 otherwise make significant changes to the Kerberos protocol should be 2047 standards track RFCs. A concern that a particular method needs to be 2048 a standards track RFC may be raised as an objection during IETF 2049 review. 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071Hartman & Zhu Expires August 15, 2009 [Page 37] 2072 2073Internet-Draft Kerberos Preauth Framework February 2009 2074 2075 2076 Type Value Reference 2077 PA-TGS-REQ 1 RFC 4120 2078 PA-ENC-TIMESTAMP 2 RFC 4120 2079 PA-PW-SALT 3 RFC 4120 2080 [reserved] 4 2081 PA-ENC-UNIX-TIME 5 (deprecated) 2082 PA-SANDIA-SECUREID 6 2083 PA-SESAME 7 2084 PA-OSF-DCE 8 2085 PA-CYBERSAFE-SECUREID 9 2086 PA-AFS3-SALT 10 2087 PA-ETYPE-INFO 11 RFC 4120 2088 PA-SAM-CHALLENGE 12 (sam/otp) 2089 PA-SAM-RESPONSE 13 (sam/otp) 2090 PA-PK-AS-REQ_OLD 14 draft-ietf-cat-kerberos-pk-init-09 2091 PA-PK-AS-REP_OLD 15 draft-ietf-cat-kerberos-pk-init-09 2092 PA-PK-AS-REQ 16 RFC 4556 2093 PA-PK-AS-REP 17 RFC 4556 2094 PA-ETYPE-INFO2 19 RFC 4120 2095 PA-USE-SPECIFIED-KVNO 20 2096 PA-SAM-REDIRECT 21 (sam/otp) 2097 PA-GET-FROM-TYPED-DATA 22 (embedded in typed data) 2098 TD-PADATA 22 (embeds padata) 2099 PA-SAM-ETYPE-INFO 23 (sam/otp) 2100 PA-ALT-PRINC 24 (crawdad@fnal.gov) 2101 PA-SAM-CHALLENGE2 30 (kenh@pobox.com) 2102 PA-SAM-RESPONSE2 31 (kenh@pobox.com) 2103 PA-EXTRA-TGT 41 Reserved extra TGT 2104 TD-PKINIT-CMS-CERTIFICATES 101 CertificateSet from CMS 2105 TD-KRB-PRINCIPAL 102 PrincipalName 2106 TD-KRB-REALM 103 Realm 2107 TD-TRUSTED-CERTIFIERS 104 from PKINIT 2108 TD-CERTIFICATE-INDEX 105 from PKINIT 2109 TD-APP-DEFINED-ERROR 106 application specific 2110 TD-REQ-NONCE 107 INTEGER 2111 TD-REQ-SEQ 108 INTEGER 2112 PA-PAC-REQUEST 128 MS-KILE 2113 2114 21158.2. Fast Armor Types 2116 2117 FAST armor types are defined in Section 6.5.1. A FAST armor type is 2118 a signed 32-bit integer. FAST armor types are assigned by standards 2119 action. 2120 2121 Type Name Description 2122 ------------------------------------------------------------ 2123 0 Reserved. 2124 2125 2126 2127Hartman & Zhu Expires August 15, 2009 [Page 38] 2128 2129Internet-Draft Kerberos Preauth Framework February 2009 2130 2131 2132 1 FX_FAST_ARMOR_AP_REQUEST Ticket armor using an ap-req. 2133 21348.3. FAST Options 2135 2136 A FAST request includes a set of bit flags to indicate additional 2137 options. Bits 0-15 are critical; other bits are non-critical. 2138 Assigning bits greater than 31 may require special support in 2139 implementations. Assignment of FAST options requires standards 2140 action. 2141 2142 Type Name Description 2143 ------------------------------------------------------------------- 2144 0 RESERVED Reserved for future expansion of this 2145 field. 2146 1 hide-client-names Requesting the KDC to hide client 2147 names in the KDC response 2148 16 kdc-follow-referrals Requesting the KDC to follow 2149 referrals 2150 2151 21529. Security Considerations 2153 2154 The kdc-referrals option in the Kerberos FAST padata requests the KDC 2155 to act as the client to follow referrals. This can overload the KDC. 2156 To limit the damages of denied of service using this option, KDCs MAY 2157 restrict the number of simultaneous active requests with this option 2158 for any given client principal. 2159 2160 With regarding to the facilities provided by the Encrypted Challenge 2161 FAST factor, the challenge key is derived from the client secrets and 2162 because the client secrets are known only to the client and the KDC, 2163 the verification of the EncryptedChallenge structure proves the 2164 client's identity, the verification of the EncryptedChallenge 2165 structure in the KDC reply proves that the expected KDC responded. 2166 Therefore, the Encrypted Challenge FAST factor as a pre- 2167 authentication mechanism offers the following facilities: client- 2168 authentication and KDC-authentication. There is no un-authenticated 2169 clear text introduced by the Encrypted Challenge FAST factor. 2170 2171 217210. Acknowledgements 2173 2174 Sam Hartman would like to thank the MIT Kerberos Consortium for its 2175 funding of his time on this project. 2176 2177 Several suggestions from Jeffrey Hutzelman based on early revisions 2178 of this documents led to significant improvements of this document. 2179 2180 2181 2182 2183Hartman & Zhu Expires August 15, 2009 [Page 39] 2184 2185Internet-Draft Kerberos Preauth Framework February 2009 2186 2187 2188 The proposal to ask one KDC to chase down the referrals and return 2189 the final ticket is based on requirements in [ID.CROSS]. 2190 2191 Joel Webber had a proposal for a mechanism similar to FAST that 2192 created a protected tunnel for Kerberos pre-authentication. 2193 2194 219511. References 2196 219711.1. Normative References 2198 2199 [KRB-ANON] 2200 Zhu, L. and P. Leach, "Kerberos Anonymity Support", 2201 draft-ietf-krb-wg-anon-04.txt (work in progress), 2007. 2202 2203 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 2204 Requirement Levels", BCP 14, RFC 2119, March 1997. 2205 2206 [RFC3961] Raeburn, K., "Encryption and Checksum Specifications for 2207 Kerberos 5", RFC 3961, February 2005. 2208 2209 [RFC4120] Neuman, C., Yu, T., Hartman, S., and K. Raeburn, "The 2210 Kerberos Network Authentication Service (V5)", RFC 4120, 2211 July 2005. 2212 2213 [RFC4556] Zhu, L. and B. Tung, "Public Key Cryptography for Initial 2214 Authentication in Kerberos (PKINIT)", RFC 4556, June 2006. 2215 221611.2. Informative References 2217 2218 [ID.CROSS] 2219 Sakane, S., Zrelli, S., and M. Ishiyama , "Problem 2220 Statement on the Operation of Kerberos in a Specific 2221 System", draft-sakane-krb-cross-problem-statement-02.txt 2222 (work in progress), April 2007. 2223 2224 [KRB-WG.SAM] 2225 Hornstein, K., Renard, K., Neuman, C., and G. Zorn, 2226 "Integrating Single-use Authentication Mechanisms with 2227 Kerberos", draft-ietf-krb-wg-kerberos-sam-02.txt (work in 2228 progress), October 2003. 2229 2230 [REFERRALS] 2231 Raeburn, K. and L. Zhu, "Generating KDC Referrals to 2232 Locate Kerberos Realms", 2233 draft-ietf-krb-wg-kerberos-referrals-10.txt (work in 2234 progress), 2007. 2235 2236 2237 2238 2239Hartman & Zhu Expires August 15, 2009 [Page 40] 2240 2241Internet-Draft Kerberos Preauth Framework February 2009 2242 2243 2244Appendix A. Change History 2245 2246 RFC editor, please remove this section before publication. 2247 2248A.1. Changes since 08 2249 2250 Fix a number of typos 2251 Rename anonymous flag to hide-client-name; rename kdc-referals to 2252 kdc-follow-referrals 2253 Clarify how anonymous pkinit interacts with KDC verified. 2254 Introduce AD-fx-fast-armor authorization data to deal with 2255 unprivileged processes constructing KDC requests. Note that a TGT 2256 is always used for armor tickets if the armor field is present; if 2257 you proxy or validate you'll end up with a TGT armor ticket and 2258 another ticket in the pa-tgs-req. Alternatively you can simply 2259 use the other ticket in the PA-TGS-REQ; weak consensus within WG. 2260 All KDCs in a realm MUST support FAST if it is to be offered. 2261 The cookie message is always generated by the KDC. 2262 Note that the client can trust and need not verify the time stamp 2263 in the finish message. This can seed the client's idea of KDC 2264 time. 2265 Note that the client name in the finish message may differ from 2266 the name in the request if referrals are used. 2267 Note that KDCs should advertize fast in preauth_required errors. 2268 Armor key is constructed using KRB-FX-CF2. This is true even in 2269 the TGS case; there is no security reason to do this. Using the 2270 subkey as done in draft 08 would be fine, but the current text 2271 uses the same procedure both in the TGS and AS case. 2272 Use a different challenge key in each direction in the encrypted 2273 challenge option. 2274 Note that the KDC should process PA-FX-COOKIE before other padata. 2275 KRB-FX-CF2 uses k1's enctype for the result; change around calling 2276 order so we pass in subkeys and armor keys as k1 in preference to 2277 long-term keys or ticket session keys. 2278 Clarify the relationship between authentication sets and cookies. 2279 A cookie may not be needed in the first message. Clarify how this 2280 interacts with optimistic clients. 2281 Remove text raising a concern that RFC 3961 may permit ciphertext 2282 transformations that do not change plaintext: discussion on the 2283 list came to the conclusion that RFC 3961 does not permit this. 2284 Remove binding key concept; use the armor key instead. The cookie 2285 becomes just an octet string. 2286 Include PA-FX-ERROR to protect the error information per Dublin. 2287 Returning preauth_failed in the failed to decrypt encrypted 2288 challenge seems fine; remove the issue marker 2289 Add a section describing what goes in the inner and outer request. 2290 I believe it is redundant but found it useful while putting 2291 together an implementation proposal. 2292 2293 2294 2295Hartman & Zhu Expires August 15, 2009 [Page 41] 2296 2297Internet-Draft Kerberos Preauth Framework February 2009 2298 2299 2300 Use hyphen rather than underscore in the constants for pre- 2301 authentication data to be consistent with RFC 4120. 2302 Add a ticket-checksum to the finished message 2303 Remove redundant KEY_USAGE_FAST_ARMOR. 2304 Add protocol constants section for non-IANA registrations and 2305 flesh out IANA section. 2306 Clarify that kdc-req-body checksums should always use the outer 2307 body even for mechanisms like PKINIT that include their own (now 2308 redundant) checksum. 2309 Remove mechanism for encapsulating typed data in padata; just 2310 reflect the value. 2311 2312A.2. Changes since 07 2313 2314 Propose replacement of authenticated timestamp with encrypted 2315 challenge. The desire to avoid clients needing time 2316 synchronization and to simply the factor. 2317 Add a requirement that any FAST armor scheme must provide a fresh 2318 key for each conversation. This allows us to assume that anything 2319 encrypted/integrity protected in the right key is fresh and not 2320 subject to cross-conversation cut and paste. 2321 Removed heartbeat padata. The KDC will double up messages if it 2322 needs to; the client simply sends its message and waits for the 2323 next response. 2324 Define PA-AUTHENTICATION-SET-SELECTED 2325 Clarify a KDC cannot ignore padata is has claimed to support 2326 2327A.3. Changes since 06 2328 2329 Note that even for replace reply key it is likely that the side 2330 using the mechanism will know that the other side supports it. 2331 Since it is reasonably unlikely we'll need a container mechanism 2332 other than FAST itself, we don't need to optimize for that case. 2333 So, we want to optimize for implementation simplicity. Thus if 2334 you do have such a container mechanism interacting with 2335 authentication sets we'll assume that the hint need to describe 2336 hints for all contained mechanisms. This closes out a long- 2337 standing issue. 2338 Write up what Sam believes is the consensus on UI and prompts in 2339 the authentication set: clients MAY assume that they have all the 2340 UI information they need. 2341 2342 2343Appendix B. ASN.1 module 2344 2345 KerberosPreauthFramework { 2346 iso(1) identified-organization(3) dod(6) internet(1) 2347 security(5) kerberosV5(2) modules(4) preauth-framework(3) 2348 2349 2350 2351Hartman & Zhu Expires August 15, 2009 [Page 42] 2352 2353Internet-Draft Kerberos Preauth Framework February 2009 2354 2355 2356 } DEFINITIONS EXPLICIT TAGS ::= BEGIN 2357 2358 IMPORTS 2359 KerberosTime, PrincipalName, Realm, EncryptionKey, Checksum, 2360 Int32, EncryptedData, PA-ENC-TS-ENC, PA-DATA, KDC-REQ-BODY, 2361 Microseconds, KerberosFlags 2362 FROM KerberosV5Spec2 { iso(1) identified-organization(3) 2363 dod(6) internet(1) security(5) kerberosV5(2) 2364 modules(4) krb5spec2(2) }; 2365 -- as defined in RFC 4120. 2366 2367 2368 PA-AUTHENTICATION-SET ::= SEQUENCE OF PA-AUTHENTICATION-SET-ELEM 2369 2370 PA-AUTHENTICATION-SET-ELEM ::= SEQUENCE { 2371 pa-type [0] Int32, 2372 -- same as padata-type. 2373 pa-hint [1] OCTET STRING OPTIONAL, 2374 pa-value [2] OCTET STRING OPTIONAL, 2375 ... 2376 } 2377 2378 KrbFastArmor ::= SEQUENCE { 2379 armor-type [0] Int32, 2380 -- Type of the armor. 2381 armor-value [1] OCTET STRING, 2382 -- Value of the armor. 2383 ... 2384 } 2385 2386 PA-FX-FAST-REQUEST ::= CHOICE { 2387 armored-data [0] KrbFastArmoredReq, 2388 ... 2389 } 2390 2391 KrbFastArmoredReq ::= SEQUENCE { 2392 armor [0] KrbFastArmor OPTIONAL, 2393 -- Contains the armor that identifies the armor key. 2394 -- MUST be present in AS-REQ. 2395 req-checksum [1] Checksum, 2396 -- Checksum performed over the type KDC-REQ-BODY for 2397 -- the req-body field of the KDC-REQ structure defined in 2398 -- [RFC4120] 2399 -- The checksum key is the armor key, the checksum 2400 -- type is the required checksum type for the enctype of 2401 -- the armor key, and the key usage number is 2402 -- KEY_USAGE_FAST_REQ_CHKSUM. 2403 enc-fast-req [2] EncryptedData, -- KrbFastReq -- 2404 2405 2406 2407Hartman & Zhu Expires August 15, 2009 [Page 43] 2408 2409Internet-Draft Kerberos Preauth Framework February 2009 2410 2411 2412 -- The encryption key is the armor key, and the key usage 2413 -- number is KEY_USAGE_FAST_ENC. 2414 ... 2415 } 2416 2417 KrbFastReq ::= SEQUENCE { 2418 fast-options [0] FastOptions, 2419 -- Additional options. 2420 padata [1] SEQUENCE OF PA-DATA, 2421 -- padata typed holes. 2422 req-body [2] KDC-REQ-BODY, 2423 -- Contains the KDC request body as defined in Section 2424 -- 5.4.1 of [RFC4120]. 2425 -- This req-body field is preferred over the outer field 2426 -- in the KDC request. 2427 ... 2428 } 2429 2430 FastOptions ::= KerberosFlags 2431 -- reserved(0), 2432 -- anonymous(1), 2433 -- kdc-referrals(16) 2434 2435 PA-FX-FAST-REPLY ::= CHOICE { 2436 armored-data [0] KrbFastArmoredRep, 2437 ... 2438 } 2439 2440 KrbFastArmoredRep ::= SEQUENCE { 2441 enc-fast-rep [0] EncryptedData, -- KrbFastResponse -- 2442 -- The encryption key is the armor key in the request, and 2443 -- the key usage number is KEY_USAGE_FAST_REP. 2444 ... 2445 } 2446 2447 KrbFastResponse ::= SEQUENCE { 2448 padata [0] SEQUENCE OF PA-DATA, 2449 -- padata typed holes. 2450 rep-key [1] EncryptionKey OPTIONAL, 2451 -- This, if present, replaces the reply key for AS and TGS. 2452 -- MUST be absent in KRB-ERROR. 2453 finished [2] KrbFastFinished OPTIONAL, 2454 -- MUST be present if the client is authenticated, 2455 -- absent otherwise. 2456 -- Typically this is present if and only if the containing 2457 -- message is the last one in a conversation. 2458 ... 2459 } 2460 2461 2462 2463Hartman & Zhu Expires August 15, 2009 [Page 44] 2464 2465Internet-Draft Kerberos Preauth Framework February 2009 2466 2467 2468 KrbFastFinished ::= SEQUENCE { 2469 timestamp [0] KerberosTime, 2470 usec [1] Microseconds, 2471 -- timestamp and usec represent the time on the KDC when 2472 -- the reply was generated. 2473 crealm [2] Realm, 2474 cname [3] PrincipalName, 2475 -- Contains the client realm and the client name. 2476 checksum [4] Checksum, 2477 -- Checksum performed over all the messages in the 2478 -- conversation, except the containing message. 2479 -- The checksum key is the armor key as defined in 2480 -- Section 6.5.1, and the checksum type is the required 2481 -- checksum type of the armor key. 2482 ticket-checksum [5] Checksum, 2483 -- checksum of the ticket in the KDC-REP using the armor 2484 -- and the key usage is KEY_USAGE_FAST_FINISH. 2485 -- The checksum type is the required checksum type 2486 -- of the armor key. 2487 ... 2488 } 2489 2490 EncryptedChallenge ::= EncryptedData 2491 -- Encrypted PA-ENC-TS-ENC, encrypted in the challenge key 2492 -- using key usage KEY_USAGE_ENC_CHALLENGE_CLIENT for the 2493 -- client and KEY_USAGE_ENC_CHALLENGE_KDC for the KDC. 2494 END 2495 2496 2497Authors' Addresses 2498 2499 Sam hartman 2500 Painless Security 2501 2502 Email: hartmans-ietf@mit.edu 2503 2504 2505 Larry Zhu 2506 Microsoft Corporation 2507 One Microsoft Way 2508 Redmond, WA 98052 2509 US 2510 2511 Email: lzhu@microsoft.com 2512 2513 2514 2515 2516 2517 2518 2519Hartman & Zhu Expires August 15, 2009 [Page 45] 2520 2521 2522