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_context *rc = ctx->acceptorCtx.radContext;
 174
 175     assert(rc != 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->radContext == NULL);
 271     assert(actx->radConn == NULL);
 272
 273     if (rs_context_create(&actx->radContext, 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->radContext, &ralloc);
 291
 292     if (rs_context_read_config(actx->radContext, configFile) != 0) {
 293         err = rs_err_ctx_pop(actx->radContext);
 294         goto fail;
 295     }
 296
 297     if (rs_conn_create(actx->radContext, &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_connection *rconn;
 332     struct rs_request *request = NULL;
 333     struct rs_packet *req = NULL, *resp = NULL;
 334     struct radius_packet *frreq, *frresp;
 335     int sendAcceptorIdentity = 0;
 336
 337     if (ctx->acceptorCtx.radContext == NULL) {
 338         /* May be NULL from an imported partial context */
 339         major = createRadiusHandle(minor, cred, ctx);
 340         if (GSS_ERROR(major))
 341             goto cleanup;
 342
 343         sendAcceptorIdentity = 1;
 344     }
 345
 346     rconn = ctx->acceptorCtx.radConn;
 347
 348     if (rs_packet_create_acc_request(rconn, &req, NULL, NULL) != 0) {
 349         major = gssEapRadiusMapError(minor, rs_err_conn_pop(rconn));
 350         goto cleanup;
 351     }
 352     frreq = rs_packet_frpkt(req);
 353
 354     if (sendAcceptorIdentity) {
 355         major = setAcceptorIdentity(minor, ctx, &frreq->vps);
 356         if (GSS_ERROR(major))
 357             goto cleanup;
 358     }
 359
 360     major = gssEapRadiusAddAvp(minor, &frreq->vps,
 361                                PW_EAP_MESSAGE, 0, inputToken);
 362     if (GSS_ERROR(major))
 363         goto cleanup;
 364
 365     if (ctx->acceptorCtx.state.length != 0) {
 366         major = gssEapRadiusAddAvp(minor, &frreq->vps, PW_STATE, 0,
 367                                    &ctx->acceptorCtx.state);
 368         if (GSS_ERROR(major))
 369             goto cleanup;
 370
 371         gss_release_buffer(&tmpMinor, &ctx->acceptorCtx.state);
 372     }
 373
 374     if (rs_request_create(rconn, &request) != 0 ||
 375         rs_request_send(request, req, &resp) != 0) {
 376         major = gssEapRadiusMapError(minor, rs_err_conn_pop(rconn));
 377         goto cleanup;
 378     }
 379
 380     assert(resp != NULL);
 381
 382     frresp = rs_packet_frpkt(resp);
 383     switch (frresp->code) {
 384     case PW_AUTHENTICATION_ACK:
 385     case PW_ACCESS_CHALLENGE:
 386         major = GSS_S_CONTINUE_NEEDED;
 387         break;
 388     case PW_AUTHENTICATION_REJECT:
 389         *minor = GSSEAP_RADIUS_AUTH_FAILURE;
 390         major = GSS_S_DEFECTIVE_CREDENTIAL;
 391         goto cleanup;
 392         break;
 393     default:
 394         *minor = GSSEAP_UNKNOWN_RADIUS_CODE;
 395         major = GSS_S_FAILURE;
 396         goto cleanup;
 397         break;
 398     }
 399
 400     major = gssEapRadiusGetAvp(minor, frresp->vps, PW_EAP_MESSAGE, 0,
 401                                outputToken, TRUE);
 402     if (major == GSS_S_UNAVAILABLE && frresp->code == PW_ACCESS_CHALLENGE) {
 403         *minor = GSSEAP_MISSING_EAP_REQUEST;
 404         major = GSS_S_DEFECTIVE_TOKEN;
 405         goto cleanup;
 406     } else if (GSS_ERROR(major))
 407         goto cleanup;
 408
 409     if (frresp->code == PW_ACCESS_CHALLENGE) {
 410         major = gssEapRadiusGetAvp(minor, frresp->vps, PW_STATE, 0,
 411                                    &ctx->acceptorCtx.state, TRUE);
 412         if (GSS_ERROR(major) && *minor != GSSEAP_NO_SUCH_ATTR)
 413             goto cleanup;
 414     } else {
 415         ctx->acceptorCtx.vps = frresp->vps;
 416         frresp->vps = NULL;
 417
 418         rs_conn_destroy(ctx->acceptorCtx.radConn);
 419         ctx->acceptorCtx.radConn = NULL;
 420
 421         major = acceptReadyEap(minor, ctx, cred);
 422         if (GSS_ERROR(major))
 423             goto cleanup;
 424
 425         ctx->state = EAP_STATE_EXTENSIONS_REQ;
 426     }
 427
 428     *minor = 0;
 429     major = GSS_S_CONTINUE_NEEDED;
 430
 431 cleanup:
 432     rs_request_destroy(request);
 433
 434     return major;
 435 }
 436
 437 static OM_uint32
 438 eapGssSmAcceptExtensionsReq(OM_uint32 *minor,
 439                             gss_ctx_id_t ctx,
 440                             gss_cred_id_t cred,
 441                             gss_buffer_t inputToken,
 442                             gss_channel_bindings_t chanBindings,
 443                             gss_buffer_t outputToken)
 444 {
 445     OM_uint32 major;
 446
 447     major = gssEapVerifyExtensions(minor, cred, ctx, chanBindings, inputToken);
 448     if (GSS_ERROR(major))
 449         return major;
 450
 451     outputToken->length = 0;
 452     outputToken->value = NULL;
 453
 454     ctx->state = EAP_STATE_EXTENSIONS_RESP;
 455
 456     *minor = 0;
 457     return GSS_S_CONTINUE_NEEDED;
 458 }
 459
 460 static OM_uint32
 461 eapGssSmAcceptExtensionsResp(OM_uint32 *minor,
 462                              gss_ctx_id_t ctx,
 463                              gss_cred_id_t cred,
 464                              gss_buffer_t inputToken,
 465                              gss_channel_bindings_t chanBindings,
 466                              gss_buffer_t outputToken)
 467 {
 468     OM_uint32 major;
 469
 470     major = gssEapMakeExtensions(minor, cred, ctx, chanBindings, outputToken);
 471     if (GSS_ERROR(major))
 472         return major;
 473
 474     ctx->state = EAP_STATE_ESTABLISHED;
 475
 476     *minor = 0;
 477     return GSS_S_COMPLETE;
 478 }
 479
 480 static OM_uint32
 481 eapGssSmAcceptEstablished(OM_uint32 *minor,
 482                           gss_ctx_id_t ctx,
 483                           gss_cred_id_t cred,
 484                           gss_buffer_t inputToken,
 485                           gss_channel_bindings_t chanBindings,
 486                           gss_buffer_t outputToken)
 487 {
 488     /* Called with already established context */
 489     *minor = GSSEAP_CONTEXT_ESTABLISHED;
 490     return GSS_S_BAD_STATUS;
 491 }
 492
 493 static OM_uint32
 494 makeErrorToken(OM_uint32 *minor,
 495                OM_uint32 majorStatus,
 496                OM_uint32 minorStatus,
 497                gss_buffer_t outputToken)
 498 {
 499     unsigned char errorData[8];
 500     gss_buffer_desc errorBuffer;
 501
 502     assert(GSS_ERROR(majorStatus));
 503
 504     /*
 505      * Only return error codes that the initiator could have caused,
 506      * to avoid information leakage.
 507      */
 508     switch (minorStatus) {
 509     case GSSEAP_WRONG_SIZE:
 510     case GSSEAP_WRONG_MECH:
 511     case GSSEAP_BAD_TOK_HEADER:
 512     case GSSEAP_TOK_TRUNC:
 513     case GSSEAP_BAD_DIRECTION:
 514     case GSSEAP_WRONG_TOK_ID:
 515     case GSSEAP_REFLECT:
 516     case GSSEAP_CRIT_EXT_UNAVAILABLE:
 517     case GSSEAP_MISSING_REQUIRED_EXT:
 518     case GSSEAP_KEY_UNAVAILABLE:
 519     case GSSEAP_KEY_TOO_SHORT:
 520     case GSSEAP_RADIUS_AUTH_FAILURE:
 521     case GSSEAP_UNKNOWN_RADIUS_CODE:
 522     case GSSEAP_MISSING_EAP_REQUEST:
 523         break;
 524     default:
 525         if (IS_RADIUS_ERROR(minorStatus))
 526             /* Squash RADIUS error codes */
 527             minorStatus = GSSEAP_GENERIC_RADIUS_ERROR;
 528         else
 529             /* Don't return system error codes */
 530             return GSS_S_COMPLETE;
 531     }
 532
 533     minorStatus -= ERROR_TABLE_BASE_eapg;
 534
 535     store_uint32_be(majorStatus, &errorData[0]);
 536     store_uint32_be(minorStatus, &errorData[4]);
 537
 538     errorBuffer.length = sizeof(errorData);
 539     errorBuffer.value = errorData;
 540
 541     return duplicateBuffer(minor, &errorBuffer, outputToken);
 542 }
 543
 544 static struct gss_eap_acceptor_sm {
 545     enum gss_eap_token_type inputTokenType;
 546     enum gss_eap_token_type outputTokenType;
 547     OM_uint32 (*processToken)(OM_uint32 *,
 548                               gss_ctx_id_t,
 549                               gss_cred_id_t,
 550                               gss_buffer_t,
 551                               gss_channel_bindings_t,
 552                               gss_buffer_t);
 553 } eapGssAcceptorSm[] = {
 554     { TOK_TYPE_EAP_RESP,    TOK_TYPE_EAP_REQ,       eapGssSmAcceptIdentity           },
 555     { TOK_TYPE_EAP_RESP,    TOK_TYPE_EAP_REQ,       eapGssSmAcceptAuthenticate       },
 556     { TOK_TYPE_EXT_REQ,     TOK_TYPE_NONE,          eapGssSmAcceptExtensionsReq      },
 557     { TOK_TYPE_NONE,        TOK_TYPE_EXT_RESP,      eapGssSmAcceptExtensionsResp     },
 558     { TOK_TYPE_NONE,        TOK_TYPE_NONE,          eapGssSmAcceptEstablished        },
 559     { TOK_TYPE_NONE,        TOK_TYPE_CONTEXT_ERR,   NULL                             },
 560 #ifdef GSSEAP_ENABLE_REAUTH
 561     { TOK_TYPE_GSS_REAUTH,  TOK_TYPE_GSS_REAUTH,    eapGssSmAcceptGssReauth          },
 562 #endif
 563 };
 564
 565 OM_uint32
 566 gss_accept_sec_context(OM_uint32 *minor,
 567                        gss_ctx_id_t *context_handle,
 568                        gss_cred_id_t cred,
 569                        gss_buffer_t input_token,
 570                        gss_channel_bindings_t input_chan_bindings,
 571                        gss_name_t *src_name,
 572                        gss_OID *mech_type,
 573                        gss_buffer_t output_token,
 574                        OM_uint32 *ret_flags,
 575                        OM_uint32 *time_rec,
 576                        gss_cred_id_t *delegated_cred_handle)
 577 {
 578     OM_uint32 major;
 579     OM_uint32 tmpMajor, tmpMinor;
 580     gss_ctx_id_t ctx = *context_handle;
 581     struct gss_eap_acceptor_sm *sm = NULL;
 582     gss_buffer_desc innerInputToken = GSS_C_EMPTY_BUFFER;
 583     gss_buffer_desc innerOutputToken = GSS_C_EMPTY_BUFFER;
 584     enum gss_eap_token_type tokType;
 585     int initialContextToken = 0;
 586
 587     *minor = 0;
 588
 589     output_token->length = 0;
 590     output_token->value = NULL;
 591
 592     if (input_token == GSS_C_NO_BUFFER || input_token->length == 0) {
 593         *minor = GSSEAP_TOK_TRUNC;
 594         return GSS_S_DEFECTIVE_TOKEN;
 595     }
 596
 597     if (ctx == GSS_C_NO_CONTEXT) {
 598         major = gssEapAllocContext(minor, &ctx);
 599         if (GSS_ERROR(major))
 600             return major;
 601
 602         initialContextToken = 1;
 603         *context_handle = ctx;
 604     }
 605
 606     GSSEAP_MUTEX_LOCK(&ctx->mutex);
 607
 608     /* Validate and lock credentials */
 609     if (cred != GSS_C_NO_CREDENTIAL) {
 610         GSSEAP_MUTEX_LOCK(&cred->mutex);
 611
 612         if ((cred->flags & CRED_FLAG_ACCEPT) == 0) {
 613             *minor = GSSEAP_CRED_USAGE_MISMATCH;
 614             major = GSS_S_NO_CRED;
 615             goto cleanup;
 616         }
 617     }
 618
 619     sm = &eapGssAcceptorSm[ctx->state];
 620
 621     major = gssEapVerifyToken(minor, ctx, input_token,
 622                               &tokType, &innerInputToken);
 623     if (GSS_ERROR(major))
 624         goto cleanup;
 625
 626     if (!gssEapCredAvailable(cred, ctx->mechanismUsed)) {
 627         *minor = GSSEAP_CRED_MECH_MISMATCH;
 628         major = GSS_S_BAD_MECH;
 629         goto cleanup;
 630     }
 631
 632 #ifdef GSSEAP_ENABLE_REAUTH
 633     /*
 634      * If we're built with fast reauthentication support, it's valid
 635      * for an initiator to send a GSS reauthentication token as its
 636      * initial context token, causing us to short-circuit the state
 637      * machine and process Kerberos GSS messages instead.
 638      */
 639     if (tokType == TOK_TYPE_GSS_REAUTH && initialContextToken) {
 640         ctx->state = EAP_STATE_KRB_REAUTH_GSS;
 641     } else
 642 #endif
 643     if (tokType != sm->inputTokenType) {
 644         *minor = GSSEAP_WRONG_TOK_ID;
 645         major = GSS_S_DEFECTIVE_TOKEN;
 646         goto cleanup;
 647     }
 648
 649     do {
 650         sm = &eapGssAcceptorSm[ctx->state];
 651
 652         major = (sm->processToken)(minor,
 653                                    ctx,
 654                                    cred,
 655                                    &innerInputToken,
 656                                    input_chan_bindings,
 657                                    &innerOutputToken);
 658         if (GSS_ERROR(major)) {
 659             /* Possibly generate an error token */
 660             tmpMajor = makeErrorToken(&tmpMinor, major, *minor, &innerOutputToken);
 661             if (GSS_ERROR(tmpMajor)) {
 662                 major = tmpMajor;
 663                 goto cleanup;
 664             }
 665
 666             sm = &eapGssAcceptorSm[EAP_STATE_ERROR];
 667             goto send_token;
 668         }
 669     } while (major == GSS_S_CONTINUE_NEEDED && innerOutputToken.length == 0);
 670
 671     if (mech_type != NULL) {
 672         if (!gssEapInternalizeOid(ctx->mechanismUsed, mech_type))
 673             duplicateOid(&tmpMinor, ctx->mechanismUsed, mech_type);
 674     }
 675     if (ret_flags != NULL)
 676         *ret_flags = ctx->gssFlags;
 677     if (delegated_cred_handle != NULL)
 678         *delegated_cred_handle = GSS_C_NO_CREDENTIAL;
 679
 680     if (major == GSS_S_COMPLETE) {
 681         if (src_name != NULL && ctx->initiatorName != GSS_C_NO_NAME) {
 682             major = gssEapDuplicateName(&tmpMinor, ctx->initiatorName, src_name);
 683             if (GSS_ERROR(major))
 684                 goto cleanup;
 685         }
 686         if (time_rec != NULL) {
 687             major = gssEapContextTime(&tmpMinor, ctx, time_rec);
 688             if (GSS_ERROR(major))
 689                 goto cleanup;
 690         }
 691     }
 692
 693     assert(ctx->state == EAP_STATE_ESTABLISHED || major == GSS_S_CONTINUE_NEEDED);
 694
 695 send_token:
 696     if (innerOutputToken.value != NULL) {
 697         tmpMajor = gssEapMakeToken(&tmpMinor, ctx, &innerOutputToken,
 698                                    sm->outputTokenType, output_token);
 699         if (GSS_ERROR(tmpMajor)) {
 700             major = tmpMajor;
 701             *minor = tmpMinor;
 702             goto cleanup;
 703         }
 704     }
 705
 706 cleanup:
 707     if (cred != GSS_C_NO_CREDENTIAL)
 708         GSSEAP_MUTEX_UNLOCK(&cred->mutex);
 709     GSSEAP_MUTEX_UNLOCK(&ctx->mutex);
 710
 711     if (GSS_ERROR(major))
 712         gssEapReleaseContext(&tmpMinor, context_handle);
 713
 714     gss_release_buffer(&tmpMinor, &innerOutputToken);
 715
 716     return major;
 717 }
 718
 719 #ifdef GSSEAP_ENABLE_REAUTH
 720 static OM_uint32
 721 acceptReadyKrb(OM_uint32 *minor,
 722                gss_ctx_id_t ctx,
 723                gss_cred_id_t cred,
 724                const gss_name_t initiator,
 725                const gss_OID mech,
 726                OM_uint32 timeRec)
 727 {
 728     OM_uint32 major;
 729
 730     major = gssEapGlueToMechName(minor, initiator, &ctx->initiatorName);
 731     if (GSS_ERROR(major))
 732         return major;
 733
 734     if (cred != GSS_C_NO_CREDENTIAL && cred->name != GSS_C_NO_NAME) {
 735         major = gssEapDuplicateName(minor, cred->name, &ctx->acceptorName);
 736         if (GSS_ERROR(major))
 737             return major;
 738     }
 739
 740     major = gssEapReauthComplete(minor, ctx, cred, mech, timeRec);
 741     if (GSS_ERROR(major))
 742         return major;
 743
 744     ctx->state = EAP_STATE_ESTABLISHED;
 745
 746     *minor = 0;
 747     return GSS_S_COMPLETE;
 748 }
 749
 750 static OM_uint32
 751 eapGssSmAcceptGssReauth(OM_uint32 *minor,
 752                         gss_ctx_id_t ctx,
 753                         gss_cred_id_t cred,
 754                         gss_buffer_t inputToken,
 755                         gss_channel_bindings_t chanBindings,
 756                         gss_buffer_t outputToken)
 757 {
 758     OM_uint32 major, tmpMinor;
 759     gss_cred_id_t krbCred = GSS_C_NO_CREDENTIAL;
 760     gss_name_t krbInitiator = GSS_C_NO_NAME;
 761     gss_OID mech = GSS_C_NO_OID;
 762     OM_uint32 gssFlags, timeRec = GSS_C_INDEFINITE;
 763
 764     ctx->flags |= CTX_FLAG_KRB_REAUTH_GSS;
 765
 766     if (cred != GSS_C_NO_CREDENTIAL)
 767         krbCred = cred->krbCred;
 768
 769     major = gssAcceptSecContext(minor,
 770                                 &ctx->kerberosCtx,
 771                                 krbCred,
 772                                 inputToken,
 773                                 chanBindings,
 774                                 &krbInitiator,
 775                                 &mech,
 776                                 outputToken,
 777                                 &gssFlags,
 778                                 &timeRec,
 779                                 NULL);
 780     if (major == GSS_S_COMPLETE) {
 781         major = acceptReadyKrb(minor, ctx, cred,
 782                                krbInitiator, mech, timeRec);
 783     }
 784
 785     ctx->gssFlags = gssFlags;
 786
 787     gssReleaseName(&tmpMinor, &krbInitiator);
 788
 789     return major;
 790 }
 791 #endif /* GSSEAP_ENABLE_REAUTH */