As per Relevance of the word integrity, we have this rfc below:
Network Working Group F.
Request for Comments: 2747
Category: Standards Track B.
USC/
M.
January 2000
RSVP Cryptographic
Status of this
This document specifies an Internet standards track protocol for
Internet community, and requests discussion and suggestions
improvements. Please refer to the current edition of the "
Official Protocol Standards" (STD 1) for the standardization
and status of this protocol. Distribution of this memo is unlimited
Copyright
Copyright (C) The Internet Society (2000). All Rights Reserved
This document describes the format and use of RSVP's INTEGRITY
to provide hop-by-hop integrity and authentication of RSVP messages
1.
The Resource ReSerVation Protocol RSVP [1] is a protocol for
up distributed state in routers and hosts, and in particular
reserving resources to implement integrated service. RSVP
particular users to obtain preferential access to network resources
under the control of an admission control mechanism. Permission
make a reservation will depend both upon the availability of
requested resources along the path of the data, and upon
of policy rules
To ensure the integrity of this admission control mechanism,
requires the ability to protect its messages against corruption
spoofing. This document defines a mechanism to protect RSVP
integrity hop-by-hop. The proposed scheme transmits
authenticating digest of the message, computed using a
Authentication Key and a keyed-hash algorithm. This scheme
protection against forgery or message modification. The
object of each RSVP message is tagged with a one-time-use
Baker, et al. Standards Track [Page 1]
RFC 2747 RSVP Cryptographic Authentication January 2000
number. This allows the message receiver to identify playbacks
hence to thwart replay attacks. The proposed mechanism does
afford confidentiality, since messages stay in the clear; however
the mechanism is also exportable from most countries, which would
impossible were a privacy algorithm to be used. Note: this
uses the terms "sender" and "receiver" differently from [1].
are used here to refer to systems that face each other across an
hop, the "sender" being the system generating RSVP messages
The message replay prevention algorithm is quite simple. The
generates packets with monotonically increasing sequence numbers.
turn, the receiver only accepts packets that have a larger
number than the previous packet. To start this process, a
handshakes with the sender to get an initial sequence number.
memo discusses ways to relax the strictness of the in-order
of messages as well as techniques to generate
increasing sequence numbers that are robust across sender
and restarts
The proposed mechanism is independent of a specific
algorithm, but the document describes the use of Keyed-Hashing
Message Authentication using HMAC-MD5 [7]. As noted in [7],
exist stronger hashes, such as HMAC-SHA1; where warranted
implementations will do well to make them available. However, in
general case, [7] suggests that HMAC-MD5 is adequate to the
at hand and has preferable performance characteristics. [7]
offers source code and test vectors for this algorithm, a boon
those who would test for interoperability. HMAC-MD5 is required as
baseline to be universally included in RSVP implementations
cryptographic authentication, with other proposals optional (
Section 6 on Conformance Requirements).
The RSVP checksum MAY be disabled (set to zero) when the
object is included in the message, as the message digest is a
stronger integrity check
1.1. Conventions used in this
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in
document are to be interpreted as described in [8].
1.2. Why not use the Standard IPSEC Authentication Header
One obvious question is why, since there exists a
authentication mechanism, IPSEC [3,5], we would choose not to use it
This was discussed at length in the working group, and the use
IPSEC was rejected for the following reasons
Baker, et al. Standards Track [Page 2]
RFC 2747 RSVP Cryptographic Authentication January 2000
The security associations in IPSEC are based on destination address
It is not clear that RSVP messages are well defined for either
or destination based security associations, as a router must
PATH and PATH TEAR messages using the same source address as
sender listed in the SENDER TEMPLATE. RSVP traffic may otherwise
follow exactly the same path as data traffic. Using either source
destination based associations would require opening a new
association among the routers for which a reservation traverses
In addition, it was noted that neighbor relationships between
systems are not limited to those that face one another across
communication channel. RSVP relationships across non-RSVP clouds
such as those described in Section 2.9 of [1], are not
visible to the sending system. These arguments suggest the use of
key management strategy based on RSVP router to RSVP
associations instead of IPSEC
2. Data
2.1. INTEGRITY Object
An RSVP message consists of a sequence of "objects," which are type
length-value encoded fields having specific purposes.
information required for hop-by-hop integrity checking is carried
an INTEGRITY object. The same INTEGRITY object type is used for
IPv4 and IPv6.
The INTEGRITY object has the following format
Keyed Message Digest INTEGRITY Object: Class = 4, C-Type = 1
+-------------+-------------+-------------+-------------+
| Flags | 0 (Reserved)| |
+-------------+-------------+ +
| Key Identifier |
+-------------+-------------+-------------+-------------+
| Sequence Number |
| |
+-------------+-------------+-------------+-------------+
| |
+ +
| |
+ Keyed Message Digest |
| |
+ +
| |
+-------------+-------------+-------------+-------------+
Baker, et al. Standards Track [Page 3]
RFC 2747 RSVP Cryptographic Authentication January 2000
o Flags: An 8-bit field with the following format
0 1 2 3 4 5 6 7
+---+---+---+---+---+---+---+---+
| H | |
| F | 0 |
+---+---+---+---+---+---+---+---+
Currently only one flag (HF) is defined. The remaining
are reserved for future use and MUST be set to 0.
o Bit 0: Handshake Flag (HF) concerns the
handshake mechanism (Section 4.3). Message
willing to respond to integrity handshake messages
set this flag to 1 whereas those that will
integrity handshake messages SHOULD set this to 0.
o Key Identifier: An unsigned 48-bit number that MUST be
for a given sender. Locally unique Key Identifiers can
generated using some combination of the address (IP or MAC
LIH) of the sending interface and the key number.
combination of the Key Identifier and the sending system's
address uniquely identifies the security association (
2.2).
o Sequence Number: An unsigned 64-bit monotonically increasing
unique sequence number
Sequence Number values may be any monotonically
sequence that provides the INTEGRITY object [of each
message] with a tag that is unique for the associated key'
lifetime. Details on sequence number generation are
in Section 3.
o Keyed Message Digest: The digest MUST be a multiple of 4
octets long. For HMAC-MD5, it will be 16 bytes long
2.2. Security
The sending and receiving systems maintain a security association
each authentication key that they share. This security
includes the following parameters
Baker, et al. Standards Track [Page 4]
RFC 2747 RSVP Cryptographic Authentication January 2000
o Authentication algorithm and algorithm mode being used
o Key used with the authentication algorithm
o Lifetime of the key
o Associated sending interface and other security
selection criteria [REQUIRED at Sending System].
o Source Address of the sending system [REQUIRED at
System].
o Latest sending sequence number used with this key
[REQUIRED at Sending System].
o List of last N sequence numbers received with this
identifier [REQUIRED at Receiving System].
3. Generating Sequence
In this section we describe methods that could be chosen to
the sequence numbers used in the INTEGRITY object of an RSVP message
As previous stated, there are two important properties that MUST
satisfied by the generation procedure. The first property is
the sequence numbers are unique, or one-time, for the lifetime of
integrity key that is in current use. A receiver can use
property to unambiguously distinguish between a new or a
message. The second property is that the sequence numbers
generated in monotonically increasing order, modulo 2^64. This
required to greatly reduce the amount of saved state, since
receiver only needs to save the value of the highest sequence
seen to avoid a replay attack. Since the starting sequence
might be arbitrarily large, the modulo operation is required
accommodate sequence number roll-over within some key's lifetime
This solution draws from TCP's approach [9].
The sequence number field is chosen to be a 64-bit unsigned quantity
This is large enough to avoid exhaustion over the key lifetime.
example, if a key lifetime was conservatively defined as one year
there would be enough sequence number values to send RSVP messages
an average rate of about 585 gigaMessages per second. A 32-
sequence number would limit this average rate to about 136
per second
The ability to generate unique monotonically increasing
numbers across a failure and restart implies some form of
storage, either local to the device or remotely over the network
Three sequence number generation procedures are described below
Baker, et al. Standards Track [Page 5]
RFC 2747 RSVP Cryptographic Authentication January 2000
3.1. Simple Sequence
The most straightforward approach is to generate a unique
number using a message counter. Each time a message is
for a given key, the sequence number counter is incremented.
current value of this counter is continually or periodically saved
stable storage. After a restart, the counter is recovered using
stable storage. If the counter was saved periodically to
storage, the count should be recovered by increasing the saved
to be larger than any possible value of the counter at the time
the failure. This can be computed, knowing the interval at which
counter was saved to stable storage and incrementing the stored
by that amount
3.2. Sequence Numbers Based on a Real Time
Most devices will probably not have the capability to save
number counters to stable storage for each key. A more
solution is to base sequence numbers on the stable storage of a
time clock. Many computing devices have a real time clock
that includes stable storage of the clock. These modules
include some form of nonvolatile memory to retain clock
in the event of a power failure
In this approach, we could use an NTP based timestamp value as
sequence number. The roll-over period of an NTP timestamp is
136 years, much longer than any reasonable lifetime of a key.
addition, the granularity of the NTP timestamp is fine enough
allow the generation of an RSVP message every 200 picoseconds for
given key. Many real time clock modules do not have the
of an NTP timestamp. In these cases, the least significant bits
the timestamp can be generated using a message counter, which
reset every clock tick. For example, when the real time
provides a resolution of 1 second, the 32 least significant bits
the sequence number can be generated using a message counter.
remaining 32 bits are filled with the 32 least significant bits
the timestamp. Assuming that the recovery time after failure
longer than one tick of the real time clock, the message counter
the low order bits can be safely reset to zero after a restart
3.3. Sequence Numbers Based on a Network Recovered
If the device does not contain any stable storage of sequence
counters or of a real time clock, it could recover the real
clock from the network using NTP. Once the clock has been
following a restart, the sequence number generation procedure
be identical to the procedure described above
Baker, et al. Standards Track [Page 6]
RFC 2747 RSVP Cryptographic Authentication January 2000
4. Message
Implementations SHOULD allow specification of interfaces that are
be secured, for either sending messages, or receiving them, or both
The sender must ensure that all RSVP messages sent on secured
interfaces include an INTEGRITY object, generated using
appropriate Key. Receivers verify whether RSVP messages, except
the type "Integrity Challenge" (Section 4.3), arriving on a
receiving interface contain the INTEGRITY object. If the
object is absent, the receiver discards the message
Security associations are simplex - the keys that a sending
uses to sign its messages may be different from the keys that
receivers use to sign theirs. Hence, each association is
with a unique sending system and (possibly) multiple
systems
Each sender SHOULD have distinct security associations (and keys)
secured sending interface (or LIH). While administrators
configure all the routers and hosts on a subnet (or for that matter
in their network) using a single security association
implementations MUST assume that each sender may send using
distinct security association on each secured interface. At
sender, security association selection is based on the
through which the message is sent. This selection MAY
additional criteria, such as the destination address (when
the message unicast, over a broadcast LAN with a large number
hosts) or user identities at the sender or receivers [2]. Finally
all intended message recipients should participate in this
association. Route flaps in a non RSVP cloud might cause
for the same receiver to be sent on different interfaces at
times. In such cases, the receivers should participate in
possible security associations that may be selected for
interfaces through which the message might be sent
Receivers select keys based on the Key Identifier and the
system's IP address. The Key Identifier is included in the
object. The sending system's address can be obtained either from
RSVP_HOP object, or if that's not present (as is the case
PathErr and ResvConf messages) from the IP source address. Since
Key Identifier is unique for a sender, this method
identifies the key
The integrity mechanism slightly modifies the processing rules
RSVP messages, both when including the INTEGRITY object in a
sent over a secured sending interface and when accepting a
received on a secured receiving interface. These modifications
detailed below
Baker, et al. Standards Track [Page 7]
RFC 2747 RSVP Cryptographic Authentication January 2000
4.1. Message
For an RSVP message sent over a secured sending interface,
message is created as described in [1], with these exceptions
(1) The RSVP checksum field is set to zero. If required, an
checksum can be calculated when the processing of
INTEGRITY object is complete
(2) The INTEGRITY object is inserted in the appropriate place,
its location in the message is remembered for later use
(3) The sending interface and other appropriate criteria (
mentioned above) are used to determine the Authentication
and the hash algorithm to be used
(4) The unused flags and the reserved field in the
object MUST be set to 0. The Handshake Flag (HF) should
set according to rules specified in Section 2.1.
(5) The sending sequence number MUST be updated to ensure
unique, monotonically increasing number. It is then placed
the Sequence Number field of the INTEGRITY object
(6) The Keyed Message Digest field is set to zero
(7) The Key Identifier is placed into the INTEGRITY object
(8) An authenticating digest of the message is computed using
Authentication Key in conjunction with the keyed-
algorithm. When the HMAC-MD5 algorithm is used, the
calculation is described in [7].
(9) The digest is written into the Cryptographic Digest field
the INTEGRITY object
4.2. Message
When the message is received on a secured receiving interface, and
not of the type "Integrity Challenge", it is processed in
following manner
(1) The RSVP checksum field is saved and the field is
set to zero
(2) The Cryptographic Digest field of the INTEGRITY object
saved and the field is subsequently set to zero
Baker, et al. Standards Track [Page 8]
RFC 2747 RSVP Cryptographic Authentication January 2000
(3) The Key Identifier field and the sending system address
used to uniquely determine the Authentication Key and the
algorithm to be used. Processing of this packet might
delayed when the Key Management System (Appendix 1) is
for this information
(4) A new keyed-digest is calculated using the indicated
and the Authentication Key
(5) If the calculated digest does not match the received digest
the message is discarded without further processing
(6) If the message is of type "Integrity Response", verify
the CHALLENGE object identically matches the
challenge. If it matches, save the sequence number in
INTEGRITY object as the largest sequence number received
date
Otherwise, for all other RSVP Messages, the sequence number
validated to prevent replay attacks, and messages with
sequence numbers are ignored by the receiver
When a message is accepted, the sequence number of
message could update a stored value corresponding to
largest sequence number received to date. Each
message must then have a larger (modulo 2^64) sequence
to be accepted. This simple processing rule prevents
replay attacks, but it must be modified to tolerate
out-of-order message delivery. For example, if
messages were sent in a burst (in a periodic refresh
by a router, or as a result of a tear down function),
might get reordered and then the sequence numbers would not
received in an increasing order
An implementation SHOULD allow administrative
that sets the receiver's tolerance to out-of-order
delivery. A simple approach would allow administrators
specify a message window corresponding to the worst
reordering behavior. For example, one might specify
packets reordered within a 32 message window would
accepted. If no reordering can occur, the window is set
one
The receiver must store a list of all sequence numbers
within the reordering window. A received sequence number
valid if (a) it is greater than the maximum sequence
received or (b) it is a past sequence number lying within
reordering window and not recorded in the list. Acceptance
Baker, et al. Standards Track [Page 9]
RFC 2747 RSVP Cryptographic Authentication January 2000
a sequence number implies adding it to the list and removing
number from the lower end of the list. Messages received
sequence numbers lying below the lower end of the list
marked seen in the list are discarded
When an "Integrity Challenge" message is received on a
sending interface it is processed in the following manner
(1) An "Integrity Response" message is formed using the
object received in the challenge message
(2) The message is sent back to the receiver, based on the
IP address of the challenge message, using the "
Generation" steps outlined above. The selection of
Authentication Key and the hash algorithm to be used
determined by the key identifier supplied in the
message
4.3. Integrity Handshake at Restart or Initialization of the
To obtain the starting sequence number for a live Authentication Key
the receiver MAY initiate an integrity handshake with the sender
This handshake consists of a receiver's Challenge and the sender'
Response, and may be either initiated during restart or
until a message signed with that key arrives
Once the receiver has decided to initiate an integrity handshake
a particular Authentication Key, it identifies the sender using
sending system's address configured in the corresponding
association. The receiver then sends an RSVP Integrity
message to the sender. This message contains the Key Identifier
identify the sender's key and MUST have a unique challenge
that is based on a local secret to prevent guessing. see
2.5.3 of [4]). It is suggested that the cookie be an MD5 hash of
local secret and a timestamp to provide uniqueness (see Section 9).
An RSVP Integrity Challenge message will carry a message type of 11.
The message format is as follows
<Integrity Challenge message> ::= <CHALLENGE
Baker, et al. Standards Track [Page 10]
RFC 2747 RSVP Cryptographic Authentication January 2000
he CHALLENGE object has the following format
CHALLENGE Object: Class = 64, C-Type = 1
+-------------+-------------+-------------+-------------+
| 0 (Reserved) | |
+-------------+-------------+ +
| Key Identifier |
+-------------+-------------+-------------+-------------+
| Challenge Cookie |
| |
+-------------+-------------+-------------+-------------+
The sender accepts the "Integrity Challenge" without doing
integrity check. It returns an RSVP "Integrity Response"
that contains the original CHALLENGE object. It also includes
INTEGRITY object, signed with the key specified by the Key
included in the "Integrity Challenge".
An RSVP Integrity Response message will carry a message type of 12.
The message format is as follows
<Integrity Response message> ::= <INTEGRITY
<CHALLENGE
The "Integrity Response" message is accepted by the
(challenger) only if the returned CHALLENGE object matches the
sent in the "Integrity Challenge" message. This prevents replay
old "Integrity Response" messages. If the match is successful,
receiver saves the Sequence Number from the INTEGRITY object as
latest sequence number received with the key identifier included
the CHALLENGE
If a response is not received within a given period of time,
challenge is repeated. When the integrity handshake
completes, the receiver begins accepting normal RSVP
messages from that sender and ignores any other "Integrity Response
messages
The Handshake Flag (HF) is used to allow implementations
flexibility of not including the integrity handshake mechanism.
setting this flag to 1, message senders that implement the
handshake distinguish themselves from those that do not.
SHOULD NOT attempt to handshake with senders whose INTEGRITY
has HF = 0.
Baker, et al. Standards Track [Page 11]
RFC 2747 RSVP Cryptographic Authentication January 2000
An integrity handshake may not be necessary in all environments.
common use of RSVP integrity will be between peering domain routers
which are likely to be processing a steady stream of RSVP
due to aggregation effects. When a router restarts after a crash
valid RSVP messages from peering senders will probably arrive
a short time. Assuming that replay messages are injected into
stream of valid RSVP messages, there may be only a small window
opportunity for a replay attack before a valid message is processed
This valid message will set the largest sequence number seen to
value greater than any number that had been stored prior to
crash, preventing any further replays
On the other hand, not using an integrity handshake could
exposure to replay attacks if there is a long period of silence
a given sender following a restart of a receiver. Hence, it
be an administrative decision whether or not the receiver performs
integrity handshake with senders that are willing to respond
"Integrity Challenge" messages, and whether it accepts any
from senders that refuse to do so. These decisions will be based
assumptions related to a particular network environment
5. Key
It is likely that the IETF will define a standard key
protocol. It is strongly desirable to use that key
protocol to distribute RSVP Authentication Keys among
RSVP implementations. Such a protocol would provide scalability
significantly reduce the human administrative burden. The
Identifier can be used as a hook between RSVP and such a
protocol. Key management protocols have a long history of
flaws that are often discovered long after the protocol was
described in public. To avoid having to change all
implementations should such a flaw be discovered, integrated
management protocol techniques were deliberately omitted from
specification
5.1. Key Management
Each key has a lifetime associated with it that is recorded in
systems (sender and receivers) configured with that key. The
of a "key lifetime" merely requires that the earliest (KeyStartValid
and latest (KeyEndValid) times that the key is valid be
in a way the system understands. Certain key generation mechanisms
such as Kerberos or some public key schemes, may directly
ephemeral keys. In this case, the lifetime of the key is
defined as part of the key
Baker, et al. Standards Track [Page 12]
RFC 2747 RSVP Cryptographic Authentication January 2000
In general, no key is ever used outside its lifetime (but see
5.3). Possible mechanisms for managing key lifetime include
Network Time Protocol and hardware time-of-day clocks
To maintain security, it is advisable to change the
Authentication Key on a regular basis. It should be possible
switch the RSVP Authentication Key without loss of RSVP state
denial of reservation service, and without requiring people to
all the keys at once. This requires an RSVP implementation
support the storage and use of more than one active
Authentication Key at the same time. Hence both the sender
receivers might have multiple active keys for a given
association
Since keys are shared between a sender and (possibly)
receivers, there is a region of uncertainty around the time of
switch-over during which some systems may still be using the old
and others might have switched to the new key. The size of
uncertainty region is related to clock synchrony of the systems
Administrators should configure the overlap between the
time of the old key (KeyEndValid) and the validity of the new
(KeyStartValid) to be at least twice the size of this
interval. This will allow the sender to make the key switch-over
the midpoint of this interval and be confident that all receivers
now accepting the new key. For the duration of the overlap in
lifetimes, a receiver must be prepared to authenticate messages
either key
During a key switch-over, it will be necessary for each receiver
handshake with the sender using the new key. As stated before,
receiver has the choice of initiating a handshake during
switchover or postponing the handshake until the receipt of a
using that key
5.2. Key Management
Requirements on an implementation are as follows
o It is strongly desirable that a hypothetical security
in one Internet protocol not automatically compromise
Internet protocols. The Authentication Key of
specification SHOULD NOT be stored using protocols
algorithms that have known flaws
o An implementation MUST support the storage and use of
than one key at the same time, for both sending and
systems
Baker, et al. Standards Track [Page 13]
RFC 2747 RSVP Cryptographic Authentication January 2000
o An implementation MUST associate a specific lifetime (i.e.,
KeyStartValid and KeyEndValid) with each key and
corresponding Key Identifier
o An implementation MUST support manual key distribution (e.g.,
the privileged user manually typing in the key, key lifetime
and key identifier on the console). The lifetime may
infinite
o If more than one algorithm is supported, then
implementation MUST require that the algorithm be
for each key at the time the other key information is entered
o Keys that are out of date MAY be automatically deleted by
implementation
o Manual deletion of active keys MUST also be supported
o Key storage SHOULD persist across a system restart, warm
cold, to ease operational usage
5.3. Pathological
It is possible that the last key for a given security association
expired. When this happens, it is unacceptable to revert to
unauthenticated condition, and not advisable to disrupt
reservations. Therefore, the system should send a "
authentication key expiration" notification to the network
and treat the key as having an infinite lifetime until the
is extended, the key is deleted by network management, or a new
is configured
6. Conformance
To conform to this specification, an implementation MUST support
of its aspects. The HMAC-MD5 authentication algorithm defined in [7]
MUST be implemented by all conforming implementations. A
implementation MAY also support other authentication algorithms
as NIST's Secure Hash Algorithm (SHA). Manual key distribution
described above MUST be supported by all conforming implementations
All implementations MUST support the smooth key roll over
under "Key Management Procedures."
Implementations SHOULD support a standard key management protocol
secure distribution of RSVP Authentication Keys once such a
management protocol is standardized by the IETF
Baker, et al. Standards Track [Page 14]
RFC 2747 RSVP Cryptographic Authentication January 2000
7. Kerberos generation of RSVP Authentication
Kerberos[10] MAY be used to generate the RSVP Authentication key
in generating a signature in the Integrity Object sent from a
sender to a receiver. Kerberos key generation avoids the use
shared keys between RSVP senders and receivers such as hosts
routers. Kerberos allows for the use of trusted third party
relationships between security principals (RSVP sender and receivers
where the Kerberos key distribution center(KDC) establishes
ephemeral session key that is subsequently shared between RSVP
and receivers. In the multicast case all receivers of a
RSVP message MUST share a single key with the KDC (e.g. the
are in effect the same security principal with respect to Kerberos).
The Key information determined by the sender MAY specify the use
Kerberos in place of configured shared keys as the mechanism
establishing a key between the sender and receiver. The
identity of the receiver is established as part of the sender'
interface configuration or it can be established through
mechanisms. When generating the first RSVP message for a
key identifier the sender requests a Kerberos service ticket and
back an ephemeral session key and a Kerberos ticket from the KDC
The sender encapsulates the ticket and the identity of the sender
an Identity Policy Object[2]. The sender includes the Policy
in the RSVP message. The session key is then used by the sender
the RSVP Authentication key in section 4.1 step (3) and is stored
Key information associated with the key identifier
Upon RSVP Message reception, the receiver retrieves the
Ticket from the Identity Policy Object, decrypts the ticket
retrieves the session key from the ticket. The session key is
same key as used by the sender and is used as the key in section 4.2
step (3). The receiver stores the key for use in
subsequent RSVP messages
Kerberos tickets have lifetimes and the sender MUST NOT use
that have expired. A new ticket MUST be requested and used by
sender for the receiver prior to the ticket expiring
7.1. Optimization when using Kerberos Based
Kerberos tickets are relatively long (> 500 bytes) and it is
necessary to send a ticket in every RSVP message. The
session key can be cached by the sender and receiver and can be
for the lifetime of the Kerberos ticket. In this case, the
only needs to include the Kerberos ticket in the first
generated. Subsequent RSVP messages use the key identifier
Baker, et al. Standards Track [Page 15]
RFC 2747 RSVP Cryptographic Authentication January 2000
retrieve the cached key (and optionally other identity information
instead of passing tickets from sender to receiver in each
message
A receiver may not have cached key state with an associated
Identifier due to reboot or route changes. If the receiver's
indicates the use of Kerberos keys for integrity checking,
receiver can send an integrity Challenge message back to the sender
Upon receiving an integrity Challenge message a sender MUST send
Identity object that includes the Kerberos ticket in the
Response message, thereby allowing the receiver to retrieve and
the session key from the Kerberos ticket for subsequent
checking
8.
This document is derived directly from similar work done for OSPF
RIP Version II, jointly by Ran Atkinson and Fred Baker.
editing was done by Bob Braden, resulting in increased clarity
Significant comments were submitted by Steve Bellovin, who
understands this stuff. Matt Crawford and Dan Harkins helped
the document
9.
[1] Braden, R., Zhang, L., Berson, S., Herzog, S. and S. Jamin
"Resource ReSerVation Protocol (RSVP) -- Version 1
Specification", RFC 2205, September 1997.
[2] Yadav, S., et al., "Identity Representation for RSVP", RFC 2752,
January 2000.
[3] Atkinson, R. and S. Kent, "Security Architecture for
Internet Protocol", RFC 2401, November 1998.
[4] Maughan, D., Schertler, M., Schneider, M. and J. Turner
"Internet Security Association and Key Management
(ISAKMP)", RFC 2408, November 1998.
[5] Kent, S. and R. Atkinson, "IP Authentication Header", RFC 2402,
November 1998.
[6] Kent, S. and R. Atkinson, "IP Encapsulating Security
(ESP)", RFC 2406, November 1998.
[7] Krawczyk, H., Bellare, M. and R. Canetti, "HMAC: Keyed-
for Message Authentication", RFC 2104, March 1996.
Baker, et al. Standards Track [Page 16]
RFC 2747 RSVP Cryptographic Authentication January 2000
[8] Bradner, S., "Key words for use in RFCs to Indicate
Levels", BCP 14, RFC 2119, March 1997.
[9] Postel, J., "Transmission Control Protocol", STD 7, RFC 793,
September 1981.
[10] Kohl, J. and C. Neuman, "The Kerberos Network
Service (V5)", RFC 1510, September 1993.
10. Security
This entire memo describes and specifies an authentication
for RSVP that is believed to be secure against active and
attacks
The quality of the security provided by this mechanism depends on
strength of the implemented authentication algorithms, the
of the key being used, and the correct implementation of the
mechanism in all communicating RSVP implementations. This
also depends on the RSVP Authentication Keys being kept
by all parties. If any of these assumptions are incorrect
procedures are insufficiently secure, then no real security will
provided to the users of this mechanism
While the handshake "Integrity Response" message is integrity
checked, the handshake "Integrity Challenge" message is not.
was done intentionally to avoid the case when both peering routers
not have a starting sequence number for each other's key
Consequently, they will each keep sending handshake "
Challenge" messages that will be dropped by the other end. Moreover
requiring only the response to be integrity-checked eliminates
dependency on an security association in the opposite direction
This, however, lets an intruder generate fake handshaking
with a certain challenge cookie. It could then save the response
attempt to play it against a receiver that is in recovery. If it
lucky enough to have guessed the challenge cookie used by
receiver at recovery time it could use the saved response.
response would be accepted, since it is properly signed, and
have a smaller sequence number for the sender because it was an
message. This opens the receiver up to replays. Still, it seems
difficult to exploit. It requires not only guessing the
cookie (which is based on a locally known secret) in advance,
also being able to masquerade as the receiver to generate a
"Integrity Challenge" with the proper IP address and not
caught
Baker, et al. Standards Track [Page 17]
RFC 2747 RSVP Cryptographic Authentication January 2000
Confidentiality is not provided by this mechanism.
confidentiality is required, IPSEC ESP [6] may be the best approach
although it is subject to the same criticisms as
Authentication, and therefore would be applicable only in
environments. Protection against traffic analysis is also
provided. Mechanisms such as bulk link encryption might be used
protection against traffic analysis is required
11. Authors'
Fred
Cisco
519 Lado
Santa Barbara, CA 93111
Phone: (408) 526-4257
EMail: fred@cisco.
Bob
USC Information Sciences
4676 Admiralty
Marina del Rey, CA 90292
Phone: (310) 822-1511
EMail: lindell@ISI.
Mohit
Microsoft
One Microsoft
Redmond, WA 98052
Phone: +1 425 705 3131
EMail: mohitt@microsoft.
Baker, et al. Standards Track [Page 18]
RFC 2747 RSVP Cryptographic Authentication January 2000
12. Appendix 1: Key Management
This appendix describes a generic interface to Key Management.
description is at an abstract level realizing that
may need to introduce small variations to the actual interface
At the start of execution, RSVP would use this interface to
the current set of relevant keys for sending and receiving messages
During execution, RSVP can query for specific keys given a
Identifier and Source Address, discover newly created keys, and
informed of those keys that have been deleted. The
provides both a polling and asynchronous upcall style for
applicability
12.1. Data
Information about keys is returned using the following KeyInfo
structure
KeyInfo {
Key Type (Send or Receive
Authentication Algorithm Type and
Status (Active or Deleted
Outgoing Interface (for Send only
Other Outgoing Security Association Selection
(for Send only, optional
Sending System Address (for Receive Only
}
12.2. Default Key
This function returns a list of KeyInfo data structures
to all of the keys that are configured for sending and receiving
messages and have an Active Status. This function is usually
at the start of execution but there is no limit on the number
times that it may be called
KM_DefaultKeyTable() ->
Baker, et al. Standards Track [Page 19]
RFC 2747 RSVP Cryptographic Authentication January 2000
12.3. Querying for Unknown Receive
When a message arrives with an unknown Key Identifier and
System Address pair, RSVP can use this function to query the
Management System for the appropriate key. The status of the
returned, if any, must be Active
KM_GetRecvKey( INTEGRITY Object, SrcAddress ) ->
12.4. Polling for
This function returns a list of KeyInfo data structures
to any incremental changes that have been made to the default
table or requested keys since the last call to
KM_KeyTablePoll, KM_DefaultKeyTable, or KM_GetRecvKey. The status
some elements in the returned list may be set to Deleted
KM_KeyTablePoll() ->
12.5. Asynchronous Upcall
Rather than repeatedly calling the KM_KeyTablePoll(),
implementation may choose to use an asynchronous event model.
function registers interest to key changes for a given Key
or for all keys if no Key Identifier is specified. The
function is called each time a change is made to a key
KM_KeyUpdate ( Function [, KeyIdentifier ] )
where the upcall function is parameterized as follows
Function ( KeyInfo )
Baker, et al. Standards Track [Page 20]
RFC 2747 RSVP Cryptographic Authentication January 2000
13. Full Copyright
Copyright (C) The Internet Society (2000). All Rights Reserved
This document and translations of it may be copied and furnished
others, and derivative works that comment on or otherwise explain
or assist in its implementation may be prepared, copied,
and distributed, in whole or in part, without restriction of
kind, provided that the above copyright notice and this paragraph
included on all such copies and derivative works. However,
document itself may not be modified in any way, such as by
the copyright notice or references to the Internet Society or
Internet organizations, except as needed for the purpose
developing Internet standards in which case the procedures
copyrights defined in the Internet Standards process must
followed, or as required to translate it into languages other
English
The limited permissions granted above are perpetual and will not
revoked by the Internet Society or its successors or assigns
This document and the information contained herein is provided on
"AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET
TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
Funding for the RFC Editor function is currently provided by
Internet Society
Baker, et al. Standards Track [Page 21]
if you see any problems within the linking, don't worry be happy,
this is version 0.1 of the Relevance System and you gotta expect some crappy subroutines sometimes,
just be content we did not write this in Java, which would have made this "bigger and better" HAHAHHA.
RFC documents can be found at I.E.T.F.
Relevance System Copyright © 2002 Spectrum WorldResearch
other technical nosh by ServerMasters Corporation
collaboration of BobX
