| 1 |
<pre>Network Working Group E. Baize |
| 2 |
Request for Comments: 2478 D. Pinkas |
| 3 |
Category: Standards Track Bull |
| 4 |
December 1998 |
| 5 |
|
| 6 |
|
| 7 |
<span class="h1">The Simple and Protected GSS-API Negotiation Mechanism</span> |
| 8 |
|
| 9 |
Status of this Memo |
| 10 |
|
| 11 |
This document specifies an Internet standards track protocol for the |
| 12 |
Internet community, and requests discussion and suggestions for |
| 13 |
improvements. Please refer to the current edition of the "Internet |
| 14 |
Official Protocol Standards" (STD 1) for the standardization state |
| 15 |
and status of this protocol. Distribution of this memo is unlimited. |
| 16 |
|
| 17 |
Copyright Notice |
| 18 |
|
| 19 |
Copyright (C) The Internet Society (1998). All Rights Reserved. |
| 20 |
|
| 21 |
<span class="h2"><a class="selflink" id="section-1" href="#section-1">1</a>. ABSTRACT</span> |
| 22 |
|
| 23 |
This document specifies a Security Negotiation Mechanism for the |
| 24 |
Generic Security Service Application Program Interface (GSS-API) |
| 25 |
which is described in [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>]. |
| 26 |
|
| 27 |
The GSS-API provides a generic interface which can be layered atop |
| 28 |
different security mechanisms such that if communicating peers |
| 29 |
acquire GSS-API credentials for the same security mechanism, then a |
| 30 |
security context may be established between them (subject to policy). |
| 31 |
However, GSS-API doesn't prescribe the method by which GSS-API peers |
| 32 |
can establish whether they have a common security mechanism. |
| 33 |
|
| 34 |
The Simple and Protected GSS-API Negotiation Mechanism defined here |
| 35 |
is a pseudo-security mechanism, represented by the object identifier |
| 36 |
iso.org.dod.internet.security.mechanism.snego (1.3.6.1.5.5.2) which |
| 37 |
enables GSS-API peers to determine in-band whether their credentials |
| 38 |
share common GSS-API security mechanism(s), and if so, to invoke |
| 39 |
normal security context establishment for a selected common security |
| 40 |
mechanism. This is most useful for applications that are based on |
| 41 |
GSS-API implementations which support multiple security mechanisms. |
| 42 |
|
| 43 |
This allows to negotiate different security mechanisms, different |
| 44 |
options within a given security mechanism or different options from |
| 45 |
several security mechanisms. |
| 46 |
|
| 47 |
|
| 48 |
|
| 49 |
|
| 50 |
|
| 51 |
|
| 52 |
<span class="grey">Baize & Pinkas Standards Track [Page 1]</span></pre> |
| 53 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-2" ></span> |
| 54 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 55 |
|
| 56 |
|
| 57 |
Once the common security mechanism is identified, the security |
| 58 |
mechanism may also negotiate mechanism-specific options during its |
| 59 |
context establishment. This will be inside the mechanism tokens, and |
| 60 |
invisible to the SPNEGO protocol. |
| 61 |
|
| 62 |
The simple and protected GSS-API mechanism negotiation is based on |
| 63 |
the following negotiation model : the initiator proposes one security |
| 64 |
mechanism or an ordered list of security mechanisms, the target |
| 65 |
either accepts the proposed security mechanism, or chooses one from |
| 66 |
an offered set, or rejects the proposed value(s). The target then |
| 67 |
informs the initiator of its choice. |
| 68 |
|
| 69 |
In its basic form this protocol requires an extra-round trip. Network |
| 70 |
connection setup is a critical performance characteristic of any |
| 71 |
network infrastructure and extra round trips over WAN links, packet |
| 72 |
radio networks, etc. really make a difference. In order to avoid such |
| 73 |
an extra round trip the initial security token of the preferred |
| 74 |
mechanism for the initiator may be embedded in the initial token. If |
| 75 |
the target preferred mechanism matches the initiator's preferred |
| 76 |
mechanism, no additional round trips are incurred by using the |
| 77 |
negotiation protocol. |
| 78 |
|
| 79 |
The simple and protected GSS-API mechanism negotiation provides a |
| 80 |
technique to protect the negotiation that must be used when the |
| 81 |
underlying mechanism selected by the target is capable of integrity |
| 82 |
protection. |
| 83 |
|
| 84 |
When all the mechanisms proposed by the initiator support integrity |
| 85 |
protection or when the selected mechanism supports integrity |
| 86 |
protection, then the negotiation mechanism becomes protected since |
| 87 |
this guarantees that the appropriate mechanism supported by both |
| 88 |
peers has been selected. |
| 89 |
|
| 90 |
The Simple and Protected GSS-API Negotiation Mechanism uses the |
| 91 |
concepts developed in the GSS-API specification [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>]. The negotiation |
| 92 |
data is encapsulated in context-level tokens. Therefore, callers of |
| 93 |
the GSS-API do not need to be aware of the existence of the |
| 94 |
negotiation tokens but only of the new pseudo-security mechanism. A |
| 95 |
failure in the negotiation phase causes a major status code to be |
| 96 |
returned: GSS_S_BAD_MECH. |
| 97 |
|
| 98 |
|
| 99 |
|
| 100 |
|
| 101 |
|
| 102 |
|
| 103 |
|
| 104 |
|
| 105 |
|
| 106 |
|
| 107 |
|
| 108 |
<span class="grey">Baize & Pinkas Standards Track [Page 2]</span></pre> |
| 109 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-3" ></span> |
| 110 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 111 |
|
| 112 |
|
| 113 |
<span class="h2"><a class="selflink" id="section-2" href="#section-2">2</a>. NEGOTIATION MODEL</span> |
| 114 |
|
| 115 |
<span class="h3"><a class="selflink" id="section-2.1" href="#section-2.1">2.1</a>. Negotiation description</span> |
| 116 |
|
| 117 |
The model for security mechanism negotiation reuses a subset of the |
| 118 |
concepts specified in [<a href="#ref-2" title=""Association Context Management including Security Context Management"">2</a>]. |
| 119 |
|
| 120 |
Each OID represents one GSS-API mechanism or one variant of it. |
| 121 |
|
| 122 |
- When one security mechanism is proposed by the initiator, it |
| 123 |
represents the only security mechanism supported or selected |
| 124 |
(when the additional APIs defined in the Annex A are used) by the |
| 125 |
initiator. |
| 126 |
|
| 127 |
- When several security mechanisms are proposed by the initiator, |
| 128 |
they represent a set of security mechanisms supported or selected |
| 129 |
(when the additional APIs defined in the Annex A are used) by the |
| 130 |
initiator. |
| 131 |
|
| 132 |
The first negotiation token sent by the initiator contains an ordered |
| 133 |
list of mechanisms, a set of options (e.g. deleg, replay, conf flags) |
| 134 |
that should be supported by the selected mechanism and optionally the |
| 135 |
initial security token for the desired mechanism of the initiator |
| 136 |
(i.e. the first of the list). |
| 137 |
|
| 138 |
The first negotiation token sent by the target contains the result of |
| 139 |
the negotiation (accept_completed, accept_incomplete or reject) and, |
| 140 |
in case of accept, the agreed security mechanism. It may also include |
| 141 |
the response to the initial security token from the initiator, when |
| 142 |
the first proposed mechanism of the initiator has been selected. When |
| 143 |
the first mechanism is acceptable to the target,it should respond to |
| 144 |
the initial security token for the desired mechanism of the initiator |
| 145 |
when it is present. However, if this is not possible, the target can |
| 146 |
simply ignore it and omit the responseToken from the first reply. |
| 147 |
|
| 148 |
Implementations that can piggyback the initial token will be rewarded |
| 149 |
by faster connection setup. |
| 150 |
|
| 151 |
In case of a successful negotiation, the security mechanism |
| 152 |
represents the value suitable for the target, and picked up from the |
| 153 |
list offered by the initiator. The policy by which the target |
| 154 |
chooses a mechanism is an implementation-specific local matter. In |
| 155 |
the absence of other policy, the target should chose the first |
| 156 |
mechanism in the list for which valid credentials are available. |
| 157 |
|
| 158 |
Once a mechanism has been selected, the tokens specific to the |
| 159 |
selected mechanism are carried within the negotiation tokens (in the |
| 160 |
mechToken for the initiator and in the responseToken for the target). |
| 161 |
|
| 162 |
|
| 163 |
|
| 164 |
<span class="grey">Baize & Pinkas Standards Track [Page 3]</span></pre> |
| 165 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-4" ></span> |
| 166 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 167 |
|
| 168 |
|
| 169 |
<span class="h3"><a class="selflink" id="section-2.2" href="#section-2.2">2.2</a>. Negotiation procedure</span> |
| 170 |
|
| 171 |
The negotiation procedure is summarised as follows: |
| 172 |
|
| 173 |
(a) the GSS-API initiator invokes GSS_Init_sec_context as normal, but |
| 174 |
requests (either explicitly, with the negotiation mechanism, or |
| 175 |
through accepting a default, when the default is the negotiation |
| 176 |
mechanism) that the Simple and Protected GSS-API Negotiation |
| 177 |
Mechanism be used; |
| 178 |
|
| 179 |
(b) the initiator GSS-API implementation emits a negotiation token |
| 180 |
containing a list of supported security mechanisms for the |
| 181 |
credentials used for this context establishment, and optionally |
| 182 |
an initial security token for the first mechanism from that list |
| 183 |
(i.e. the preferred mechanism), and indicates |
| 184 |
GSS_S_CONTINUE_NEEDED status; |
| 185 |
|
| 186 |
(c) The GSS-API initiator sends the token to the target application; |
| 187 |
|
| 188 |
(d) The GSS-API target deposits the token through invoking |
| 189 |
GSS_Accept_sec_context. The target GSS-API implementation emits a |
| 190 |
negotiation token containing which if any of the proposed |
| 191 |
mechanisms it supports (or has selected). |
| 192 |
|
| 193 |
If the mechanism selected by the target matches the preferred |
| 194 |
mechanism identified by the initiator and the initiator provides a |
| 195 |
mechToken, the negotiation token response may contain also an initial |
| 196 |
security token from that mechanism. |
| 197 |
|
| 198 |
If the preferred mechanism is accepted, GSS_Accept_sec_context() |
| 199 |
indicates GSS_S_COMPLETE when unilateral or mutual authentication has |
| 200 |
been performed and involves a single token in either direction. |
| 201 |
|
| 202 |
If a proposed mechanism is accepted, and it was not the preferred |
| 203 |
mechanism, or if the first negotiation token sent by the initiator |
| 204 |
did not included a mechToken, then the negotiation token response |
| 205 |
sent by the target may contain also a response token from that |
| 206 |
mechanism which transmits mechanism-specific information (e.g. to |
| 207 |
transmit a certificate). The initiator may ignore such an initial |
| 208 |
token if it is not prepared to process it. |
| 209 |
|
| 210 |
If a proposed mechanism other than the preferred mechanism is |
| 211 |
accepted, or the preferred mechanism is accepted but involves |
| 212 |
multiple exchanges (e.g. challenge-response authentication), then |
| 213 |
GSS_Accept_sec_context() indicates GSS_S_CONTINUE_NEEDED status. |
| 214 |
|
| 215 |
|
| 216 |
|
| 217 |
|
| 218 |
|
| 219 |
|
| 220 |
<span class="grey">Baize & Pinkas Standards Track [Page 4]</span></pre> |
| 221 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-5" ></span> |
| 222 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 223 |
|
| 224 |
|
| 225 |
If the proposed mechanism(s) are rejected, GSS_Accept_sec_context() |
| 226 |
indicates GSS_S_BAD_MECH status. The security context initialisation |
| 227 |
has failed. |
| 228 |
|
| 229 |
(e) The GSS-API target returns the token to the initiator |
| 230 |
application; |
| 231 |
|
| 232 |
(f) The GSS-API initiator deposits the token through invoking |
| 233 |
GSS_Init_sec_context. |
| 234 |
|
| 235 |
GSS_Init_sec_context() may then indicate GSS_S_CONTINUE_NEEDED, |
| 236 |
GSS_S_COMPLETE or GSS_S_BAD_MECH status. |
| 237 |
|
| 238 |
The GSS_S_BAD_MECH status is returned when the negotiation token |
| 239 |
carries a reject result or when the negotiation token carries an |
| 240 |
accept result and the mechanism selected by the target is not |
| 241 |
included in the initial list sent by the initiator. |
| 242 |
|
| 243 |
The GSS_S_BAD_MIC status is returned when the selected mechanism |
| 244 |
supports a MIC token but the MIC computed over the list of |
| 245 |
mechanisms sent by the initiator is missing or incorrect. |
| 246 |
|
| 247 |
If the negotiation token carries a reject result, the context |
| 248 |
establishment is impossible. For example, a rejection will occur |
| 249 |
if the target doesn't support the initiator's proposed mechanism |
| 250 |
type(s). Upon failure of the mechanism negotiation procedure, the |
| 251 |
mech_type output parameter value is the negotiation mechanism |
| 252 |
type. |
| 253 |
|
| 254 |
The GSS_S_CONTINUE_NEEDED status is returned when the negotiation |
| 255 |
token carries an accept result and further tokens must be |
| 256 |
transferred in order to complete context establishment for the |
| 257 |
selected mechanism. In that case GSS_Init_sec_context() returns an |
| 258 |
initial context token as output_token (with the selected |
| 259 |
mechanism's context token encapsulated within that output_token). |
| 260 |
|
| 261 |
The initiator then sends the output_token to the target. The |
| 262 |
security context initialisation is then continued according to the |
| 263 |
standard GSS-API conventions for the selected mechanism, where the |
| 264 |
tokens of the selected mechanism are encapsulated until the |
| 265 |
GSS_S_COMPLETE is returned for both the initiator and the target. |
| 266 |
When GSS_S_CONTINUE_NEEDED is returned, the mech_type output |
| 267 |
parameter is not yet valid. |
| 268 |
|
| 269 |
When GSS_S_COMPLETE is returned, the mech_type output parameter |
| 270 |
indicates the selected mechanism. When the final negotiation token |
| 271 |
does not contain a MIC, the initiator GSS-API implementation must |
| 272 |
check the returned/selected mechanism is on the originally |
| 273 |
|
| 274 |
|
| 275 |
|
| 276 |
<span class="grey">Baize & Pinkas Standards Track [Page 5]</span></pre> |
| 277 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-6" ></span> |
| 278 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 279 |
|
| 280 |
|
| 281 |
submitted list of mechanisms and also verify that the selected |
| 282 |
mechanism is not able to support a MIC. When the final negotiation |
| 283 |
token contains a MIC over the initial mechanisms list sent by the |
| 284 |
initiator, the MIC must be verified. |
| 285 |
|
| 286 |
Note that the *_req_flag input parameters for context establishment |
| 287 |
are relative to the selected mechanism, as are the *_state output |
| 288 |
parameters. i.e., these parameters are not applicable to the |
| 289 |
negotiation process per se. |
| 290 |
|
| 291 |
The initiator GSS-API calling application may need to know when the |
| 292 |
negotiation exchanges were protected or not. For this, when |
| 293 |
GSS_S_COMPLETE is returned, it can simply test the integ_avail flag. |
| 294 |
When this flag is set it indicates that the negotiation was |
| 295 |
protected. |
| 296 |
|
| 297 |
On receipt of a negotiation token on the target side, a GSS-API |
| 298 |
implementation that does not support negotiation would indicate the |
| 299 |
GSS_S_BAD_MECH status as if a particular basic security mechanism had |
| 300 |
been requested but was not supported. |
| 301 |
|
| 302 |
When GSS_Acquire_cred is invoked with the negotiation mechanism as |
| 303 |
desired_mechs, an implementation-specific default credential is used |
| 304 |
to carry on the negotiation. A set of mechanisms as specified locally |
| 305 |
by the system administrator is then available for negotiation. If |
| 306 |
there is a desire for the caller to make its own choice, then an |
| 307 |
additional API has to be used (see <a href="#appendix-A">Appendix A</a>). |
| 308 |
|
| 309 |
<span class="h2"><a class="selflink" id="section-3" href="#section-3">3</a>. DATA ELEMENTS</span> |
| 310 |
|
| 311 |
<span class="h3"><a class="selflink" id="section-3.1" href="#section-3.1">3.1</a>. Mechanism Type</span> |
| 312 |
|
| 313 |
MechType::= OBJECT IDENTIFIER |
| 314 |
|
| 315 |
mechType |
| 316 |
Each security mechanism is as defined in [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>]. |
| 317 |
|
| 318 |
<span class="h3"><a class="selflink" id="section-3.2" href="#section-3.2">3.2</a>. Negotiation Tokens</span> |
| 319 |
|
| 320 |
The syntax of the negotiation tokens follows the InitialContextToken |
| 321 |
syntax defined in [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>]. The security mechanism of the initial |
| 322 |
negotiation token is identified by the Object Identifier |
| 323 |
iso.org.dod.internet.security.mechanism.snego (1.3.6.1.5.5.2). |
| 324 |
|
| 325 |
|
| 326 |
|
| 327 |
|
| 328 |
|
| 329 |
|
| 330 |
|
| 331 |
|
| 332 |
<span class="grey">Baize & Pinkas Standards Track [Page 6]</span></pre> |
| 333 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-7" ></span> |
| 334 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 335 |
|
| 336 |
|
| 337 |
<span class="h4"><a class="selflink" id="section-3.2.1" href="#section-3.2.1">3.2.1</a>. Syntax</span> |
| 338 |
|
| 339 |
This section specifies the syntax of the corresponding |
| 340 |
"innerContextToken" field for the first token and subsequent |
| 341 |
negotiation tokens. During the mechanism negociation, the |
| 342 |
"innerContextToken" field contains the ASN.1 structure |
| 343 |
"NegociationToken" given below, encoded using the DER encoding |
| 344 |
conventions. |
| 345 |
|
| 346 |
NegotiationToken ::= CHOICE { |
| 347 |
negTokenInit [0] NegTokenInit, |
| 348 |
negTokenTarg [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>] NegTokenTarg } |
| 349 |
|
| 350 |
MechTypeList ::= SEQUENCE OF MechType |
| 351 |
|
| 352 |
NegTokenInit ::= SEQUENCE { |
| 353 |
mechTypes [0] MechTypeList OPTIONAL, |
| 354 |
reqFlags [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>] ContextFlags OPTIONAL, |
| 355 |
mechToken [<a href="#ref-2" title=""Association Context Management including Security Context Management"">2</a>] OCTET STRING OPTIONAL, |
| 356 |
mechListMIC [3] OCTET STRING OPTIONAL |
| 357 |
} |
| 358 |
|
| 359 |
ContextFlags ::= BIT STRING { |
| 360 |
delegFlag (0), |
| 361 |
mutualFlag (1), |
| 362 |
replayFlag (2), |
| 363 |
sequenceFlag (3), |
| 364 |
anonFlag (4), |
| 365 |
confFlag (5), |
| 366 |
integFlag (6) |
| 367 |
} |
| 368 |
|
| 369 |
negTokenInit |
| 370 |
Negotiation token sent by the initiator to the target, which |
| 371 |
contains, for the first token sent, one or more security mechanisms |
| 372 |
supported by the initiator (as indicated in the field mechTypes) |
| 373 |
and the service options (reqFlags) that are requested to establish |
| 374 |
the context. The context flags should be filled in from the |
| 375 |
req_flags parameter of init_sec_context(). |
| 376 |
|
| 377 |
The mechToken field is optional for the first token sent that all |
| 378 |
target implementations would not have to support. However for those |
| 379 |
targets that do support piggybacking the initial mechToken, an |
| 380 |
optimistic negotiation response is possible. Otherwise the |
| 381 |
mechToken is used to carry the tokens specific to the mechanism |
| 382 |
selected. |
| 383 |
|
| 384 |
|
| 385 |
|
| 386 |
|
| 387 |
|
| 388 |
<span class="grey">Baize & Pinkas Standards Track [Page 7]</span></pre> |
| 389 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-8" ></span> |
| 390 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 391 |
|
| 392 |
|
| 393 |
The mechListMIC is an optional field. In the case that the chosen |
| 394 |
mechanism supports integrity, the initiator may optionally include |
| 395 |
a mechListMIC which is the result of a GetMIC of the MechTypes in |
| 396 |
the initial NegTokenInit and return GSS_S_COMPLETE. |
| 397 |
|
| 398 |
When the chosen mechanism uses an odd number of messages, the final |
| 399 |
mechanism token will be sent from the initiator to the acceptor. In |
| 400 |
this case, there is a tradeoff between using the optimal number of |
| 401 |
messages, or using an additional message from the acceptor to the |
| 402 |
initiator in order to give the initiator assurance that no |
| 403 |
modification of the initiator's mechanism list occurred. The |
| 404 |
implementation can choose which tradeoff to make (see <a href="#section-4.2.2">section 4.2.2</a> |
| 405 |
for further details for the processing of that field). |
| 406 |
|
| 407 |
NegTokenTarg ::= SEQUENCE { |
| 408 |
negResult [0] ENUMERATED { |
| 409 |
accept_completed (0), |
| 410 |
accept_incomplete (1), |
| 411 |
reject (2) } OPTIONAL, |
| 412 |
supportedMech [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>] MechType OPTIONAL, |
| 413 |
responseToken [<a href="#ref-2" title=""Association Context Management including Security Context Management"">2</a>] OCTET STRING OPTIONAL, |
| 414 |
mechListMIC [3] OCTET STRING OPTIONAL |
| 415 |
} |
| 416 |
|
| 417 |
negTokenTarg |
| 418 |
Negotiation token returned by the target to the initiator which |
| 419 |
contains, for the first token returned, a global negotiation result |
| 420 |
and the security mechanism selected (if any). |
| 421 |
|
| 422 |
negResult |
| 423 |
The result accept_completed indicates that a context has been |
| 424 |
successfully established, while the result accept_incomplete |
| 425 |
indicates that additional token exchanges are needed. |
| 426 |
|
| 427 |
Note: For the case where (a) a single-token context setup is |
| 428 |
used and (b) the preferred mechanism does not support the |
| 429 |
integrity facility which would cause a mechListMIC to be |
| 430 |
generated and enclosed, this feature allows to make a |
| 431 |
difference between a mechToken sent by the initiator but not |
| 432 |
processed by the target (accept_incomplete) and a mechToken |
| 433 |
sent by the initiator and processed by the target |
| 434 |
(accept_completed). |
| 435 |
|
| 436 |
For those targets that support piggybacking the initial mechToken, |
| 437 |
an optimistic negotiation response is possible and includes in that |
| 438 |
case a responseToken which may continue the authentication exchange |
| 439 |
(e.g. when mutual authentication has been requested or when |
| 440 |
unilateral authentication requires several round trips). Otherwise |
| 441 |
|
| 442 |
|
| 443 |
|
| 444 |
<span class="grey">Baize & Pinkas Standards Track [Page 8]</span></pre> |
| 445 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-9" ></span> |
| 446 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 447 |
|
| 448 |
|
| 449 |
the responseToken is used to carry the tokens specific to the |
| 450 |
mechanism selected. For subsequent tokens (if any) returned by the |
| 451 |
target, negResult, and supportedMech are not present. |
| 452 |
|
| 453 |
For the last token returned by the target, the mechListMIC, when |
| 454 |
present, is a MIC computed over the MechTypes using the selected |
| 455 |
mechanism. |
| 456 |
|
| 457 |
negResult |
| 458 |
Result of the negotiation exchange, specified by the target. |
| 459 |
|
| 460 |
This can be either : |
| 461 |
|
| 462 |
accept_completed |
| 463 |
The target accepts the preferred security mechanism, |
| 464 |
and the context is established for the target or, |
| 465 |
|
| 466 |
accept_incomplete |
| 467 |
The target accepts one of the proposed security |
| 468 |
mechanisms and further exchanges are necessary, or, |
| 469 |
|
| 470 |
reject |
| 471 |
The target rejects all the proposed security |
| 472 |
mechanisms. |
| 473 |
|
| 474 |
supportedMech |
| 475 |
This field has to be present when negResult is "accept_completed" |
| 476 |
or "accept_incomplete". It is a choice from the mechanisms offered |
| 477 |
by the initiator. |
| 478 |
|
| 479 |
responseToken |
| 480 |
This field may be used either to transmit the response to the |
| 481 |
mechToken when sent by the initiator and when the first mechanism |
| 482 |
from the list has been selected by the target or to carry the |
| 483 |
tokens specific to the selected security mechanism. |
| 484 |
|
| 485 |
mechListMIC |
| 486 |
If the selected mechanism is capable of integrity protection, this |
| 487 |
field must be present in the last message of the negotiation, |
| 488 |
(i.e., when the underlying mechanism returns a non-empty token and |
| 489 |
a major status of GSS_S_COMPLETE); it contains the result of a |
| 490 |
GetMIC of the MechTypes field in the initial NegTokenInit. It |
| 491 |
allows to verify that the list initially sent by the initiator has |
| 492 |
been received unmodified by the target. |
| 493 |
|
| 494 |
|
| 495 |
|
| 496 |
|
| 497 |
|
| 498 |
|
| 499 |
|
| 500 |
<span class="grey">Baize & Pinkas Standards Track [Page 9]</span></pre> |
| 501 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-10" ></span> |
| 502 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 503 |
|
| 504 |
|
| 505 |
<span class="h4"><a class="selflink" id="section-3.2.2" href="#section-3.2.2">3.2.2</a>. Processing of mechListMIC.</span> |
| 506 |
|
| 507 |
If the mechanism selected by the negotiation does not support |
| 508 |
integrity, then no mechListMIC is included, otherwise a mechListMIC |
| 509 |
must be used and validated as indicated below. |
| 510 |
|
| 511 |
If the mechanism supports integrity and uses an even number of |
| 512 |
messages, then the target must compute a MIC as described above, and |
| 513 |
send this in the final NegTokenTarg along with the final mechToken. |
| 514 |
The initiator when receiving the last token must require that the |
| 515 |
mechListMIC field be present and valid. In the absence of a valid |
| 516 |
mechListMIC, the negotiation must fail as if the last context |
| 517 |
establishment token was invalid. |
| 518 |
|
| 519 |
In the case that the chosen mechanism supports integrity and uses an |
| 520 |
odd number of messages, the final mechanism token will be sent from |
| 521 |
the initiator to the target. In this case, there is a tradeoff |
| 522 |
between using the optimal number of messages, or using an additional |
| 523 |
message from the target to the initiator in order to give the |
| 524 |
initiator assurance that no modification of the initiator's mechanism |
| 525 |
list occurred. The implementation can choose which tradeoff to make. |
| 526 |
|
| 527 |
When generating the final NegTokenInit message, the NegTokenInit may |
| 528 |
optionally include a mechListMIC which is the result of a GetMIC of |
| 529 |
the MechTypes in the initial NegTokenInit and return GSS_S_COMPLETE. |
| 530 |
The target must check the presence of the MIC computed over the |
| 531 |
mechList sent in the initial NegTokenInit. Three cases may then be |
| 532 |
considered: |
| 533 |
|
| 534 |
1) If the mechListMIC is present and correct, then |
| 535 |
GSS_S_COMPLETE is returned to the target with no token; the |
| 536 |
context is established by the target. |
| 537 |
|
| 538 |
2) If the mechListMIC is present but invalid, then the context |
| 539 |
establishment must fail. An error major status code is |
| 540 |
returned to the target. |
| 541 |
|
| 542 |
3) If the mechListMIC is not included in the final NegTokenInit, |
| 543 |
then GSS_S_COMPLETE must be returned to the target with a |
| 544 |
token. This token must be a NegTokenTarg, with a MIC included |
| 545 |
as described above, and no responseToken. The application will |
| 546 |
then send this token back to the initiator, which must verify |
| 547 |
that the mechListMIC field is present and valid. |
| 548 |
|
| 549 |
|
| 550 |
|
| 551 |
|
| 552 |
|
| 553 |
|
| 554 |
|
| 555 |
|
| 556 |
<span class="grey">Baize & Pinkas Standards Track [Page 10]</span></pre> |
| 557 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-11" ></span> |
| 558 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 559 |
|
| 560 |
|
| 561 |
Note: If the MIC was originally sent by the initiator, but |
| 562 |
thenafter deleted by an attacker, the target will send |
| 563 |
back a token according to the description above, but the |
| 564 |
initiator will be unable to process that returned token |
| 565 |
and the context establishment must then fail. |
| 566 |
|
| 567 |
<span class="h2"><a class="selflink" id="section-4" href="#section-4">4</a>. EXAMPLES : SECURITY MECHANISM NEGOTIATION</span> |
| 568 |
|
| 569 |
Here are some examples of security mechanism negotiation between an |
| 570 |
initiator (I) and a target (T). |
| 571 |
|
| 572 |
<span class="h3"><a class="selflink" id="section-4.1" href="#section-4.1">4.1</a>. Initial steps</span> |
| 573 |
|
| 574 |
(I) supports two security mechanism types (GSS-MECH1 and GSS-MECH2). |
| 575 |
|
| 576 |
(I) invokes GSS_Init_sec_context() with : |
| 577 |
|
| 578 |
Input |
| 579 |
mech_type = OID for negotiation mechanism or NULL, if the |
| 580 |
negotiation mechanism is the default mechanism. |
| 581 |
|
| 582 |
Output |
| 583 |
major_status = GSS_S_CONTINUE_NEEDED |
| 584 |
output_token = negTokenInit |
| 585 |
|
| 586 |
The negotiation token (negTokenInit) contains two security mechanisms |
| 587 |
with : |
| 588 |
mechType = GSS-MECH1 or |
| 589 |
mechType = GSS-MECH2 |
| 590 |
|
| 591 |
(I) sends to (T) the negotiation token. |
| 592 |
|
| 593 |
<span class="h3"><a class="selflink" id="section-4.2" href="#section-4.2">4.2</a> Successful negotiation steps</span> |
| 594 |
|
| 595 |
(T) supports GSS-MECH2 |
| 596 |
(T) receives the negotiation token (negTokenInit) from (I) |
| 597 |
(T) invokes GSS_Accept_sec_context() with : |
| 598 |
|
| 599 |
Input |
| 600 |
input_token = negTokenInit |
| 601 |
|
| 602 |
Output |
| 603 |
major_status = GSS_S_CONTINUE_NEEDED |
| 604 |
output_token = negTokenTarg |
| 605 |
|
| 606 |
The negotiation token (negTokenTarg) contains : |
| 607 |
negResult = accept (the negotiation result) |
| 608 |
supportedMech : mechType = GSS-MECH2 |
| 609 |
|
| 610 |
|
| 611 |
|
| 612 |
<span class="grey">Baize & Pinkas Standards Track [Page 11]</span></pre> |
| 613 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-12" ></span> |
| 614 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 615 |
|
| 616 |
|
| 617 |
(T) returns the negotiation token (negTokenTarg) to (I) |
| 618 |
(I) invokes GSS_Init_sec_context() with : |
| 619 |
|
| 620 |
Input |
| 621 |
input_token = negTokenTarg |
| 622 |
|
| 623 |
Output |
| 624 |
major_status = GSS_S_COMPLETE |
| 625 |
output_token = initialContextToken (initial context token |
| 626 |
for GSS-MECH2) |
| 627 |
mech_type = GSS-MECH2 |
| 628 |
|
| 629 |
The subsequent steps are security mechanism specific, and work as |
| 630 |
specified in [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>]. The output tokens from the security mechanism are |
| 631 |
encapsulated in a NegTokenTarg message (with the supportedMech field |
| 632 |
omitted, and the mechListMIC included with the last token). |
| 633 |
|
| 634 |
<span class="h3"><a class="selflink" id="section-4.3" href="#section-4.3">4.3</a>. Failed negotiation steps</span> |
| 635 |
|
| 636 |
(T) supports GSS-MECH3. |
| 637 |
(T) receives the negotiation token (negTokenInit) from (I) |
| 638 |
(T) invokes GSS_Accept_sec_context() with : |
| 639 |
|
| 640 |
Input |
| 641 |
input_token = negTokenInit |
| 642 |
|
| 643 |
Output |
| 644 |
major_status = GSS_S_BAD_MECH |
| 645 |
output_token = negTokenTarg |
| 646 |
|
| 647 |
The negotiation token (negTokenTarg) contains : |
| 648 |
|
| 649 |
negResult = reject (the negotiation result) |
| 650 |
|
| 651 |
(T) returns the negotiation token (negTokenTarg) to (I) |
| 652 |
(I) invokes GSS_Init_sec_context() with : |
| 653 |
|
| 654 |
Input |
| 655 |
input_token = negTokenTarg |
| 656 |
|
| 657 |
Output |
| 658 |
major_status = GSS_S_BAD_MECH |
| 659 |
|
| 660 |
The security context establishment has failed. |
| 661 |
|
| 662 |
|
| 663 |
|
| 664 |
|
| 665 |
|
| 666 |
|
| 667 |
|
| 668 |
<span class="grey">Baize & Pinkas Standards Track [Page 12]</span></pre> |
| 669 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-13" ></span> |
| 670 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 671 |
|
| 672 |
|
| 673 |
<span class="h3"><a class="selflink" id="section-4.4" href="#section-4.4">4.4</a> Successful Negotiation with preferred mechanism info</span> |
| 674 |
|
| 675 |
(I) supports two security mechanism types (GSS-MECH1 and GSS-MECH2). |
| 676 |
|
| 677 |
(I) invokes GSS_Init_sec_context() with : |
| 678 |
|
| 679 |
Input |
| 680 |
mech_type = OID for negotiation mechanism or NULL, if the |
| 681 |
negotiation mechanism is the default mechanism. |
| 682 |
|
| 683 |
Output |
| 684 |
major_status = GSS_S_CONTINUE_NEEDED |
| 685 |
output_token = negTokenInit |
| 686 |
|
| 687 |
The negotiation token (negTokenInit) contains two security mechanisms |
| 688 |
with : |
| 689 |
mechType = GSS-MECH1 or |
| 690 |
mechType = GSS-MECH2 |
| 691 |
|
| 692 |
mechToken = output_token from GSS_Init_sec_context |
| 693 |
( first mechType) as described in [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>] |
| 694 |
|
| 695 |
(I) sends to (T) the negotiation token. |
| 696 |
|
| 697 |
(T) supports GSS-MECH1. |
| 698 |
(T) receives the negotiation token (negTokenInit) from (I) |
| 699 |
(T) invokes GSS_Accept_sec_context() with : |
| 700 |
|
| 701 |
Input |
| 702 |
input_token = negTokenInit |
| 703 |
|
| 704 |
Output |
| 705 |
major_status = GSS_S_CONTINUE_NEEDED |
| 706 |
output_token = negTokenTarg |
| 707 |
|
| 708 |
The negotiation token (negTokenTarg) contains : |
| 709 |
negResult = accept (the negotiation result) |
| 710 |
supportedMech : mechType = GSS-MECH1 |
| 711 |
|
| 712 |
mechToken = output_token from |
| 713 |
GSS_Accept_sec_context(mechToken ) |
| 714 |
|
| 715 |
(T) returns the negotiation token (negTokenTarg) to (I) |
| 716 |
(I) invokes GSS_Init_sec_context() with : |
| 717 |
|
| 718 |
Input |
| 719 |
input_token = negTokenTarg |
| 720 |
|
| 721 |
|
| 722 |
|
| 723 |
|
| 724 |
<span class="grey">Baize & Pinkas Standards Track [Page 13]</span></pre> |
| 725 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-14" ></span> |
| 726 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 727 |
|
| 728 |
|
| 729 |
Output |
| 730 |
major_status = GSS_S_COMPLETE or GSS_S_CONTINUE_NEEDED as needed |
| 731 |
output_token = ContextToken (initial or subsequent context token |
| 732 |
for GSS-MECH1) |
| 733 |
mech_type = GSS-MECH1 |
| 734 |
|
| 735 |
Specific implementations of the protocol can support the optimistic |
| 736 |
negotiation by completing the security context establishment using the |
| 737 |
agreed upon mechanism as described in [<a href="#ref-1" title=""Generic Security Service Application Program Interface"">1</a>]. As described above in |
| 738 |
<a href="#section-5.2">section 5.2</a>, the output tokens from the security mechanisms are |
| 739 |
encapsulated in a NegTokenTarg message (with the negResult and |
| 740 |
supportedMech fields omitted, and the mechListMIC included with the |
| 741 |
last token). |
| 742 |
|
| 743 |
<span class="h2"><a class="selflink" id="section-5" href="#section-5">5</a>. SECURITY CONSIDERATIONS</span> |
| 744 |
|
| 745 |
When the mechanism selected by the target from the list supplied by |
| 746 |
the initiator supports integrity protection, then the negotiation is |
| 747 |
protected. |
| 748 |
|
| 749 |
When one of the mechanisms proposed by the initiator does not support |
| 750 |
integrity protection, then the negotiation is exposed to all threats |
| 751 |
a non secured service is exposed. In particular, an active attacker |
| 752 |
can force to use a security mechanism which is not the common |
| 753 |
preferred one (when multiple security mechanisms are shared between |
| 754 |
peers) but which is acceptable anyway to the target. |
| 755 |
|
| 756 |
In any case, the communicating peers may be exposed to the denial of |
| 757 |
service threat. |
| 758 |
|
| 759 |
<span class="h2"><a class="selflink" id="section-6" href="#section-6">6</a>. ACKNOWLEDGMENTS</span> |
| 760 |
|
| 761 |
Acknowledgments are due to Stephen Farrell of SSE, Marc Horowitz of |
| 762 |
Stonecast, John Linn of RSA Laboratories, Piers McMahon of Platinum |
| 763 |
Technology, Tom Parker of ICL and Doug Rosenthal of EINet, for |
| 764 |
reviewing earlier versions of this document and for providing useful |
| 765 |
inputs. Acknowledgments are also due to Peter Brundrett of Microsoft |
| 766 |
for his proposal for an optimistic negotiation, and for Bill |
| 767 |
Sommerfeld of Epilogue Technology for his proposal for protecting the |
| 768 |
negotiation. |
| 769 |
|
| 770 |
|
| 771 |
|
| 772 |
|
| 773 |
|
| 774 |
|
| 775 |
|
| 776 |
|
| 777 |
|
| 778 |
|
| 779 |
|
| 780 |
<span class="grey">Baize & Pinkas Standards Track [Page 14]</span></pre> |
| 781 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-15" ></span> |
| 782 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 783 |
|
| 784 |
|
| 785 |
APPENDIX A |
| 786 |
|
| 787 |
|
| 788 |
GSS-API NEGOTIATION SUPPORT API |
| 789 |
|
| 790 |
In order to provide to a GSS-API caller (either the initiator or the |
| 791 |
target or both) the ability to choose among the set of supported |
| 792 |
mechanisms a reduced set of mechanisms for negotiation, two |
| 793 |
additional APIs are defined: |
| 794 |
|
| 795 |
GSS_Get_neg_mechs() indicates the set of security mechanisms |
| 796 |
available on the local system to the caller for negotiation. |
| 797 |
|
| 798 |
GSS_Set_neg_mechs() specifies the set of security mechanisms to be |
| 799 |
used on the local system by the caller for negotiation. |
| 800 |
|
| 801 |
<span class="h3"><a class="selflink" id="appendix-A.1" href="#appendix-A.1">A.1</a>. GSS_Set_neg_mechs call</span> |
| 802 |
|
| 803 |
Input: |
| 804 |
cred_handle CREDENTIAL HANDLE |
| 805 |
- NULL specifies default credentials |
| 806 |
mech_set SET OF OBJECT IDENTIFIER |
| 807 |
|
| 808 |
Outputs: |
| 809 |
major_status INTEGER, |
| 810 |
minor_status INTEGER, |
| 811 |
|
| 812 |
Return major_status codes : |
| 813 |
GSS_S_COMPLETE indicates that the set of security mechanisms |
| 814 |
available for negotiation has been set to mech_set. GSS_S_FAILURE |
| 815 |
indicates that the requested operation could not be performed for |
| 816 |
reasons unspecified at the GSS-API level. |
| 817 |
|
| 818 |
Allows callers to specify the set of security mechanisms that may be |
| 819 |
negotiated with the credential identified by cred_handle. This call |
| 820 |
is intended for support of specialised callers who need to restrict |
| 821 |
the set of negotiable security mechanisms from the set of all |
| 822 |
security mechanisms available to the caller (based on available |
| 823 |
credentials). Note that if more than one mechanism is specified in |
| 824 |
mech_set, the order in which those mechanisms are specified implies a |
| 825 |
relative mechanism preference for the target. |
| 826 |
|
| 827 |
|
| 828 |
|
| 829 |
|
| 830 |
|
| 831 |
|
| 832 |
|
| 833 |
|
| 834 |
|
| 835 |
|
| 836 |
<span class="grey">Baize & Pinkas Standards Track [Page 15]</span></pre> |
| 837 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-16" ></span> |
| 838 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 839 |
|
| 840 |
|
| 841 |
<span class="h3"><a class="selflink" id="appendix-A.2" href="#appendix-A.2">A.2</a>. GSS_Get_neg_mechs call</span> |
| 842 |
|
| 843 |
Input: |
| 844 |
cred_handle CREDENTIAL HANDLE |
| 845 |
- NULL specifies default credentials |
| 846 |
|
| 847 |
Outputs: |
| 848 |
major_status INTEGER, |
| 849 |
minor_status INTEGER, |
| 850 |
mech_set SET OF OBJECT IDENTIFIER |
| 851 |
|
| 852 |
Return major_status codes : |
| 853 |
GSS_S_COMPLETE indicates that the set of security mechanisms |
| 854 |
available for negotiation has been returned in |
| 855 |
mech_option_set. |
| 856 |
GSS_S_FAILURE indicates that the requested operation could not |
| 857 |
be performed for reasons unspecified at the GSS-API level. |
| 858 |
|
| 859 |
Allows callers to determine the set of security mechanisms available |
| 860 |
for negotiation with the credential identified by cred_handle. This |
| 861 |
call is intended for support of specialised callers who need to |
| 862 |
reduce the set of negotiable security mechanisms from the set of |
| 863 |
supported security mechanisms available to the caller (based on |
| 864 |
available credentials). |
| 865 |
|
| 866 |
Note: The GSS_Indicate_mechs() function indicates the full set of |
| 867 |
mechanism types available on the local system. Since this call has no |
| 868 |
input parameter, the returned set is not necessarily available for |
| 869 |
all credentials. |
| 870 |
|
| 871 |
REFERENCES |
| 872 |
|
| 873 |
[<a id="ref-1">1</a>] Linn, J., "Generic Security Service Application Program |
| 874 |
Interface", <a href="./rfc2078">RFC 2078</a>, January 1997. |
| 875 |
|
| 876 |
[<a id="ref-2">2</a>] Standard ECMA-206, "Association Context Management including |
| 877 |
Security Context Management", December 1993. Available on |
| 878 |
<a href="http://www.ecma.ch">http://www.ecma.ch</a> |
| 879 |
|
| 880 |
|
| 881 |
|
| 882 |
|
| 883 |
|
| 884 |
|
| 885 |
|
| 886 |
|
| 887 |
|
| 888 |
|
| 889 |
|
| 890 |
|
| 891 |
|
| 892 |
<span class="grey">Baize & Pinkas Standards Track [Page 16]</span></pre> |
| 893 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-17" ></span> |
| 894 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 895 |
|
| 896 |
|
| 897 |
AUTHORS' ADDRESSES |
| 898 |
|
| 899 |
Eric Baize |
| 900 |
Bull - 300 Concord Road |
| 901 |
Billerica, MA 01821 - USA |
| 902 |
|
| 903 |
Phone: +1 978 294 61 37 |
| 904 |
Fax: +1 978 294 61 09 |
| 905 |
EMail: [email protected] |
| 906 |
|
| 907 |
|
| 908 |
Denis Pinkas |
| 909 |
Bull |
| 910 |
Rue Jean-Jaures |
| 911 |
BP 68 |
| 912 |
78340 Les Clayes-sous-Bois - FRANCE |
| 913 |
|
| 914 |
Phone: +33 1 30 80 34 87 |
| 915 |
Fax: +33 1 30 80 33 21 |
| 916 |
EMail: [email protected] |
| 917 |
|
| 918 |
|
| 919 |
|
| 920 |
|
| 921 |
|
| 922 |
|
| 923 |
|
| 924 |
|
| 925 |
|
| 926 |
|
| 927 |
|
| 928 |
|
| 929 |
|
| 930 |
|
| 931 |
|
| 932 |
|
| 933 |
|
| 934 |
|
| 935 |
|
| 936 |
|
| 937 |
|
| 938 |
|
| 939 |
|
| 940 |
|
| 941 |
|
| 942 |
|
| 943 |
|
| 944 |
|
| 945 |
|
| 946 |
|
| 947 |
|
| 948 |
<span class="grey">Baize & Pinkas Standards Track [Page 17]</span></pre> |
| 949 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-18" ></span> |
| 950 |
<span class="grey"><a href="./rfc2478">RFC 2478</a> GSS-API Negotiation Mechanism December 1998</span> |
| 951 |
|
| 952 |
|
| 953 |
Full Copyright Statement |
| 954 |
|
| 955 |
Copyright (C) The Internet Society (1998). All Rights Reserved. |
| 956 |
|
| 957 |
This document and translations of it may be copied and furnished to |
| 958 |
others, and derivative works that comment on or otherwise explain it |
| 959 |
or assist in its implementation may be prepared, copied, published |
| 960 |
and distributed, in whole or in part, without restriction of any |
| 961 |
kind, provided that the above copyright notice and this paragraph are |
| 962 |
included on all such copies and derivative works. However, this |
| 963 |
document itself may not be modified in any way, such as by removing |
| 964 |
the copyright notice or references to the Internet Society or other |
| 965 |
Internet organizations, except as needed for the purpose of |
| 966 |
developing Internet standards in which case the procedures for |
| 967 |
copyrights defined in the Internet Standards process must be |
| 968 |
followed, or as required to translate it into languages other than |
| 969 |
English. |
| 970 |
|
| 971 |
The limited permissions granted above are perpetual and will not be |
| 972 |
revoked by the Internet Society or its successors or assigns. |
| 973 |
|
| 974 |
This document and the information contained herein is provided on an |
| 975 |
"AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING |
| 976 |
TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING |
| 977 |
BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION |
| 978 |
HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF |
| 979 |
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. |
| 980 |
|
| 981 |
|
| 982 |
|
| 983 |
|
| 984 |
|
| 985 |
|
| 986 |
|
| 987 |
|
| 988 |
|
| 989 |
|
| 990 |
|
| 991 |
|
| 992 |
|
| 993 |
|
| 994 |
|
| 995 |
|
| 996 |
|
| 997 |
|
| 998 |
|
| 999 |
|
| 1000 |
|
| 1001 |
|
| 1002 |
|
| 1003 |
|
| 1004 |
Baize & Pinkas Standards Track [Page 18] |
| 1005 |
</pre> |