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 #ifdef GSSEAP_ENABLE_REAUTH
  36 static OM_uint32
  37 eapGssSmAcceptGssReauth(OM_uint32 *minor,
  38                         gss_ctx_id_t ctx,
  39                         gss_cred_id_t cred,
  40                         gss_buffer_t inputToken,
  41                         gss_channel_bindings_t chanBindings,
  42                         gss_buffer_t outputToken);
  43 #endif
  44
  45 /*
  46  * Mark an acceptor context as ready for cryptographic operations
  47  */
  48 static OM_uint32
  49 acceptReadyEap(OM_uint32 *minor, gss_ctx_id_t ctx, gss_cred_id_t cred)
  50 {
  51     OM_uint32 major, tmpMinor;
  52     VALUE_PAIR *vp;
  53     gss_buffer_desc nameBuf = GSS_C_EMPTY_BUFFER;
  54
  55     /* Cache encryption type derived from selected mechanism OID */
  56     major = gssEapOidToEnctype(minor, ctx->mechanismUsed,
  57                                &ctx->encryptionType);
  58     if (GSS_ERROR(major))
  59         return major;
  60
  61     gssEapReleaseName(&tmpMinor, &ctx->initiatorName);
  62
  63     major = gssEapRadiusGetRawAvp(minor, ctx->acceptorCtx.vps,
  64                                   PW_USER_NAME, 0, &vp);
  65     if (major == GSS_S_COMPLETE) {
  66         nameBuf.length = vp->length;
  67         nameBuf.value = vp->vp_strvalue;
  68     } else {
  69         ctx->gssFlags |= GSS_C_ANON_FLAG;
  70     }
  71
  72     major = gssEapImportName(minor, &nameBuf, GSS_C_NT_USER_NAME,
  73                              &ctx->initiatorName);
  74     if (GSS_ERROR(major))
  75         return major;
  76
  77     major = gssEapRadiusGetRawAvp(minor, ctx->acceptorCtx.vps,
  78                                   PW_MS_MPPE_SEND_KEY, VENDORPEC_MS, &vp);
  79     if (GSS_ERROR(major)) {
  80         *minor = GSSEAP_KEY_UNAVAILABLE;
  81         return GSS_S_UNAVAILABLE;
  82     }
  83
  84     major = gssEapDeriveRfc3961Key(minor,
  85                                    vp->vp_octets,
  86                                    vp->length,
  87                                    ctx->encryptionType,
  88                                    &ctx->rfc3961Key);
  89     if (GSS_ERROR(major))
  90         return major;
  91
  92     major = rfc3961ChecksumTypeForKey(minor, &ctx->rfc3961Key,
  93                                        &ctx->checksumType);
  94     if (GSS_ERROR(major))
  95         return major;
  96
  97     major = sequenceInit(minor,
  98                          &ctx->seqState, ctx->recvSeq,
  99                          ((ctx->gssFlags & GSS_C_REPLAY_FLAG) != 0),
 100                          ((ctx->gssFlags & GSS_C_SEQUENCE_FLAG) != 0),
 101                          TRUE);
 102     if (GSS_ERROR(major))
 103         return major;
 104
 105     ctx->initiatorName->attrCtx = gssEapCreateAttrContext(cred, ctx);
 106
 107     *minor = 0;
 108     return GSS_S_COMPLETE;
 109 }
 110
 111 /*
 112  * Emit a identity EAP request to force the initiator (peer) to identify
 113  * itself.
 114  */
 115 static OM_uint32
 116 eapGssSmAcceptIdentity(OM_uint32 *minor,
 117                        gss_ctx_id_t ctx,
 118                        gss_cred_id_t cred,
 119                        gss_buffer_t inputToken,
 120                        gss_channel_bindings_t chanBindings,
 121                        gss_buffer_t outputToken)
 122 {
 123     OM_uint32 major;
 124     union {
 125         struct eap_hdr pdu;
 126         unsigned char data[5];
 127     } pkt;
 128     gss_buffer_desc pktBuffer;
 129
 130     if (inputToken != GSS_C_NO_BUFFER && inputToken->length != 0) {
 131         *minor = GSSEAP_WRONG_SIZE;
 132         return GSS_S_DEFECTIVE_TOKEN;
 133     }
 134
 135     assert(ctx->acceptorName == GSS_C_NO_NAME);
 136
 137     if (cred != GSS_C_NO_CREDENTIAL && cred->name != GSS_C_NO_NAME) {
 138         major = gssEapDuplicateName(minor, cred->name, &ctx->acceptorName);
 139         if (GSS_ERROR(major))
 140             return major;
 141     }
 142
 143     pkt.pdu.code = EAP_CODE_REQUEST;
 144     pkt.pdu.identifier = 0;
 145     pkt.pdu.length = htons(sizeof(pkt.data));
 146     pkt.data[4] = EAP_TYPE_IDENTITY;
 147
 148     pktBuffer.length = sizeof(pkt.data);
 149     pktBuffer.value = pkt.data;
 150
 151     major = duplicateBuffer(minor, &pktBuffer, outputToken);
 152     if (GSS_ERROR(major))
 153         return major;
 154
 155     ctx->state = EAP_STATE_AUTHENTICATE;
 156
 157     *minor = 0;
 158     return GSS_S_CONTINUE_NEEDED;
 159 }
 160
 161 /*
 162  * Pass the asserted acceptor identity to the authentication server.
 163  */
 164 static OM_uint32
 165 setAcceptorIdentity(OM_uint32 *minor,
 166                     gss_ctx_id_t ctx,
 167                     VALUE_PAIR **vps)
 168 {
 169     OM_uint32 major;
 170     gss_buffer_desc nameBuf;
 171     krb5_context krbContext = NULL;
 172     krb5_principal krbPrinc;
 173     struct rs_handle *rh = ctx->acceptorCtx.radHandle;
 174
 175     assert(rh != NULL);
 176
 177     if (ctx->acceptorName == GSS_C_NO_NAME) {
 178         *minor = 0;
 179         return GSS_S_COMPLETE;
 180     }
 181
 182     if ((ctx->acceptorName->flags & NAME_FLAG_SERVICE) == 0) {
 183         *minor = GSSEAP_BAD_SERVICE_NAME;
 184         return GSS_S_BAD_NAME;
 185     }
 186
 187     GSSEAP_KRB_INIT(&krbContext);
 188
 189     krbPrinc = ctx->acceptorName->krbPrincipal;
 190     assert(krbPrinc != NULL);
 191     assert(krb5_princ_size(krbContext, krbPrinc) >= 2);
 192
 193     /* Acceptor-Service-Name */
 194     krbDataToGssBuffer(krb5_princ_component(krbContext, krbPrinc, 0), &nameBuf);
 195
 196     major = gssEapRadiusAddAvp(minor, vps,
 197                                PW_GSS_ACCEPTOR_SERVICE_NAME,
 198                                VENDORPEC_UKERNA,
 199                                &nameBuf);
 200     if (GSS_ERROR(major))
 201         return major;
 202
 203     /* Acceptor-Host-Name */
 204     krbDataToGssBuffer(krb5_princ_component(krbContext, krbPrinc, 1), &nameBuf);
 205
 206     major = gssEapRadiusAddAvp(minor, vps,
 207                                PW_GSS_ACCEPTOR_HOST_NAME,
 208                                VENDORPEC_UKERNA,
 209                                &nameBuf);
 210     if (GSS_ERROR(major))
 211         return major;
 212
 213     if (krb5_princ_size(krbContext, krbPrinc) > 2) {
 214         /* Acceptor-Service-Specific */
 215         krb5_principal_data ssiPrinc = *krbPrinc;
 216         char *ssi;
 217
 218         krb5_princ_size(krbContext, &ssiPrinc) -= 2;
 219         krb5_princ_name(krbContext, &ssiPrinc) += 2;
 220
 221         *minor = krb5_unparse_name_flags(krbContext, &ssiPrinc,
 222                                          KRB5_PRINCIPAL_UNPARSE_NO_REALM, &ssi);
 223         if (*minor != 0)
 224             return GSS_S_FAILURE;
 225
 226         nameBuf.value = ssi;
 227         nameBuf.length = strlen(ssi);
 228
 229         major = gssEapRadiusAddAvp(minor, vps,
 230                                    PW_GSS_ACCEPTOR_SERVICE_SPECIFIC,
 231                                    VENDORPEC_UKERNA,
 232                                    &nameBuf);
 233
 234         if (GSS_ERROR(major)) {
 235             krb5_free_unparsed_name(krbContext, ssi);
 236             return major;
 237         }
 238         krb5_free_unparsed_name(krbContext, ssi);
 239     }
 240
 241     krbDataToGssBuffer(krb5_princ_realm(krbContext, krbPrinc), &nameBuf);
 242     if (nameBuf.length != 0) {
 243         /* Acceptor-Realm-Name */
 244         major = gssEapRadiusAddAvp(minor, vps,
 245                                    PW_GSS_ACCEPTOR_REALM_NAME,
 246                                    VENDORPEC_UKERNA,
 247                                    &nameBuf);
 248         if (GSS_ERROR(major))
 249             return major;
 250     }
 251
 252     *minor = 0;
 253     return GSS_S_COMPLETE;
 254 }
 255
 256 /*
 257  * Allocate a RadSec handle
 258  */
 259 static OM_uint32
 260 createRadiusHandle(OM_uint32 *minor,
 261                    gss_cred_id_t cred,
 262                    gss_ctx_id_t ctx)
 263 {
 264     struct gss_eap_acceptor_ctx *actx = &ctx->acceptorCtx;
 265     const char *configFile = RS_CONFIG_FILE;
 266     const char *configStanza = "gss-eap";
 267     struct rs_alloc_scheme ralloc;
 268     struct rs_error *err;
 269
 270     assert(actx->radHandle == NULL);
 271     assert(actx->radConn == NULL);
 272
 273     if (rs_context_create(&actx->radHandle, RS_DICT_FILE) != 0) {
 274         *minor = GSSEAP_RADSEC_CONTEXT_FAILURE;
 275         return GSS_S_FAILURE;
 276     }
 277
 278     if (cred != GSS_C_NO_CREDENTIAL) {
 279         if (cred->radiusConfigFile != NULL)
 280             configFile = cred->radiusConfigFile;
 281         if (cred->radiusConfigStanza != NULL)
 282             configStanza = cred->radiusConfigStanza;
 283     }
 284
 285     ralloc.calloc  = GSSEAP_CALLOC;
 286     ralloc.malloc  = GSSEAP_MALLOC;
 287     ralloc.free    = GSSEAP_FREE;
 288     ralloc.realloc = GSSEAP_REALLOC;
 289
 290     rs_context_set_alloc_scheme(actx->radHandle, &ralloc);
 291
 292     if (rs_context_read_config(actx->radHandle, configFile) != 0) {
 293         err = rs_err_ctx_pop(actx->radHandle);
 294         goto fail;
 295     }
 296
 297     if (rs_conn_create(actx->radHandle, &actx->radConn, configStanza) != 0) {
 298         err = rs_err_conn_pop(actx->radConn);
 299         goto fail;
 300     }
 301
 302     /* XXX TODO rs_conn_select_server does not exist yet */
 303 #if 0
 304     if (actx->radServer != NULL) {
 305         if (rs_conn_select_server(actx->radConn, actx->radServer) != 0) {
 306             err = rs_err_conn_pop(actx->radConn);
 307             goto fail;
 308         }
 309     }
 310 #endif
 311
 312     *minor = 0;
 313     return GSS_S_COMPLETE;
 314
 315 fail:
 316     return gssEapRadiusMapError(minor, err);
 317 }
 318
 319 /*
 320  * Process a EAP response from the initiator.
 321  */
 322 static OM_uint32
 323 eapGssSmAcceptAuthenticate(OM_uint32 *minor,
 324                            gss_ctx_id_t ctx,
 325                            gss_cred_id_t cred,
 326                            gss_buffer_t inputToken,
 327                            gss_channel_bindings_t chanBindings,
 328                            gss_buffer_t outputToken)
 329 {
 330     OM_uint32 major, tmpMinor;
 331     struct rs_handle *rh;
 332     struct rs_connection *rconn;
 333     struct rs_request *request = NULL;
 334     struct rs_packet *req = NULL, *resp = NULL;
 335     struct radius_packet *frreq, *frresp;
 336     int sendAcceptorIdentity = 0;
 337
 338     if (ctx->acceptorCtx.radHandle == NULL) {
 339         /* May be NULL from an imported partial context */
 340         major = createRadiusHandle(minor, cred, ctx);
 341         if (GSS_ERROR(major))
 342             goto cleanup;
 343
 344         sendAcceptorIdentity = 1;
 345     }
 346
 347     rh = ctx->acceptorCtx.radHandle;
 348     rconn = ctx->acceptorCtx.radConn;
 349
 350     if (rs_packet_create_acc_request(rconn, &req, NULL, NULL) != 0) {
 351         major = gssEapRadiusMapError(minor, rs_err_conn_pop(rconn));
 352         goto cleanup;
 353     }
 354     frreq = rs_packet_frpkt(req);
 355
 356     if (sendAcceptorIdentity) {
 357         major = setAcceptorIdentity(minor, ctx, &frreq->vps);
 358         if (GSS_ERROR(major))
 359             goto cleanup;
 360     }
 361
 362     major = gssEapRadiusAddAvp(minor, &frreq->vps,
 363                                PW_EAP_MESSAGE, 0, inputToken);
 364     if (GSS_ERROR(major))
 365         goto cleanup;
 366
 367     if (ctx->acceptorCtx.state.length != 0) {
 368         major = gssEapRadiusAddAvp(minor, &frreq->vps, PW_STATE, 0,
 369                                    &ctx->acceptorCtx.state);
 370         if (GSS_ERROR(major))
 371             goto cleanup;
 372
 373         gss_release_buffer(&tmpMinor, &ctx->acceptorCtx.state);
 374     }
 375
 376     if (rs_request_create(rconn, &request) != 0 ||
 377         rs_request_send(request, req, &resp) != 0) {
 378         major = gssEapRadiusMapError(minor, rs_err_conn_pop(rconn));
 379         goto cleanup;
 380     }
 381
 382     assert(resp != NULL);
 383
 384     frresp = rs_packet_frpkt(resp);
 385     switch (frresp->code) {
 386     case PW_AUTHENTICATION_ACK:
 387     case PW_ACCESS_CHALLENGE:
 388         major = GSS_S_CONTINUE_NEEDED;
 389         break;
 390     case PW_AUTHENTICATION_REJECT:
 391         *minor = GSSEAP_RADIUS_AUTH_FAILURE;
 392         major = GSS_S_DEFECTIVE_CREDENTIAL;
 393         goto cleanup;
 394         break;
 395     default:
 396         *minor = GSSEAP_UNKNOWN_RADIUS_CODE;
 397         major = GSS_S_FAILURE;
 398         goto cleanup;
 399         break;
 400     }
 401
 402     major = gssEapRadiusGetAvp(minor, frresp->vps, PW_EAP_MESSAGE, 0,
 403                                outputToken, TRUE);
 404     if (major == GSS_S_UNAVAILABLE && frresp->code == PW_ACCESS_CHALLENGE) {
 405         *minor = GSSEAP_MISSING_EAP_REQUEST;
 406         major = GSS_S_DEFECTIVE_TOKEN;
 407         goto cleanup;
 408     } else if (GSS_ERROR(major))
 409         goto cleanup;
 410
 411     if (frresp->code == PW_ACCESS_CHALLENGE) {
 412         major = gssEapRadiusGetAvp(minor, frresp->vps, PW_STATE, 0,
 413                                    &ctx->acceptorCtx.state, TRUE);
 414         if (GSS_ERROR(major) && *minor != GSSEAP_NO_SUCH_ATTR)
 415             goto cleanup;
 416     } else {
 417         ctx->acceptorCtx.vps = frresp->vps;
 418         frresp->vps = NULL;
 419
 420         rs_conn_destroy(ctx->acceptorCtx.radConn);
 421         ctx->acceptorCtx.radConn = NULL;
 422
 423         major = acceptReadyEap(minor, ctx, cred);
 424         if (GSS_ERROR(major))
 425             goto cleanup;
 426
 427         ctx->state = EAP_STATE_EXTENSIONS_REQ;
 428     }
 429
 430     *minor = 0;
 431     major = GSS_S_CONTINUE_NEEDED;
 432
 433 cleanup:
 434     rs_request_destroy(request);
 435
 436     return major;
 437 }
 438
 439 static OM_uint32
 440 eapGssSmAcceptExtensionsReq(OM_uint32 *minor,
 441                             gss_ctx_id_t ctx,
 442                             gss_cred_id_t cred,
 443                             gss_buffer_t inputToken,
 444                             gss_channel_bindings_t chanBindings,
 445                             gss_buffer_t outputToken)
 446 {
 447     OM_uint32 major;
 448
 449     major = gssEapVerifyExtensions(minor, cred, ctx, chanBindings, inputToken);
 450     if (GSS_ERROR(major))
 451         return major;
 452
 453     outputToken->length = 0;
 454     outputToken->value = NULL;
 455
 456     ctx->state = EAP_STATE_EXTENSIONS_RESP;
 457
 458     *minor = 0;
 459     return GSS_S_CONTINUE_NEEDED;
 460 }
 461
 462 static OM_uint32
 463 eapGssSmAcceptExtensionsResp(OM_uint32 *minor,
 464                              gss_ctx_id_t ctx,
 465                              gss_cred_id_t cred,
 466                              gss_buffer_t inputToken,
 467                              gss_channel_bindings_t chanBindings,
 468                              gss_buffer_t outputToken)
 469 {
 470     OM_uint32 major;
 471
 472     major = gssEapMakeExtensions(minor, cred, ctx, chanBindings, outputToken);
 473     if (GSS_ERROR(major))
 474         return major;
 475
 476     ctx->state = EAP_STATE_ESTABLISHED;
 477
 478     *minor = 0;
 479     return GSS_S_COMPLETE;
 480 }
 481
 482 static OM_uint32
 483 eapGssSmAcceptEstablished(OM_uint32 *minor,
 484                           gss_ctx_id_t ctx,
 485                           gss_cred_id_t cred,
 486                           gss_buffer_t inputToken,
 487                           gss_channel_bindings_t chanBindings,
 488                           gss_buffer_t outputToken)
 489 {
 490     /* Called with already established context */
 491     *minor = GSSEAP_CONTEXT_ESTABLISHED;
 492     return GSS_S_BAD_STATUS;
 493 }
 494
 495 static OM_uint32
 496 makeErrorToken(OM_uint32 *minor,
 497                OM_uint32 majorStatus,
 498                OM_uint32 minorStatus,
 499                gss_buffer_t outputToken)
 500 {
 501     unsigned char errorData[8];
 502     gss_buffer_desc errorBuffer;
 503
 504     assert(GSS_ERROR(majorStatus));
 505
 506     /*
 507      * Only return error codes that the initiator could have caused,
 508      * to avoid information leakage.
 509      */
 510     switch (minorStatus) {
 511     case GSSEAP_WRONG_SIZE:
 512     case GSSEAP_WRONG_MECH:
 513     case GSSEAP_BAD_TOK_HEADER:
 514     case GSSEAP_TOK_TRUNC:
 515     case GSSEAP_BAD_DIRECTION:
 516     case GSSEAP_WRONG_TOK_ID:
 517     case GSSEAP_REFLECT:
 518     case GSSEAP_CRIT_EXT_UNAVAILABLE:
 519     case GSSEAP_MISSING_REQUIRED_EXT:
 520     case GSSEAP_KEY_UNAVAILABLE:
 521     case GSSEAP_KEY_TOO_SHORT:
 522     case GSSEAP_RADIUS_AUTH_FAILURE:
 523     case GSSEAP_UNKNOWN_RADIUS_CODE:
 524     case GSSEAP_MISSING_EAP_REQUEST:
 525         break;
 526     default:
 527         if (IS_RADIUS_ERROR(minorStatus))
 528             /* Squash RADIUS error codes */
 529             minorStatus = GSSEAP_GENERIC_RADIUS_ERROR;
 530         else
 531             /* Don't return system error codes */
 532             return GSS_S_COMPLETE;
 533     }
 534
 535     minorStatus -= ERROR_TABLE_BASE_eapg;
 536
 537     store_uint32_be(majorStatus, &errorData[0]);
 538     store_uint32_be(minorStatus, &errorData[4]);
 539
 540     errorBuffer.length = sizeof(errorData);
 541     errorBuffer.value = errorData;
 542
 543     return duplicateBuffer(minor, &errorBuffer, outputToken);
 544 }
 545
 546 static struct gss_eap_acceptor_sm {
 547     enum gss_eap_token_type inputTokenType;
 548     enum gss_eap_token_type outputTokenType;
 549     OM_uint32 (*processToken)(OM_uint32 *,
 550                               gss_ctx_id_t,
 551                               gss_cred_id_t,
 552                               gss_buffer_t,
 553                               gss_channel_bindings_t,
 554                               gss_buffer_t);
 555 } eapGssAcceptorSm[] = {
 556     { TOK_TYPE_EAP_RESP,    TOK_TYPE_EAP_REQ,       eapGssSmAcceptIdentity           },
 557     { TOK_TYPE_EAP_RESP,    TOK_TYPE_EAP_REQ,       eapGssSmAcceptAuthenticate       },
 558     { TOK_TYPE_EXT_REQ,     TOK_TYPE_NONE,          eapGssSmAcceptExtensionsReq      },
 559     { TOK_TYPE_NONE,        TOK_TYPE_EXT_RESP,      eapGssSmAcceptExtensionsResp     },
 560     { TOK_TYPE_NONE,        TOK_TYPE_NONE,          eapGssSmAcceptEstablished        },
 561     { TOK_TYPE_NONE,        TOK_TYPE_CONTEXT_ERR,   NULL                             },
 562 #ifdef GSSEAP_ENABLE_REAUTH
 563     { TOK_TYPE_GSS_REAUTH,  TOK_TYPE_GSS_REAUTH,    eapGssSmAcceptGssReauth          },
 564 #endif
 565 };
 566
 567 OM_uint32
 568 gss_accept_sec_context(OM_uint32 *minor,
 569                        gss_ctx_id_t *context_handle,
 570                        gss_cred_id_t cred,
 571                        gss_buffer_t input_token,
 572                        gss_channel_bindings_t input_chan_bindings,
 573                        gss_name_t *src_name,
 574                        gss_OID *mech_type,
 575                        gss_buffer_t output_token,
 576                        OM_uint32 *ret_flags,
 577                        OM_uint32 *time_rec,
 578                        gss_cred_id_t *delegated_cred_handle)
 579 {
 580     OM_uint32 major;
 581     OM_uint32 tmpMajor, tmpMinor;
 582     gss_ctx_id_t ctx = *context_handle;
 583     struct gss_eap_acceptor_sm *sm = NULL;
 584     gss_buffer_desc innerInputToken = GSS_C_EMPTY_BUFFER;
 585     gss_buffer_desc innerOutputToken = GSS_C_EMPTY_BUFFER;
 586     enum gss_eap_token_type tokType;
 587     int initialContextToken = 0;
 588
 589     *minor = 0;
 590
 591     output_token->length = 0;
 592     output_token->value = NULL;
 593
 594     if (input_token == GSS_C_NO_BUFFER || input_token->length == 0) {
 595         *minor = GSSEAP_TOK_TRUNC;
 596         return GSS_S_DEFECTIVE_TOKEN;
 597     }
 598
 599     if (ctx == GSS_C_NO_CONTEXT) {
 600         major = gssEapAllocContext(minor, &ctx);
 601         if (GSS_ERROR(major))
 602             return major;
 603
 604         initialContextToken = 1;
 605         *context_handle = ctx;
 606     }
 607
 608     GSSEAP_MUTEX_LOCK(&ctx->mutex);
 609
 610     /* Validate and lock credentials */
 611     if (cred != GSS_C_NO_CREDENTIAL) {
 612         GSSEAP_MUTEX_LOCK(&cred->mutex);
 613
 614         if ((cred->flags & CRED_FLAG_ACCEPT) == 0) {
 615             *minor = GSSEAP_CRED_USAGE_MISMATCH;
 616             major = GSS_S_NO_CRED;
 617             goto cleanup;
 618         }
 619     }
 620
 621     sm = &eapGssAcceptorSm[ctx->state];
 622
 623     major = gssEapVerifyToken(minor, ctx, input_token,
 624                               &tokType, &innerInputToken);
 625     if (GSS_ERROR(major))
 626         goto cleanup;
 627
 628     if (!gssEapCredAvailable(cred, ctx->mechanismUsed)) {
 629         *minor = GSSEAP_CRED_MECH_MISMATCH;
 630         major = GSS_S_BAD_MECH;
 631         goto cleanup;
 632     }
 633
 634 #ifdef GSSEAP_ENABLE_REAUTH
 635     /*
 636      * If we're built with fast reauthentication support, it's valid
 637      * for an initiator to send a GSS reauthentication token as its
 638      * initial context token, causing us to short-circuit the state
 639      * machine and process Kerberos GSS messages instead.
 640      */
 641     if (tokType == TOK_TYPE_GSS_REAUTH && initialContextToken) {
 642         ctx->state = EAP_STATE_KRB_REAUTH_GSS;
 643     } else
 644 #endif
 645     if (tokType != sm->inputTokenType) {
 646         *minor = GSSEAP_WRONG_TOK_ID;
 647         major = GSS_S_DEFECTIVE_TOKEN;
 648         goto cleanup;
 649     }
 650
 651     do {
 652         sm = &eapGssAcceptorSm[ctx->state];
 653
 654         major = (sm->processToken)(minor,
 655                                    ctx,
 656                                    cred,
 657                                    &innerInputToken,
 658                                    input_chan_bindings,
 659                                    &innerOutputToken);
 660         if (GSS_ERROR(major)) {
 661             /* Possibly generate an error token */
 662             tmpMajor = makeErrorToken(&tmpMinor, major, *minor, &innerOutputToken);
 663             if (GSS_ERROR(tmpMajor)) {
 664                 major = tmpMajor;
 665                 goto cleanup;
 666             }
 667
 668             sm = &eapGssAcceptorSm[EAP_STATE_ERROR];
 669             goto send_token;
 670         }
 671     } while (major == GSS_S_CONTINUE_NEEDED && innerOutputToken.length == 0);
 672
 673     if (mech_type != NULL) {
 674         if (!gssEapInternalizeOid(ctx->mechanismUsed, mech_type))
 675             duplicateOid(&tmpMinor, ctx->mechanismUsed, mech_type);
 676     }
 677     if (ret_flags != NULL)
 678         *ret_flags = ctx->gssFlags;
 679     if (delegated_cred_handle != NULL)
 680         *delegated_cred_handle = GSS_C_NO_CREDENTIAL;
 681
 682     if (major == GSS_S_COMPLETE) {
 683         if (src_name != NULL && ctx->initiatorName != GSS_C_NO_NAME) {
 684             major = gssEapDuplicateName(&tmpMinor, ctx->initiatorName, src_name);
 685             if (GSS_ERROR(major))
 686                 goto cleanup;
 687         }
 688         if (time_rec != NULL) {
 689             major = gssEapContextTime(&tmpMinor, ctx, time_rec);
 690             if (GSS_ERROR(major))
 691                 goto cleanup;
 692         }
 693     }
 694
 695     assert(ctx->state == EAP_STATE_ESTABLISHED || major == GSS_S_CONTINUE_NEEDED);
 696
 697 send_token:
 698     if (innerOutputToken.value != NULL) {
 699         tmpMajor = gssEapMakeToken(&tmpMinor, ctx, &innerOutputToken,
 700                                    sm->outputTokenType, output_token);
 701         if (GSS_ERROR(tmpMajor)) {
 702             major = tmpMajor;
 703             *minor = tmpMinor;
 704             goto cleanup;
 705         }
 706     }
 707
 708 cleanup:
 709     if (cred != GSS_C_NO_CREDENTIAL)
 710         GSSEAP_MUTEX_UNLOCK(&cred->mutex);
 711     GSSEAP_MUTEX_UNLOCK(&ctx->mutex);
 712
 713     if (GSS_ERROR(major))
 714         gssEapReleaseContext(&tmpMinor, context_handle);
 715
 716     gss_release_buffer(&tmpMinor, &innerOutputToken);
 717
 718     return major;
 719 }
 720
 721 #ifdef GSSEAP_ENABLE_REAUTH
 722 static OM_uint32
 723 acceptReadyKrb(OM_uint32 *minor,
 724                gss_ctx_id_t ctx,
 725                gss_cred_id_t cred,
 726                const gss_name_t initiator,
 727                const gss_OID mech,
 728                OM_uint32 timeRec)
 729 {
 730     OM_uint32 major;
 731
 732     major = gssEapGlueToMechName(minor, initiator, &ctx->initiatorName);
 733     if (GSS_ERROR(major))
 734         return major;
 735
 736     if (cred != GSS_C_NO_CREDENTIAL && cred->name != GSS_C_NO_NAME) {
 737         major = gssEapDuplicateName(minor, cred->name, &ctx->acceptorName);
 738         if (GSS_ERROR(major))
 739             return major;
 740     }
 741
 742     major = gssEapReauthComplete(minor, ctx, cred, mech, timeRec);
 743     if (GSS_ERROR(major))
 744         return major;
 745
 746     ctx->state = EAP_STATE_ESTABLISHED;
 747
 748     *minor = 0;
 749     return GSS_S_COMPLETE;
 750 }
 751
 752 static OM_uint32
 753 eapGssSmAcceptGssReauth(OM_uint32 *minor,
 754                         gss_ctx_id_t ctx,
 755                         gss_cred_id_t cred,
 756                         gss_buffer_t inputToken,
 757                         gss_channel_bindings_t chanBindings,
 758                         gss_buffer_t outputToken)
 759 {
 760     OM_uint32 major, tmpMinor;
 761     gss_cred_id_t krbCred = GSS_C_NO_CREDENTIAL;
 762     gss_name_t krbInitiator = GSS_C_NO_NAME;
 763     gss_OID mech = GSS_C_NO_OID;
 764     OM_uint32 gssFlags, timeRec = GSS_C_INDEFINITE;
 765
 766     ctx->flags |= CTX_FLAG_KRB_REAUTH_GSS;
 767
 768     if (cred != GSS_C_NO_CREDENTIAL)
 769         krbCred = cred->krbCred;
 770
 771     major = gssAcceptSecContext(minor,
 772                                 &ctx->kerberosCtx,
 773                                 krbCred,
 774                                 inputToken,
 775                                 chanBindings,
 776                                 &krbInitiator,
 777                                 &mech,
 778                                 outputToken,
 779                                 &gssFlags,
 780                                 &timeRec,
 781                                 NULL);
 782     if (major == GSS_S_COMPLETE) {
 783         major = acceptReadyKrb(minor, ctx, cred,
 784                                krbInitiator, mech, timeRec);
 785     }
 786
 787     ctx->gssFlags = gssFlags;
 788
 789     gssReleaseName(&tmpMinor, &krbInitiator);
 790
 791     return major;
 792 }
 793 #endif /* GSSEAP_ENABLE_REAUTH */