idnits 2.17.1 draft-ietf-rap-auth-policy-data-00.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- ** Looks like you're using RFC 2026 boilerplate. This must be updated to follow RFC 3978/3979, as updated by RFC 4748. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- ** The document seems to lack a 1id_guidelines paragraph about Internet-Drafts being working documents. ** The document is more than 15 pages and seems to lack a Table of Contents. == No 'Intended status' indicated for this document; assuming Proposed Standard Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- ** The document seems to lack an IANA Considerations section. (See Section 2.2 of https://www.ietf.org/id-info/checklist for how to handle the case when there are no actions for IANA.) ** The document seems to lack separate sections for Informative/Normative References. All references will be assumed normative when checking for downward references. ** There is 1 instance of too long lines in the document, the longest one being 1 character in excess of 72. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the RFC 3978 Section 5.4 Copyright Line does not match the current year -- The document seems to lack a disclaimer for pre-RFC5378 work, but may have content which was first submitted before 10 November 2008. If you have contacted all the original authors and they are all willing to grant the BCP78 rights to the IETF Trust, then this is fine, and you can ignore this comment. If not, you may need to add the pre-RFC5378 disclaimer. (See the Legal Provisions document at https://trustee.ietf.org/license-info for more information.) -- The document date (June 2001) is 8351 days in the past. Is this intentional? Checking references for intended status: Proposed Standard ---------------------------------------------------------------------------- (See RFCs 3967 and 4897 for information about using normative references to lower-maturity documents in RFCs) -- Possible downref: Normative reference to a draft: ref. '2' ** Downref: Normative reference to an Informational RFC: RFC 2104 (ref. '4') ** Obsolete normative reference: RFC 2401 (ref. '6') (Obsoleted by RFC 4301) ** Obsolete normative reference: RFC 2402 (ref. '7') (Obsoleted by RFC 4302, RFC 4305) -- Duplicate reference: RFC2747, mentioned in '8', was also mentioned in '3'. ** Obsolete normative reference: RFC 793 (ref. '9') (Obsoleted by RFC 9293) ** Obsolete normative reference: RFC 2752 (ref. '10') (Obsoleted by RFC 3182) ** Obsolete normative reference: RFC 2408 (ref. '11') (Obsoleted by RFC 4306) ** Obsolete normative reference: RFC 1510 (ref. '12') (Obsoleted by RFC 4120, RFC 6649) ** Obsolete normative reference: RFC 2406 (ref. '13') (Obsoleted by RFC 4303, RFC 4305) Summary: 14 errors (**), 0 flaws (~~), 2 warnings (==), 4 comments (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 2 RAP Working Group R. Hess 3 Internet Draft Intel 4 Expires December 2001 June 2001 6 Cryptographic Authentication for RSVP POLICY_DATA Objects 8 draft-ietf-rap-auth-policy-data-00.txt 10 Status of this Memo 12 This document is an Internet-Draft and is subject to all provisions 13 of Section 10 of RFC2026. Internet-Drafts are working documents of 14 the Internet Engineering Task Force (IETF), its areas, and its 15 working groups. Note that other groups may also distribute 16 working documents as Internet-Drafts. 18 Internet-Drafts are draft documents valid for a maximum of six months 19 and may be updated, replaced, or obsoleted by other documents at any 20 time. It is inappropriate to use Internet-Drafts as reference 21 material or to cite them other than as "work in progress." 23 The list of current Internet-Drafts can be accessed at 24 http://www.ietf.org/ietf/1id-abstracts.txt 26 The list of Internet-Draft Shadow Directories can be accessed at 27 http://www.ietf.org/shadow.html 29 The distribution of this memo is unlimited. This memo is filed as 30 and expires December 31, 31 2001. Please send comments to the author. 33 Copyright Notice 35 Copyright (C) The Internet Society (2001). All Rights Reserved. 37 Abstract 39 This document describes the format and use of the INTEGRITY option 40 within RSVP's POLICY_DATA object to provide integrity and 41 authentication of POLICY_DATA objects within RSVP messages. 43 1. Introduction 45 The Resource ReSerVation Protocol (RSVP) [1] is a protocol for 46 setting up distributed state in routers and hosts, and in particular 47 for reserving resources to implement integrated service. RSVP allows 48 particular users to obtain preferential access to network resources, 49 under the control of an admission control mechanism. Permission to 50 make a reservation will depend both upon the availability of the 51 requested resources along the path of the data, and upon satisfaction 52 of policy rules. 54 Policy based admission control will occur at Policy Enforcement 55 Points (PEPs); for the purposes of this document these nodes are 56 policy aware RSVP systems. Policy data are distributed among PEPs 57 using POLICY_DATA objects in RSVP messages. Initially, the 58 enforcement of policy rules may concentrate on border nodes between 59 autonomous systems. As such, POLICY_DATA objects may traverse policy 60 ignorant RSVP systems (PINs) whose capabilities are limited to 61 default policy handling [2]. 63 To ensure the integrity of this policy based admission control 64 mechanism, PEPs require the ability to protect their POLICY_DATA 65 objects against corruption and spoofing. The RSVP integrity 66 mechanism [3] works hop-by-hop, which, unfortunately, is 67 insufficient for our needs as it places trust with the POLICY_DATA 68 object in PINs. What is required is an integrity mechanism 69 analogous to RSVP's, but one what works PEP peer to PEP peer. This 70 document defines such a mechanism. The proposed scheme transmits an 71 authenticating digest of the POLICY_DATA object, computed using a 72 secret Authentication Key and a keyed-hash algorithm. This scheme 73 provides protection against forgery or object modification. The 74 INTEGRITY option of each POLICY_DATA object is tagged with a one- 75 time-use sequence number. This allows the message receiver to 76 identify playbacks and hence to thwart replay attacks. The proposed 77 mechanism does not afford confidentiality, since messages stay in the 78 clear; however, the mechanism is also exportable from most countries, 79 which would be impossible were a privacy algorithm to be used. Note: 80 this document uses the terms "sender" and "receiver" differently from 81 [3]. They are used here to refer to policy aware RSVP systems 82 (a.k.a. PEPs) that face each other either across an RSVP hop or 83 through one or more PINs, the "sender" being the system generating 84 POLICY_DATA objects. 86 The message replay prevention algorithm is quite simple. The sender 87 generates packets with monotonically increasing sequence numbers. In 88 turn, the receiver only accepts packets that have a larger sequence 89 number than the previous packet. To start this process, a receiver 90 handshakes with the sender to get an initial sequence number. This 91 memo discusses ways to relax the strictness of the in-order delivery 92 of messages as well as techniques to generate monotonically 93 increasing sequence numbers that are robust across sender failures 94 and restarts. 96 The proposed mechanism is independent of a specific cryptographic 97 algorithm, but this document describes the use of Keyed-Hashing for 98 Message Authentication using HMAC-MD5 [4]. As noted in [4], there 99 exist stronger hashes, such as HMAC-SHA1; where warranted, 100 implementations will do well to make them available. However, in the 101 general case, [4] suggests that HMAC-MD5 is adequate to the purpose 102 at hand and has preferable performance characteristics. [4] also 103 offers source code and test vectors for this algorithm, a boon to 104 those who would test for interoperability. HMAC-MD5 is required as a 105 baseline to be universally included in policy aware RSVP 106 implementations providing cryptographic authentication, with other 107 proposals optional (see Section 6 on Conformance Requirements). 109 1.1. Conventions used in this Document 111 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 112 "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this 113 document are to be interpreted as described in [5]. 115 1.2. Why not use the Standard IPsec Authentication Header? 117 One obvious question is why, since there exists a standard 118 authentication mechanism, IPsec [6,7], we would choose not to use it. 119 The use of IPsec was rejected for the following reasons. 121 The security associations in IPsec are based on destination address. 122 It is not clear that POLICY_DATA objects are well defined for either 123 source or destination based security associations, as a router must 124 forward PATH and PATH TEAR messages using the same source address as 125 the sender listed in the SENDER TEMPLATE. RSVP traffic may otherwise 126 not follow exactly the same path as data traffic. Using either 127 source or destination based associations would require opening a new 128 security association among the routers for which a reservation 129 traverses. 131 In addition, it was noted that neighbor relationships between PEPs 132 are not limited to those that face one another across a communication 133 channel. POLICY_DATA objects may traverse PINs, which are not 134 necessarily visible to the sending system. These arguments suggest 135 the use of a key management strategy based on PEP to PEP associations 136 instead of IPsec. 138 2. Data Structures 140 2.1. INTEGRITY Option Format 142 The Options List of a POLICY_DATA object consists of a sequence of 143 "objects," which are type-length-value encoded fields having specific 144 purposes. The information required for PEP peer to PEP peer 145 integrity checking is carried in an INTEGRITY option. The same 146 INTEGRITY option type is used for both IPv4 and IPv6. 148 The INTEGRITY Option format is defined to be identical to RSVP's 149 INTEGRITY object as defined in [8], Section 2.1. For clarity, the 150 format is reproduced below. 152 o Keyed Message Digest INTEGRITY Option: Class = 4, C-Type = 1 154 +-------------+-------------+-------------+-------------+ 155 | Length | 4 | 1 | 156 +-------------+-------------+-------------+-------------+ 157 | Flags | 0 (Reserved)| | 158 +-------------+-------------+ + 159 | Key Identifier | 160 +-------------+-------------+-------------+-------------+ 161 | | 162 | Sequence Number | 163 +-------------+-------------+-------------+-------------+ 164 | | 165 // Keyed Message Digest // 166 | | 167 +-------------+-------------+-------------+-------------+ 169 Length: 16 bits 171 The total length of the INTEGRITY Option in octets. Must 172 always be a multiple of 4. 174 Flags: An 8-bit field with the following format: 176 Flags 178 0 1 2 3 4 5 6 7 179 +---+---+---+---+---+---+---+---+ 180 | H | | 181 | F | 0 | 182 +---+---+---+---+---+---+---+---+ 184 Currently only one flag (HF) is defined. The remaining flags 185 are reserved for future use and MUST be set to 0. 187 o Bit 0: Handshake Flag (HF) concerns the integrity 188 handshake mechanism (Section 4.3). POLICY_DATA object 189 senders willing to respond to integrity handshake 190 messages SHOULD set this flag to 1 whereas those that 191 will reject integrity handshake messages SHOULD set this 192 to 0. 194 Reserved: 8 bits 196 Unused at this time. This field MUST be set to 0. 198 Key Identifier: 48 bits 200 An unsigned 48-bit number that MUST be unique for a given 201 sender. Locally unique Key Identifiers can be generated using 202 some combination of the address (IP or MAC or LIH) of the 203 sending interface and the key number. The combination of the 204 Key Identifier and the sending system's IP address uniquely 205 identifies the security association (Section 2.2). 207 Sequence Number: 64 bits 209 An unsigned monotonically increasing, unique sequence number. 211 Sequence Number values may be any monotonically increasing 212 sequence that provides the INTEGRITY option (of each 213 POLICY_DATA object) with a tag that is unique for the 214 associated key's lifetime. Details on sequence number 215 generation are presented in Section 3. 217 Keyed Message Digest: Variable length 219 The digest MUST be a multiple of 4 octets long. For HMAC-MD5, 220 it will be 16 octets long. 222 2.2. Security Association 224 The sending and receiving systems maintain a security association for 225 each authentication key that they share. This security association 226 includes the following parameters: 228 o Authentication algorithm and algorithm mode being used. 230 o Key used with the authentication algorithm. 232 o Lifetime of the key. 234 o Associated sending interface and other security association 235 selection criteria [REQUIRED at Sending System]. 237 o Source Address of the sending system [REQUIRED at Receiving 238 System]. 240 o Latest sending sequence number used with this key identifier 241 [REQUIRED at Sending System]. 243 o List of last N sequence numbers received with this key 244 identifier [REQUIRED at Receiving System]. 246 3. Generating Sequence Numbers 248 In this section we describe methods that could be chosen to generate 249 the sequence numbers used in the INTEGRITY option of a POLICY_DATA 250 object in a RSVP message. As previous stated, there are two 251 important properties that MUST be satisfied by the generation 252 procedure. The first property is that the sequence numbers are 253 unique, or one-time, for the lifetime of the integrity key that is in 254 current use. A receiver can use this property to unambiguously 255 distinguish between a new or a replayed object. The second property 256 is that the sequence numbers are generated in monotonically 257 increasing order, modulo 2^64. This is required to greatly reduce 258 the amount of saved state, since a receiver only needs to save the 259 value of the highest sequence number seen to avoid a replay attack. 260 Since the starting sequence number might be arbitrarily large, the 261 modulo operation is required to accommodate sequence number roll-over 262 within some key's lifetime. This solution draws from TCP's approach 263 [9]. 265 The sequence number field is chosen to be a 64-bit unsigned quantity. 266 This is large enough to avoid exhaustion over the key lifetime. For 267 example, if a key lifetime was conservatively defined as one year, 268 there would be enough sequence number values to send POLICY_DATA 269 objects at an average rate of about 585 gigaObjects per second. A 270 32-bit sequence number would limit this average rate to about 136 271 objects per second. 273 The ability to generate unique monotonically increasing sequence 274 numbers across a failure and restart implies some form of stable 275 storage, either local to the device or remotely over the network. 276 Three sequence number generation procedures are described below. 278 3.1. Simple Sequence Numbers 280 The most straightforward approach is to generate a unique sequence 281 number using an object counter. Each time a POLICY_DATA object is 282 transmitted for a given key, the sequence number counter is 283 incremented. The current value of this counter is continually or 284 periodically saved to stable storage. After a restart, the counter 285 is recovered using this stable storage. If the counter was saved 286 periodically to stable storage, the count should be recovered by 287 increasing the saved value to be larger than any possible value of 288 the counter at the time of the failure. This can be computed, 289 knowing the interval at which the counter was saved to stable 290 storage and incrementing the stored value by that amount. 292 3.2. Sequence Numbers Based on a Real Time Clock 294 Most devices will probably not have the capability to save sequence 295 number counters to stable storage for each key. A more universal 296 solution is to base sequence numbers on the stable storage of a real 297 time clock. Many computing devices have a real time clock module 298 that includes stable storage of the clock. These modules generally 299 include some form of nonvolatile memory to retain clock information 300 in the event of a power failure. 302 In this approach, we could use an NTP based timestamp value as the 303 sequence number. The roll-over period of a NTP timestamp is about 304 136 years, much longer than any reasonable lifetime of a key. In 305 addition, the granularity of the NTP timestamp is fine enough to 306 allow the generation of a POLICY_DATA object every 200 picoseconds 307 for a given key. Many real time clock modules do not have the 308 resolution of an NTP timestamp. In these cases, the least 309 significant bits of the timestamp can be generated using an object 310 counter, which is reset every clock tick. For example, when the real 311 time clock provides a resolution of 1 second, the 32 least 312 significant bits of the sequence number can be generated using an 313 object counter. The remaining 32 bits are filled with the 32 least 314 significant bits of the timestamp. Assuming that the recovery time 315 after failure takes longer than one tick of the real time clock, the 316 object counter for the low order bits can be safely reset to zero 317 after a restart. 319 3.3. Sequence Numbers Based on a Network Recovered Clock 321 If the device does not contain any stable storage of sequence number 322 counters or of a real time clock, it could recover the real time 323 clock from the network using NTP. Once the clock has been recovered 324 following a restart, the sequence number generation procedure would 325 be identical to the procedure described above. 327 4. POLICY_DATA Object Processing 329 Implementations SHOULD allow specification of interfaces that are to 330 be secured, for either sending objects, or receiving them, or both. 331 The sender must ensure that all POLICY_DATA objects sent on secured 332 sending interfaces include an INTEGRITY option, generated using the 333 appropriate Key. Receivers verify whether POLICY_DATA objects, 334 except of the type "Integrity Challenge" (Section 4.3), arriving on a 335 secured receiving interface contain the INTEGRITY option. If the 336 INTEGRITY option is absent, the receiver discards the object. 338 Security associations are simplex - the keys that a sending system 339 uses to sign its objects may be different from the keys that its 340 receivers use to sign theirs. Hence, each association is associated 341 with a unique sending system and (possibly) multiple receiving 342 systems. 344 Each sender SHOULD have distinct security associations (and keys) per 345 secured sending interface (or LIH). While administrators may 346 configure all the routers and hosts on a subnet (or for that matter, 347 in their network) using a single security association, 348 implementations MUST assume that each sender may send using a 349 distinct security association on each secured interface. At the 350 sender, security association selection is based on the interface 351 through which the object is sent. This selection MAY include 352 additional criteria, such as the destination address (when sending 353 the object unicast, over a broadcast LAN with a large number of 354 hosts) or user identities at the sender or receivers [10]. Finally, 355 all intended object recipients should participate in this security 356 association. Route flaps in a non RSVP cloud might cause objects for 357 the same receiver to be sent on different interfaces at different 358 times. In such cases, the receivers should participate in all 359 possible security associations that may be selected for the 360 interfaces through which the object might be sent. 362 Receivers select keys based on the Key Identifier and the sending 363 system's IP address. The Key Identifier is included in the INTEGRITY 364 option. The sending system's address can be obtained from the 365 Originating RSVP_HOP option. Since the Key Identifier is unique for 366 a sender, this method uniquely identifies the key. 368 The integrity mechanism slightly modifies the processing rules for 369 POLICY_DATA objects, both when including the INTEGRITY option in a 370 policy object sent over a secured sending interface and when 371 accepting a policy object received on a secured receiving interface. 372 These modifications are detailed below. 374 4.1. INTEGRITY Generation 376 For a POLICY_DATA object sent over a secured sending interface, the 377 object is created as follows: 379 (1) The INTEGRITY option is inserted in the appropriate place, and 380 its location in the POLICY_DATA object is remembered for later 381 use. 383 (2) The sending interface and other appropriate criteria (as 384 mentioned above) are used to determine the Authentication Key 385 and the hash algorithm to be used. 387 (3) The unused flags and the reserved field in the INTEGRITY 388 option MUST be set to 0. The Handshake Flag (HF) should be 389 set according to rules specified in Section 2.1. 391 (4) The sending sequence number MUST be updated to ensure a 392 unique, monotonically increasing number. It is then placed in 393 the Sequence Number field of the INTEGRITY option. 395 (5) The Keyed Message Digest field is set to zero. 397 (6) The Key Identifier is placed into the INTEGRITY option. 399 4.2. INTEGRITY Reception 401 (7) A copy of the RSVP SESSION object is temporarily appended to 402 the end of the POLICY_DATA object (for computational purposes 403 only, without changing the length of the POLICY_DATA object). 404 The flags field of the SESSION object is set to 0. This 405 concatenation is considered as the message for which a digest 406 is to be computed. 408 (8) An authenticating digest of the object is computed using the 409 Authentication Key in conjunction with the keyed-hash 410 algorithm. When the HMAC-MD5 algorithm is used, the hash 411 calculation is described in [4]. Note: When the computation 412 is complete, the SESSION object is ignored and is not part of 413 the POLICY_DATA object. 415 (9) The digest is written into the Cryptographic Digest field of 416 the INTEGRITY option. 418 When the policy object is received on a secured receiving interface, 419 and is not of the type "Integrity Challenge", it is processed in the 420 following manner: 422 (1) The Cryptographic Digest field of the INTEGRITY option is 423 saved and the field is subsequently set to zero. 425 (2) A copy of the RSVP SESSION object is temporarily appended to 426 the end of the POLICY_DATA object (for computational purposes 427 only, without changing the length of the POLICY_DATA object). 428 The flags field of the SESSION object is set to 0. This 429 concatenation is considered as the message for which a digest 430 is to be computed. 432 (3) The Key Identifier field and the sending system address are 433 used to uniquely determine the Authentication Key and the hash 434 algorithm to be used. Processing of this packet might be 435 delayed when the Key Management System (Appendix 1) is queried 436 for this information. 438 (4) A new keyed-digest is calculated using the indicated algorithm 439 and the Authentication Key. Note: When the computation is 440 complete, the SESSION object is ignored and is not part of the 441 POLICY_DATA object. 443 (5) If the calculated digest does not match the received digest, 444 the policy object is discarded without further processing. 446 (6) If the policy object is of type "Integrity Response", verify 447 that the CHALLENGE option identically matches the originated 448 challenge. If it matches, save the sequence number in the 449 INTEGRITY option as the largest sequence number received to 450 date. 452 Otherwise, for all other policy objects, the sequence number 453 is validated to prevent replay attacks, and messages with 454 invalid sequence numbers are ignored by the receiver. 456 When a policy object is accepted, the sequence number of that 457 object could update a stored value corresponding to the 458 largest sequence number received to date. Each subsequent 459 object must then have a larger (modulo 2^64) sequence number 460 to be accepted. This simple processing rule prevents message 461 replay attacks, but it must be modified to tolerate limited 462 out-of-order message delivery. For example, if several 463 messages were sent in a burst (in a periodic refresh generated 464 by a router, or as a result of a tear down function), they 465 might get reordered and then the sequence numbers would not be 466 received in an increasing order. 468 An implementation SHOULD allow administrative configuration 469 that sets the receiver's tolerance to out-of-order message 470 delivery. A simple approach would allow administrators to 471 specify a message window corresponding to the worst case 472 reordering behavior. For example, one might specify that 473 packets reordered within a 32 message window would be 474 accepted. If no reordering can occur, the window is set to 475 one. 477 The receiver must store a list of all sequence numbers seen 478 within the reordering window. A received sequence number is 479 valid if (a) it is greater than the maximum sequence number 480 received or (b) it is a past sequence number lying within the 481 reordering window and not recorded in the list. Acceptance of 482 a sequence number implies adding it to the list and removing a 483 number from the lower end of the list. Policy objects 484 received with sequence numbers lying below the lower end of 485 the list or marked seen in the list are discarded. 487 When an "Integrity Challenge" policy object is received on a secured 488 sending interface it is processed in the following manner: 490 (1) An "Integrity Response" policy object is formed using the 491 Challenge option received in the challenge policy object. 493 (2) The response object is sent back to the receiver, based on the 494 source IP address of the challenge policy object, using the 495 "INTEGRITY Generation" steps outlined above. The selection of 496 the Authentication Key and the hash algorithm to be used is 497 determined by the key identifier supplied in the challenge 498 policy object. 500 4.3. Integrity Handshake at Restart or Initialization of the Receiver 502 To obtain the starting sequence number for a live Authentication Key, 503 the receiver MAY initiate an integrity handshake with the sender. 504 This handshake consists of a receiver's Challenge and the sender's 505 Response, and may be either initiated during restart or postponed 506 until a message signed with that key arrives. 508 Once the receiver has decided to initiate an integrity handshake for 509 a particular Authentication Key, it identifies the sender using the 510 sending system's address configured in the corresponding security 511 association. The receiver then sends an Integrity Challenge, that 512 is, a POLICY_DATA object with a CHALLENGE Option to the sender. This 513 option contains the Key Identifier to identify the sender's key and 514 MUST have a unique challenge cookie that is based on a local secret 515 to prevent guessing (see Section 2.5.3 of [11]). It is suggested 516 that the cookie be an MD5 hash of a local secret and a timestamp to 517 provide uniqueness (see Section 9). 519 A CHALLENGE Option format is defined to be identical to RSVP's 520 CHALLENGE object as defined in [8], Section 4.3. For clarity, the 521 format is reproduced below. 523 o CHALLENGE option: Class = 64, C-Type = 1 525 +-------------+-------------+-------------+-------------+ 526 | Length | 64 | 1 | 527 +-------------+-------------+-------------+-------------+ 528 | 0 (Reserved) | | 529 +-------------+-------------+ + 530 | Key Identifier | 531 +-------------+-------------+-------------+-------------+ 532 | | 533 // Challenge Cookie // 534 | | 535 +-------------+-------------+-------------+-------------+ 537 Length: 16 bits 539 The total length of the CHALLENGE Option in octets. Must 540 always be a multiple of 4. 542 Reserved: 16 bits 544 Unused at this time. This field MUST be set to 0. 546 Key Identifier: 48 bits 548 Challenge Cookie: Variable length 550 The cookie MUST be a multiple of 4 octets long. 552 The sender accepts the "Integrity Challenge" without doing an 553 integrity check. It returns an "Integrity Response," that is, a 554 POLICY_DATA object that contains the original CHALLENGE option. It 555 also includes an INTEGRITY option, signed with the key specified by 556 the Key Identifier included in the "Integrity Challenge". 558 The "Integrity Response" message is accepted by the receiver 559 (challenger) only if the returned CHALLENGE option matches the one 560 sent in the "Integrity Challenge" message. This prevents replay of 561 old "Integrity Response" messages. If the match is successful, the 562 receiver saves the Sequence Number from the INTEGRITY option as the 563 latest sequence number received with the key identifier included in 564 the CHALLENGE. 566 If a response is not received within a given period of time, the 567 challenge is repeated. When the integrity handshake successfully 568 completes, the receiver begins accepting normal POLICY_DATA objects 569 from that sender and ignores any other "Integrity Response" messages. 571 The Handshake Flag (HF) is used to allow implementations the 572 flexibility of not including the integrity handshake mechanism. By 573 setting this flag to 1, message senders that implement the integrity 574 handshake distinguish themselves from those that do not. Receivers 575 SHOULD NOT attempt to handshake with senders whose INTEGRITY option 576 has HF = 0. 578 An integrity handshake may not be necessary in all environments. A 579 common use of POLICY_DATA integrity will be between peering PEPs, 580 which are likely to be processing a steady stream of policy objects 581 due to aggregation effects. When a PEP restarts after a crash, valid 582 policy objects from peering senders will probably arrive within a 583 short time. Assuming that replay objects are injected into the 584 stream of valid policy objects, there may be only a small window of 585 opportunity for a replay attack before a valid object is processed. 586 This valid object will set the largest sequence number seen to a 587 value greater than any number that had been stored prior to the 588 crash, preventing any further replays. 590 On the other hand, not using an integrity handshake could allow 591 exposure to replay attacks if there is a long period of silence from 592 a given sender following a restart of a receiver. Hence, it SHOULD 593 be an administrative decision whether or not the receiver performs an 594 integrity handshake with senders that are willing to respond to 595 "Integrity Challenge" messages, and whether it accepts any messages 596 from senders that refuse to do so. These decisions will be based on 597 assumptions related to a particular network environment. 599 5. Key Management 601 It is likely that the IETF will define a standard key management 602 protocol. It is strongly desirable to use that key management 603 protocol to distribute POLICY_DATA Authentication Keys among 604 communicating policy aware RSVP implementations. Such a protocol 605 would provide scalability and significantly reduce the human 606 administrative burden. The Key Identifier can be used as a hook 607 between PEPs and such a future protocol. Key management protocols 608 have a long history of subtle flaws that are often discovered long 609 after the protocol was first described in public. To avoid having to 610 change all PEP implementations should such a flaw be discovered, 611 integrated key management protocol techniques were deliberately 612 omitted from this specification. 614 5.1. Key Management Procedures 616 Each key has a lifetime associated with it that is recorded in all 617 systems (sender and receivers) configured with that key. The concept 618 of a "key lifetime" merely requires that the earliest (KeyStartValid) 619 and latest (KeyEndValid) times that the key is valid be programmable 620 in a way the system understands. Certain key generation mechanisms, 621 such as Kerberos or some public key schemes, may directly produce 622 ephemeral keys. In this case, the lifetime of the key is implicitly 623 defined as part of the key. 625 In general, no key is ever used outside its lifetime (but see Section 626 5.3). Possible mechanisms for managing key lifetime include the 627 Network Time Protocol and hardware time-of-day clocks. 629 To maintain security, it is advisable to change the POLICY_DATA 630 Authentication Key on a regular basis. It should be possible to 631 switch the POLICY_DATA Authentication Key without loss of RSVP state 632 or denial of reservation service, and without requiring people to 633 change all the keys at once. This requires a PEP implementation to 634 support the storage and use of more than one active POLICY_DATA 635 Authentication Key at the same time. Hence both the sender and 636 receivers might have multiple active keys for a given security 637 association. 639 Since keys are shared between a sender and (possibly) multiple 640 receivers, there is a region of uncertainty around the time of key 641 switch-over during which some systems may still be using the old key 642 and others might have switched to the new key. The size of this 643 uncertainty region is related to clock synchrony of the systems. 644 Administrators should configure the overlap between the expiration 645 time of the old key (KeyEndValid) and the validity of the new key 646 (KeyStartValid) to be at least twice the size of this uncertainty 647 interval. This will allow the sender to make the key switch-over at 648 the midpoint of this interval and be confident that all receivers are 649 now accepting the new key. For the duration of the overlap in key 650 lifetimes, a receiver must be prepared to authenticate messages using 651 either key. 653 During a key switch-over, it will be necessary for each receiver to 654 handshake with the sender using the new key. As stated before, a 655 receiver has the choice of initiating a handshake during the 656 switchover or postponing the handshake until the receipt of a message 657 using that key. 659 5.2. Key Management Requirements 661 Requirements on an implementation are as follows: 663 o It is strongly desirable that a hypothetical security breach 664 in one Internet protocol not automatically compromise other 665 Internet protocols. The Authentication Key of this 666 specification SHOULD NOT be stored using protocols or 667 algorithms that have known flaws. 669 o An implementation MUST support the storage and use of more 670 than one key at the same time, for both sending and receiving 671 systems. 673 o An implementation MUST associate a specific lifetime (i.e., 674 KeyStartValid and KeyEndValid) with each key and the 675 corresponding Key Identifier. 677 o An implementation MUST support manual key distribution (e.g., 678 the privileged user manually typing in the key, key lifetime, 679 and key identifier on the console). The lifetime may be 680 infinite. 682 o If more than one algorithm is supported, then the 683 implementation MUST require that the algorithm be specified 684 for each key at the time the other key information is entered. 686 o Keys that are out of date MAY be automatically deleted by the 687 implementation. 689 o Manual deletion of active keys MUST also be supported. 691 o Key storage SHOULD persist across a system restart, warm or 692 cold, to ease operational usage. 694 5.3. Pathological Case 696 It is possible that the last key for a given security association has 697 expired. When this happens, it is unacceptable to revert to an 698 unauthenticated condition, and not advisable to disrupt current 699 reservations. Therefore, the system should send a "last 700 authentication key expiration" notification to the network manager 701 and treat the key as having an infinite lifetime until the lifetime 702 is extended, the key is deleted by network management, or a new key 703 is configured. 705 6. Conformance Requirements 707 To conform to this specification, an implementation MUST support all 708 of its aspects. The HMAC-MD5 authentication algorithm defined in [4] 709 MUST be implemented by all conforming implementations. A conforming 710 implementation MAY also support other authentication algorithms such 711 as NIST's Secure Hash Algorithm (SHA). Manual key distribution as 712 described above MUST be supported by all conforming implementations. 713 All implementations MUST support the smooth key roll over described 714 under "Key Management Procedures." 716 Implementations SHOULD support a standard key management protocol for 717 secure distribution of POLICY_DATA Authentication Keys once such a 718 key management protocol is standardized by the IETF. 720 7. Kerberos Generation of POLICY_DATA Authentication Keys 722 Kerberos [12] MAY be used to generate the POLICY_DATA Authentication 723 key used in generating a signature in the Integrity Option sent from 724 a PEP sender to a receiver. Kerberos key generation avoids the use 725 of shared keys between PEP senders and receivers such as hosts and 726 routers. Kerberos allows for the use of trusted third party keying 727 relationships between security principals (PEP sender and receivers) 728 where the Kerberos key distribution center (KDC) establishes an 729 ephemeral session key that is subsequently shared between PEP sender 730 and receivers. In the multicast case all receivers of a multicast 731 POLICY_DATA object MUST share a single key with the KDC (e.g. the 732 receivers are in effect the same security principal with respect to 733 Kerberos). 735 The Key information determined by the sender MAY specify the use of 736 Kerberos in place of configured shared keys as the mechanism for 737 establishing a key between the sender and receiver. The Kerberos 738 identity of the receiver is established as part of the sender's 739 interface configuration or it can be established through other 740 mechanisms. When generating the first Integrity Option for a 741 specific key identifier the sender requests a Kerberos service ticket 742 and gets back an ephemeral session key and a Kerberos ticket from the 743 KDC. The sender encapsulates the ticket and the identity of the 744 sender in an Identity Option of the POLICY_DATA object [10]. The 745 session key is then used by the sender as the POLICY_DATA 746 Authentication key in section 4.1 step (2) and is stored as Key 747 information associated with the key identifier. 749 Upon policy object reception, the receiver retrieves the Kerberos 750 Ticket from the Identity Option, decrypts the ticket and retrieves 751 the session key from the ticket. The session key is the same key as 752 used by the sender and is used as the key in section 4.2 step (3). 753 The receiver stores the key for use in processing subsequent policy 754 objects. 756 Kerberos tickets have lifetimes and the sender MUST NOT use tickets 757 that have expired. A new ticket MUST be requested and used by the 758 sender for the receiver prior to the ticket expiring. 760 7.1. Optimization when using Kerberos Based Authentication 762 Kerberos tickets are relatively long (> 500 bytes) and it is not 763 necessary to send a ticket in every POLICY_DATA object. The ephemeral 764 session key can be cached by the sender and receiver and can be used 765 for the lifetime of the Kerberos ticket. In this case, the sender 766 only needs to include the Kerberos ticket in the first POLICY_DATA 767 object generated. Subsequent messages use the key identifier to 768 retrieve the cached key (and optionally other identity information) 769 instead of passing tickets from sender to receiver in each 770 POLICY_DATA object. 772 A receiver may not have cached key state with an associated Key 773 Identifier due to reboot or route changes. If the receiver's policy 774 indicates the use of Kerberos keys for integrity checking, the 775 receiver can send an integrity Challenge message back to the sender. 776 Upon receiving an integrity Challenge message a sender MUST send an 777 Identity option that includes the Kerberos ticket in the integrity 778 Response message, thereby allowing the receiver to retrieve and store 779 the session key from the Kerberos ticket for subsequent Integrity 780 checking. 782 8. Acknowledgements 784 This document is derived directly from similar work done for RSVP by 785 Fred Baker, Bob Lindell and Mohit Talwar in [8]. 787 9. References 789 [1] Braden, R., Zhang, L., Berson, S., Herzog, S. and S. Jamin, 790 "Resource ReSerVation Protocol (RSVP) -- Version 1 Functional 791 Specification", RFC 2205, September 1997. 793 [2] Hess, R., Ed., Herzog, S., "RSVP Extensions for Policy Control", 794 work in progress, draft-ietf-rap-new-rsvp-ext-00.txt, June 2001. 796 [3] Baker, F., Lindell, B. and Talwar, M., "RSVP Cryptographic 797 Authentication", RFC 2747, January 2000. 799 [4] Krawczyk, H., Bellare, M. and R. Canetti, "HMAC: Keyed-Hashing 800 for Message Authentication", RFC 2104, March 1996. 802 [5] Bradner, S., "Key words for use in RFCs to Indicate Requirement 803 Levels", BCP 14, RFC 2119, March 1997. 805 [6] Atkinson, R. and S. Kent, "Security Architecture for the 806 Internet Protocol", RFC 2401, November 1998. 808 [7] Kent, S. and R. Atkinson, "IP Authentication Header", RFC 2402, 809 November 1998. 811 [8] Baker, F., Lindell, B. and Talwar, M., "RSVP Cryptographic 812 Authentication", RFC 2747, January 2000. 814 [9] Postel, J., "Transmission Control Protocol", STD 7, RFC 793, 815 September 1981. 817 [10] Yadav, S., et al., "Identity Representation for RSVP", RFC 2752, 818 January 2000. 820 [11] Maughan, D., Schertler, M., Schneider, M. and J. Turner, 821 "Internet Security Association and Key Management Protocol 822 (ISAKMP)", RFC 2408, November 1998. 824 [12] Kohl, J. and C. Neuman, "The Kerberos Network Authentication 825 Service (V5)", RFC 1510, September 1993. 827 [13] Kent, S. and R. Atkinson, "IP Encapsulating Security Payload 828 (ESP)", RFC 2406, November 1998. 830 10. Security Considerations 832 This entire memo describes and specifies an authentication mechanism 833 for RSVP POLICY_DATA objects that is believed to be secure against 834 active and passive attacks. 836 The quality of the security provided by this mechanism depends on the 837 strength of the implemented authentication algorithms, the strength 838 of the key being used, and the correct implementation of the security 839 mechanism in all communicating policy aware RSVP implementations. 840 This mechanism also depends on the POLICY_DATA Authentication Keys 841 being kept confidential by all parties. If any of these assumptions 842 are incorrect or procedures are insufficiently secure, then no real 843 security will be provided to the users of this mechanism. 845 While the handshake "Integrity Response" message is integrity- 846 checked, the handshake "Integrity Challenge" message is not. This 847 was done intentionally to avoid the case when both peering routers do 848 not have a starting sequence number for each other's key. 849 Consequently, they will each keep sending handshake "Integrity 850 Challenge" messages that will be dropped by the other end. Moreover, 851 requiring only the response to be integrity-checked eliminates a 852 dependency on an security association in the opposite direction. 854 This, however, lets an intruder generate fake handshaking challenges 855 with a certain challenge cookie. It could then save the response and 856 attempt to play it against a receiver that is in recovery. If it was 857 lucky enough to have guessed the challenge cookie used by the 858 receiver at recovery time it could use the saved response. This 859 response would be accepted, since it is properly signed, and would 860 have a smaller sequence number for the sender because it was an old 861 message. This opens the receiver up to replays. Still, it seems 862 very difficult to exploit. It requires not only guessing the 863 challenge cookie (which is based on a locally known secret) in 864 advance, but also being able to masquerade as the receiver to 865 generate a handshake "Integrity Challenge" with the proper IP address 866 and not being caught. 868 Confidentiality is not provided by this mechanism. If 869 confidentiality is required, IPsec ESP [13] may be the best approach, 870 although it is subject to the same criticisms as IPsec 871 Authentication, and therefore would be applicable only in specific 872 environments. Protection against traffic analysis is also not 873 provided. Mechanisms such as bulk link encryption might be used when 874 protection against traffic analysis is required. 876 11. Author's Address 878 Rodney Hess 879 Intel Corp, BD1 880 28 Crosby Dr 881 Bedford, MA 01730 883 EMail: rodney.hess@intel.com 885 Appendix A: Key Management Interface 887 This appendix describes a generic interface to Key Management. This 888 description is at an abstract level realizing that implementations 889 may need to introduce small variations to the actual interface. 891 At the start of execution, a policy aware RSVP system would use this 892 interface to obtain the current set of relevant keys for sending and 893 receiving POLICY_DATA objects. During execution, it can query for 894 specific keys given a Key Identifier and Source Address, discover 895 newly created keys, and be informed of those keys that have been 896 deleted. The interface provides both a polling and asynchronous 897 upcall style for wider applicability. 899 A.1. Data Structures 901 Information about keys is returned using the following KeyInfo data 902 structure: 904 KeyInfo { 905 Key Type (Send or Receive) 906 KeyIdentifier 907 Key 908 Authentication Algorithm Type and Mode 909 KeyStartValid 910 KeyEndValid 911 Status (Active or Deleted) 912 Outgoing Interface (for Send only) 913 Other Outgoing Security Association Selection Criteria 914 (for Send only, optional) 915 Sending System Address (for Receive Only) 916 } 918 A.2. Default Key Table 920 This function returns a list of KeyInfo data structures corresponding 921 to all of the keys that are configured for sending and receiving 922 POLICY_DATA objects and have an Active Status. This function is 923 usually called at the start of execution but there is no limit on the 924 number of times that it may be called. 926 KM_DefaultKeyTable() -> KeyInfoList 928 A.3. Querying for Unknown Receive Keys 930 When a message arrives with an unknown Key Identifier and Sending 931 System Address pair, PEP can use this function to query the Key 932 Management System for the appropriate key. The status of the element 933 returned, if any, must be Active. 935 KM_GetRecvKey( INTEGRITY Object, SrcAddress ) -> KeyInfo 937 A.4. Polling for Updates 939 This function returns a list of KeyInfo data structures corresponding 940 to any incremental changes that have been made to the default key 941 table or requested keys since the last call to either 942 KM_KeyTablePoll, KM_DefaultKeyTable, or KM_GetRecvKey. The status of 943 some elements in the returned list may be set to Deleted. 945 KM_KeyTablePoll() -> KeyInfoList 947 A.5. Asynchronous Upcall Interface 949 Rather than repeatedly calling the KM_KeyTablePoll(), an 950 implementation may choose to use an asynchronous event model. This 951 function registers interest to key changes for a given Key Identifier 952 or for all keys if no Key Identifier is specified. The upcall 953 function is called each time a change is made to a key. 955 KM_KeyUpdate ( Function [, KeyIdentifier ] ) 957 where the upcall function is parameterized as follows: 959 Function ( KeyInfo ) 961 Full Copyright Statement 963 Copyright (C) The Internet Society (2001). All Rights Reserved. 965 This document and translations of it may be copied and furnished to 966 others, and derivative works that comment on or otherwise explain it 967 or assist in its implementation may be prepared, copied, published 968 and distributed, in whole or in part, without restriction of any 969 kind, provided that the above copyright notice and this paragraph are 970 included on all such copies and derivative works. However, this 971 document itself may not be modified in any way, such as by removing 972 the copyright notice or references to the Internet Society or other 973 Internet organizations, except as needed for the purpose of 974 developing Internet standards in which case the procedures for 975 copyrights defined in the Internet Standards process must be 976 followed, or as required to translate it into languages other than 977 English. 979 The limited permissions granted above are perpetual and will not be 980 revoked by the Internet Society or its successors or assigns. 982 This document and the information contained herein is provided on an 983 "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING 984 TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING 985 BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION 986 HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF 987 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 989 Acknowledgement 991 Funding for the RFC Editor function is currently provided by the 992 Internet Society.