accept_sec_context.c

   1 /*
   2  * Copyright (c) 2010, JANET(UK)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of JANET(UK) nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include "gssapiP_eap.h"
  34
  35 static OM_uint32
  36 acceptReadyCommon(OM_uint32 *minor, gss_ctx_id_t ctx, gss_cred_id_t cred)
  37 {
  38     OM_uint32 major;
  39
  40     major = sequenceInit(minor,
  41                          &ctx->seqState, ctx->recvSeq,
  42                          ((ctx->gssFlags & GSS_C_REPLAY_FLAG) != 0),
  43                          ((ctx->gssFlags & GSS_C_SEQUENCE_FLAG) != 0),
  44                          TRUE);
  45     if (GSS_ERROR(major))
  46         return major;
  47
  48     return GSS_S_COMPLETE;
  49 }
  50
  51
  52 /*
  53  * Mark a context as ready for cryptographic operations
  54  */
  55 static OM_uint32
  56 acceptReadyEap(OM_uint32 *minor, gss_ctx_id_t ctx, gss_cred_id_t cred)
  57 {
  58     OM_uint32 major, tmpMinor;
  59     VALUE_PAIR *vp;
  60     gss_buffer_desc nameBuf = GSS_C_EMPTY_BUFFER;
  61
  62     /* Cache encryption type derived from selected mechanism OID */
  63     major = gssEapOidToEnctype(minor, ctx->mechanismUsed,
  64                                &ctx->encryptionType);
  65     if (GSS_ERROR(major))
  66         return major;
  67
  68     gssEapReleaseName(&tmpMinor, &ctx->initiatorName);
  69
  70     vp = rc_avpair_get(ctx->acceptorCtx.avps, PW_USER_NAME, 0);
  71     if (vp != NULL) {
  72         nameBuf.length = vp->lvalue;
  73         nameBuf.value = vp->strvalue;
  74     } else {
  75         ctx->gssFlags |= GSS_C_ANON_FLAG;
  76     }
  77
  78     major = gssEapImportName(minor, &nameBuf, GSS_C_NT_USER_NAME,
  79                              &ctx->initiatorName);
  80     if (GSS_ERROR(major))
  81         return major;
  82
  83     ctx->initiatorName->attrCtx = gssEapCreateAttrContext(cred, ctx);
  84
  85     vp = rc_avpair_get(ctx->acceptorCtx.avps,
  86                        VENDOR_ATTR_MS_MPPE_SEND_KEY,
  87                        VENDOR_ID_MICROSOFT);
  88     if (ctx->encryptionType != ENCTYPE_NULL && vp != NULL) {
  89         major = gssEapDeriveRfc3961Key(minor,
  90                                        (unsigned char *)vp->strvalue,
  91                                        vp->lvalue,
  92                                        ctx->encryptionType,
  93                                        &ctx->rfc3961Key);
  94         if (GSS_ERROR(major))
  95             return major;
  96
  97         major = rfc3961ChecksumTypeForKey(minor, &ctx->rfc3961Key,
  98                                            &ctx->checksumType);
  99         if (GSS_ERROR(major))
 100             return major;
 101     } else {
 102         /*
 103          * draft-howlett-eap-gss says that integrity/confidentialty should
 104          * always be advertised as available, but if we have no keying
 105          * material it seems confusing to the caller to advertise this.
 106          */
 107         ctx->gssFlags &= ~(GSS_C_INTEG_FLAG | GSS_C_CONF_FLAG);
 108         ctx->encryptionType = ENCTYPE_NULL;
 109     }
 110
 111     return acceptReadyCommon(minor, ctx, cred);
 112 }
 113
 114 static OM_uint32
 115 eapGssSmAcceptIdentity(OM_uint32 *minor,
 116                        gss_ctx_id_t ctx,
 117                        gss_cred_id_t cred,
 118                        gss_buffer_t inputToken,
 119                        gss_channel_bindings_t chanBindings,
 120                        gss_buffer_t outputToken)
 121 {
 122     OM_uint32 major;
 123     union {
 124         struct eap_hdr pdu;
 125         unsigned char data[5];
 126     } pkt;
 127     gss_buffer_desc pktBuffer;
 128
 129     if (inputToken != GSS_C_NO_BUFFER && inputToken->length != 0)
 130         return GSS_S_DEFECTIVE_TOKEN;
 131
 132     assert(ctx->acceptorCtx.radHandle == NULL);
 133
 134     major = gssEapRadiusAllocHandle(minor, cred, &ctx->acceptorCtx.radHandle);
 135     if (GSS_ERROR(major))
 136         return major;
 137
 138     assert(ctx->acceptorName == GSS_C_NO_NAME);
 139
 140     if (cred != GSS_C_NO_CREDENTIAL && cred->name != GSS_C_NO_NAME) {
 141         major = gssEapDuplicateName(minor, cred->name, &ctx->acceptorName);
 142         if (GSS_ERROR(major))
 143             return major;
 144     }
 145
 146     pkt.pdu.code = EAP_CODE_REQUEST;
 147     pkt.pdu.identifier = 0;
 148     pkt.pdu.length = htons(sizeof(pkt.data));
 149     pkt.data[4] = EAP_TYPE_IDENTITY;
 150
 151     pktBuffer.length = sizeof(pkt.data);
 152     pktBuffer.value = pkt.data;
 153
 154     major = duplicateBuffer(minor, &pktBuffer, outputToken);
 155     if (GSS_ERROR(major))
 156         return major;
 157
 158     ctx->state = EAP_STATE_AUTHENTICATE;
 159
 160     return GSS_S_CONTINUE_NEEDED;
 161 }
 162
 163 static OM_uint32
 164 setAcceptorIdentity(OM_uint32 *minor,
 165                     gss_ctx_id_t ctx,
 166                     VALUE_PAIR **avps)
 167 {
 168     OM_uint32 major;
 169     gss_buffer_desc nameBuf;
 170     krb5_context krbContext = NULL;
 171     krb5_principal krbPrinc;
 172
 173     /* Awaits further specification */
 174     if (ctx->acceptorName == GSS_C_NO_NAME)
 175         return GSS_S_COMPLETE;
 176
 177     GSSEAP_KRB_INIT(&krbContext);
 178
 179     krbPrinc = ctx->acceptorName->krbPrincipal;
 180     assert(krbPrinc != NULL);
 181
 182     if (krb5_princ_size(krbContext, krbPrinc) < 2)
 183         return GSS_S_BAD_NAME;
 184
 185     /* Acceptor-Service-Name */
 186     krbDataToGssBuffer(krb5_princ_component(krbContext, krbPrinc, 0), &nameBuf);
 187
 188     major = addAvpFromBuffer(minor, ctx->acceptorCtx.radHandle, avps,
 189                              VENDOR_ATTR_GSS_ACCEPTOR_SERVICE_NAME,
 190                              VENDOR_ID_UKERNA,
 191                              &nameBuf);
 192     if (GSS_ERROR(major))
 193         return major;
 194
 195     /* Acceptor-Host-Name */
 196     krbDataToGssBuffer(krb5_princ_component(krbContext, krbPrinc, 1), &nameBuf);
 197
 198     major = addAvpFromBuffer(minor, ctx->acceptorCtx.radHandle, avps,
 199                              VENDOR_ATTR_GSS_ACCEPTOR_HOST_NAME,
 200                              VENDOR_ID_UKERNA,
 201                              &nameBuf);
 202     if (GSS_ERROR(major))
 203         return major;
 204
 205     if (krb5_princ_size(krbContext, krbPrinc) > 2) {
 206         /* Acceptor-Service-Specific */
 207         krb5_principal_data ssiPrinc = *krbPrinc;
 208         char *ssi;
 209
 210         krb5_princ_size(krbContext, &ssiPrinc) -= 2;
 211         krb5_princ_name(krbContext, &ssiPrinc) += 2;
 212
 213         *minor = krb5_unparse_name_flags(krbContext, &ssiPrinc,
 214                                          KRB5_PRINCIPAL_UNPARSE_NO_REALM, &ssi);
 215         if (*minor != 0)
 216             return GSS_S_FAILURE;
 217
 218         nameBuf.value = ssi;
 219         nameBuf.length = strlen(ssi);
 220
 221         major = addAvpFromBuffer(minor, ctx->acceptorCtx.radHandle, avps,
 222                                  VENDOR_ATTR_GSS_ACCEPTOR_SERVICE_SPECIFIC,
 223                                  VENDOR_ID_UKERNA,
 224                                  &nameBuf);
 225
 226         if (GSS_ERROR(major)) {
 227             krb5_free_unparsed_name(krbContext, ssi);
 228             return major;
 229         }
 230         krb5_free_unparsed_name(krbContext, ssi);
 231     }
 232
 233     krbDataToGssBuffer(krb5_princ_realm(krbContext, krbPrinc), &nameBuf);
 234     if (nameBuf.length != 0) {
 235         /* Acceptor-Realm-Name */
 236         major = addAvpFromBuffer(minor, ctx->acceptorCtx.radHandle, avps,
 237                                  VENDOR_ATTR_GSS_ACCEPTOR_REALM_NAME,
 238                                  VENDOR_ID_UKERNA,
 239                                  &nameBuf);
 240         if (GSS_ERROR(major))
 241             return major;
 242     }
 243
 244     return GSS_S_COMPLETE;
 245 }
 246
 247 static OM_uint32
 248 eapGssSmAcceptAuthenticate(OM_uint32 *minor,
 249                            gss_ctx_id_t ctx,
 250                            gss_cred_id_t cred,
 251                            gss_buffer_t inputToken,
 252                            gss_channel_bindings_t chanBindings,
 253                            gss_buffer_t outputToken)
 254 {
 255     OM_uint32 major, tmpMinor;
 256     int code;
 257     VALUE_PAIR *send = NULL;
 258     VALUE_PAIR *received = NULL;
 259     rc_handle *rh = ctx->acceptorCtx.radHandle;
 260     char msgBuffer[4096];
 261     struct eap_hdr *pdu;
 262     unsigned char *pos;
 263     gss_buffer_desc nameBuf = GSS_C_EMPTY_BUFFER;
 264
 265     pdu = (struct eap_hdr *)inputToken->value;
 266     pos = (unsigned char *)(pdu + 1);
 267
 268     if (inputToken->length > sizeof(*pdu) &&
 269         pdu->code == EAP_CODE_RESPONSE &&
 270         pos[0] == EAP_TYPE_IDENTITY) {
 271         /*
 272          * XXX TODO do we really need to set User-Name? FreeRADIUS does
 273          * not appear to require it.
 274          */
 275         major = addAvpFromBuffer(minor, rh, &send, PW_USER_NAME, 0, &nameBuf);
 276         if (GSS_ERROR(major))
 277             goto cleanup;
 278
 279         major = setAcceptorIdentity(minor, ctx, &send);
 280         if (GSS_ERROR(major))
 281             goto cleanup;
 282     }
 283
 284     major = addAvpFromBuffer(minor, rh, &send, PW_EAP_MESSAGE, 0, inputToken);
 285     if (GSS_ERROR(major))
 286         goto cleanup;
 287
 288     if (ctx->acceptorCtx.lastStatus == CHALLENGE_RC) {
 289         major = addAvpFromBuffer(minor, rh, &send, PW_STATE, 0,
 290                                  &ctx->acceptorCtx.state);
 291         if (GSS_ERROR(major))
 292             goto cleanup;
 293
 294         gss_release_buffer(&tmpMinor, &ctx->acceptorCtx.state);
 295     }
 296
 297     code = rc_auth(rh, 0, send, &received, msgBuffer);
 298     switch (code) {
 299     case OK_RC:
 300     case CHALLENGE_RC:
 301         major = GSS_S_CONTINUE_NEEDED;
 302         break;
 303     case TIMEOUT_RC:
 304         major = GSS_S_UNAVAILABLE;
 305         break;
 306     case REJECT_RC:
 307         major = GSS_S_DEFECTIVE_CREDENTIAL;
 308         break;
 309     default:
 310         major = GSS_S_FAILURE;
 311         goto cleanup;
 312     }
 313
 314     if (GSS_ERROR(major))
 315         goto cleanup;
 316
 317     ctx->acceptorCtx.lastStatus = code;
 318
 319     major = getBufferFromAvps(minor, received, PW_EAP_MESSAGE, 0,
 320                               outputToken, TRUE);
 321     if ((major == GSS_S_UNAVAILABLE && code != OK_RC) ||
 322         GSS_ERROR(major))
 323         goto cleanup;
 324
 325     if (code == CHALLENGE_RC) {
 326         major = getBufferFromAvps(minor, received, PW_STATE, 0,
 327                                   &ctx->acceptorCtx.state, TRUE);
 328         if (major != GSS_S_UNAVAILABLE && GSS_ERROR(major))
 329             goto cleanup;
 330     } else {
 331         ctx->acceptorCtx.avps = received;
 332         received = NULL;
 333
 334         major = acceptReadyEap(minor, ctx, cred);
 335         if (GSS_ERROR(major))
 336             goto cleanup;
 337
 338         ctx->state = EAP_STATE_GSS_CHANNEL_BINDINGS;
 339     }
 340
 341     major = GSS_S_CONTINUE_NEEDED;
 342
 343 cleanup:
 344     if (received != NULL)
 345         rc_avpair_free(received);
 346
 347     return major;
 348 }
 349
 350 static OM_uint32
 351 eapGssSmAcceptGssChannelBindings(OM_uint32 *minor,
 352                                  gss_ctx_id_t ctx,
 353                                  gss_cred_id_t cred,
 354                                  gss_buffer_t inputToken,
 355                                  gss_channel_bindings_t chanBindings,
 356                                  gss_buffer_t outputToken)
 357 {
 358     OM_uint32 major;
 359     gss_iov_buffer_desc iov[2];
 360
 361     outputToken->length = 0;
 362     outputToken->value = NULL;
 363
 364     if (chanBindings != GSS_C_NO_CHANNEL_BINDINGS) {
 365         if (inputToken->length < 14) {
 366             return GSS_S_DEFECTIVE_TOKEN;
 367         }
 368
 369         iov[0].type = GSS_IOV_BUFFER_TYPE_DATA;
 370         iov[0].buffer.length = 0;
 371         iov[0].buffer.value = NULL;
 372
 373         if (chanBindings != GSS_C_NO_CHANNEL_BINDINGS)
 374             iov[0].buffer = chanBindings->application_data;
 375
 376         iov[1].type = GSS_IOV_BUFFER_TYPE_HEADER;
 377         iov[1].buffer.length = 16;
 378         iov[1].buffer.value = (unsigned char *)inputToken->value - 2;
 379
 380         assert(load_uint16_be(iov[1].buffer.value) == TOK_TYPE_GSS_CB);
 381
 382         iov[2].type = GSS_IOV_BUFFER_TYPE_TRAILER;
 383         iov[2].buffer.length = inputToken->length - 14;
 384         iov[2].buffer.value = (unsigned char *)inputToken->value + 14;
 385
 386         major = gssEapUnwrapOrVerifyMIC(minor, ctx, NULL, NULL,
 387                                         iov, 3, TOK_TYPE_GSS_CB);
 388         if (GSS_ERROR(major))
 389             return major;
 390     }
 391
 392     ctx->state = EAP_STATE_KRB_REAUTH_CRED;
 393     return GSS_S_CONTINUE_NEEDED;
 394 }
 395
 396 static OM_uint32
 397 eapGssSmAcceptKrbReauthCred(OM_uint32 *minor,
 398                             gss_ctx_id_t ctx,
 399                             gss_cred_id_t cred,
 400                             gss_buffer_t inputToken,
 401                             gss_channel_bindings_t chanBindings,
 402                             gss_buffer_t outputToken)
 403 {
 404     OM_uint32 major;
 405
 406     major = gssEapMakeReauthCreds(minor, ctx, cred, outputToken);
 407     if (GSS_ERROR(major))
 408         return major;
 409
 410     ctx->state = EAP_STATE_ESTABLISHED;
 411
 412     return GSS_S_COMPLETE;
 413 }
 414
 415 static OM_uint32
 416 eapGssSmAcceptEstablished(OM_uint32 *minor,
 417                           gss_ctx_id_t ctx,
 418                           gss_cred_id_t cred,
 419                           gss_buffer_t inputToken,
 420                           gss_channel_bindings_t chanBindings,
 421                           gss_buffer_t outputToken)
 422 {
 423     /* Called with already established context */
 424     *minor = EINVAL;
 425     return GSS_S_BAD_STATUS;
 426 }
 427
 428 static OM_uint32
 429 acceptReadyKrb(OM_uint32 *minor,
 430                gss_ctx_id_t ctx,
 431                gss_cred_id_t cred,
 432                const gss_name_t initiator,
 433                const gss_OID mech,
 434                OM_uint32 timeRec)
 435 {
 436     OM_uint32 major, tmpMinor;
 437     gss_buffer_set_t keyData = GSS_C_NO_BUFFER_SET;
 438     gss_buffer_desc nameBuf = GSS_C_EMPTY_BUFFER;
 439
 440     if (!oidEqual(mech, gss_mech_krb5)) {
 441         major = GSS_S_BAD_MECH;
 442         goto cleanup;
 443     }
 444
 445     major = gssInquireSecContextByOid(minor, ctx->kerberosCtx,
 446                                       GSS_C_INQ_SSPI_SESSION_KEY, &keyData);
 447     if (GSS_ERROR(major))
 448         goto cleanup;
 449
 450     {
 451         gss_OID_desc oid;
 452         int suffix;
 453
 454         oid.length = keyData->elements[1].length;
 455         oid.elements = keyData->elements[1].value;
 456
 457         /* GSS_KRB5_SESSION_KEY_ENCTYPE_OID */
 458         major = decomposeOid(minor,
 459                              "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02\x04",
 460                              10, &oid, &suffix);
 461         if (GSS_ERROR(major))
 462             goto cleanup;
 463
 464         ctx->encryptionType = suffix;
 465     }
 466
 467     {
 468         krb5_context krbContext = NULL;
 469         krb5_keyblock key;
 470
 471         GSSEAP_KRB_INIT(&krbContext);
 472
 473         KRB_KEY_LENGTH(&key) = keyData->elements[0].length;
 474         KRB_KEY_DATA(&key)   = keyData->elements[0].value;
 475         KRB_KEY_TYPE(&key)   = ctx->encryptionType;
 476
 477         *minor = krb5_copy_keyblock_contents(krbContext,
 478                                              &key, &ctx->rfc3961Key);
 479         if (*minor != 0) {
 480             major = GSS_S_FAILURE;
 481             goto cleanup;
 482         }
 483     }
 484
 485     major = rfc3961ChecksumTypeForKey(minor, &ctx->rfc3961Key,
 486                                       &ctx->checksumType);
 487     if (GSS_ERROR(major))
 488         goto cleanup;
 489
 490     major = gssDisplayName(minor, initiator, &nameBuf, NULL);
 491     if (GSS_ERROR(major))
 492         goto cleanup;
 493
 494     major = gssEapImportName(minor, &nameBuf, GSS_C_NT_USER_NAME,
 495                              &ctx->initiatorName);
 496     if (GSS_ERROR(major))
 497         goto cleanup;
 498
 499     if (cred != GSS_C_NO_CREDENTIAL && cred->name != GSS_C_NO_NAME) {
 500         major = gssEapDuplicateName(minor, cred->name, &ctx->acceptorName);
 501         if (GSS_ERROR(major))
 502             goto cleanup;
 503     }
 504
 505     if (timeRec != GSS_C_INDEFINITE)
 506         ctx->expiryTime = time(NULL) + timeRec;
 507
 508     major = acceptReadyCommon(minor, ctx, cred);
 509     if (GSS_ERROR(major))
 510         goto cleanup;
 511
 512     ctx->state = EAP_STATE_ESTABLISHED;
 513     ctx->mechanismUsed = GSS_EAP_MECHANISM;
 514
 515 cleanup:
 516     gss_release_buffer_set(&tmpMinor, &keyData);
 517     gss_release_buffer(&tmpMinor, &nameBuf);
 518
 519     return major;
 520 }
 521
 522 static OM_uint32
 523 eapGssSmAcceptGssReauth(OM_uint32 *minor,
 524                          gss_ctx_id_t ctx,
 525                          gss_cred_id_t cred,
 526                          gss_buffer_t inputToken,
 527                          gss_channel_bindings_t chanBindings,
 528                          gss_buffer_t outputToken)
 529 {
 530     OM_uint32 major, tmpMinor;
 531     gss_cred_id_t krbCred = GSS_C_NO_CREDENTIAL;
 532     gss_name_t krbInitiator = GSS_C_NO_NAME;
 533     gss_OID mech = GSS_C_NO_OID;
 534     OM_uint32 timeRec = GSS_C_INDEFINITE;
 535
 536     ctx->flags |= CTX_FLAG_KRB_REAUTH_GSS;
 537
 538     if (cred != GSS_C_NO_CREDENTIAL)
 539         krbCred = cred->krbCred;
 540
 541     major = gssAcceptSecContext(minor,
 542                                 &ctx->kerberosCtx,
 543                                 krbCred,
 544                                 inputToken,
 545                                 chanBindings,
 546                                 &krbInitiator,
 547                                 &mech,
 548                                 outputToken,
 549                                 &ctx->gssFlags,
 550                                 &timeRec,
 551                                 NULL);
 552     if (major == GSS_S_COMPLETE) {
 553         major = acceptReadyKrb(minor, ctx, cred,
 554                                krbInitiator, mech, timeRec);
 555     }
 556
 557     gssReleaseName(&tmpMinor, &krbInitiator);
 558
 559     return major;
 560 }
 561
 562 static struct gss_eap_acceptor_sm {
 563     enum gss_eap_token_type inputTokenType;
 564     enum gss_eap_token_type outputTokenType;
 565     OM_uint32 (*processToken)(OM_uint32 *,
 566                               gss_ctx_id_t,
 567                               gss_cred_id_t,
 568                               gss_buffer_t,
 569                               gss_channel_bindings_t,
 570                               gss_buffer_t);
 571 } eapGssAcceptorSm[] = {
 572     { TOK_TYPE_EAP_RESP,    TOK_TYPE_EAP_REQ,    eapGssSmAcceptIdentity           },
 573     { TOK_TYPE_EAP_RESP,    TOK_TYPE_EAP_REQ,    eapGssSmAcceptAuthenticate       },
 574     { TOK_TYPE_GSS_CB,      TOK_TYPE_NONE,       eapGssSmAcceptGssChannelBindings },
 575     { TOK_TYPE_NONE,        TOK_TYPE_KRB_CRED,   eapGssSmAcceptKrbReauthCred      },
 576     { TOK_TYPE_NONE,        TOK_TYPE_NONE,       eapGssSmAcceptEstablished        },
 577     { TOK_TYPE_GSS_REAUTH,  TOK_TYPE_GSS_REAUTH, eapGssSmAcceptGssReauth          },
 578 };
 579
 580 OM_uint32
 581 gss_accept_sec_context(OM_uint32 *minor,
 582                        gss_ctx_id_t *context_handle,
 583                        gss_cred_id_t cred,
 584                        gss_buffer_t input_token,
 585                        gss_channel_bindings_t input_chan_bindings,
 586                        gss_name_t *src_name,
 587                        gss_OID *mech_type,
 588                        gss_buffer_t output_token,
 589                        OM_uint32 *ret_flags,
 590                        OM_uint32 *time_rec,
 591                        gss_cred_id_t *delegated_cred_handle)
 592 {
 593     OM_uint32 major;
 594     OM_uint32 tmpMajor, tmpMinor;
 595     gss_ctx_id_t ctx = *context_handle;
 596     struct gss_eap_acceptor_sm *sm = NULL;
 597     gss_buffer_desc innerInputToken = GSS_C_EMPTY_BUFFER;
 598     gss_buffer_desc innerOutputToken = GSS_C_EMPTY_BUFFER;
 599     enum gss_eap_token_type tokType;
 600
 601     *minor = 0;
 602
 603     output_token->length = 0;
 604     output_token->value = NULL;
 605
 606     if (cred != GSS_C_NO_CREDENTIAL && !(cred->flags & CRED_FLAG_ACCEPT)) {
 607         return GSS_S_NO_CRED;
 608     }
 609
 610     if (input_token == GSS_C_NO_BUFFER || input_token->length == 0) {
 611         return GSS_S_DEFECTIVE_TOKEN;
 612     }
 613
 614     if (ctx == GSS_C_NO_CONTEXT) {
 615         major = gssEapAllocContext(minor, &ctx);
 616         if (GSS_ERROR(major))
 617             return major;
 618
 619         *context_handle = ctx;
 620     }
 621
 622     GSSEAP_MUTEX_LOCK(&ctx->mutex);
 623
 624     sm = &eapGssAcceptorSm[ctx->state];
 625
 626     major = gssEapVerifyToken(minor, ctx, input_token,
 627                               sm->inputTokenType, &tokType,
 628                               &innerInputToken);
 629     if (major == GSS_S_DEFECTIVE_TOKEN && tokType == TOK_TYPE_GSS_REAUTH) {
 630         ctx->state = EAP_STATE_KRB_REAUTH_GSS;
 631     } else if (GSS_ERROR(major)) {
 632         goto cleanup;
 633     }
 634
 635     /* If credentials were provided, check they're usable with this mech */
 636     if (!gssEapCredAvailable(cred, ctx->mechanismUsed)) {
 637         major = GSS_S_BAD_MECH;
 638         goto cleanup;
 639     }
 640
 641     do {
 642         sm = &eapGssAcceptorSm[ctx->state];
 643
 644         major = (sm->processToken)(minor,
 645                                    ctx,
 646                                    cred,
 647                                    &innerInputToken,
 648                                    input_chan_bindings,
 649                                    &innerOutputToken);
 650         if (GSS_ERROR(major))
 651             goto cleanup;
 652     } while (major == GSS_S_CONTINUE_NEEDED && innerOutputToken.length == 0);
 653
 654     if (mech_type != NULL) {
 655         if (!gssEapInternalizeOid(ctx->mechanismUsed, mech_type))
 656             duplicateOid(&tmpMinor, ctx->mechanismUsed, mech_type);
 657     }
 658     if (innerOutputToken.length != 0) {
 659         tmpMajor = gssEapMakeToken(&tmpMinor, ctx, &innerOutputToken,
 660                                    sm->outputTokenType, output_token);
 661         if (GSS_ERROR(tmpMajor)) {
 662             major = tmpMajor;
 663             *minor = tmpMinor;
 664             goto cleanup;
 665         }
 666     }
 667     if (ret_flags != NULL)
 668         *ret_flags = ctx->gssFlags;
 669     if (delegated_cred_handle != NULL)
 670         *delegated_cred_handle = GSS_C_NO_CREDENTIAL;
 671
 672     if (major == GSS_S_COMPLETE) {
 673         if (src_name != NULL && ctx->initiatorName != GSS_C_NO_NAME) {
 674             major = gssEapDuplicateName(&tmpMinor, ctx->initiatorName, src_name);
 675             if (GSS_ERROR(major))
 676                 goto cleanup;
 677         }
 678         if (time_rec != NULL)
 679             gssEapContextTime(&tmpMinor, ctx, time_rec);
 680     }
 681
 682     assert(ctx->state == EAP_STATE_ESTABLISHED || major == GSS_S_CONTINUE_NEEDED);
 683
 684 cleanup:
 685     GSSEAP_MUTEX_UNLOCK(&ctx->mutex);
 686
 687     if (GSS_ERROR(major))
 688         gssEapReleaseContext(&tmpMinor, context_handle);
 689
 690     gss_release_buffer(&tmpMinor, &innerOutputToken);
 691
 692     return major;
 693 }
 694