X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=accept_sec_context.c;h=eb1a07cc73379062a00141f0cc440c412f84af9a;hb=31355119edb3a282ab302c05e33e23430af67603;hp=3c1e98f1b53525bdc677520563b8e6cc03a7503f;hpb=2e206b746716b821cebe55a5faf3a0de8fd4967b;p=mech_eap.orig diff --git a/accept_sec_context.c b/accept_sec_context.c index 3c1e98f..eb1a07c 100644 --- a/accept_sec_context.c +++ b/accept_sec_context.c @@ -32,224 +32,205 @@ #include "gssapiP_eap.h" -#define EAP_MAX_METHODS 8 - -#define EAP_TTLS_AUTH_PAP 1 -#define EAP_TTLS_AUTH_CHAP 2 -#define EAP_TTLS_AUTH_MSCHAP 4 -#define EAP_TTLS_AUTH_MSCHAPV2 8 - -#if 1 -struct eap_user { - struct { - int vendor; - u32 method; - } methods[EAP_MAX_METHODS]; - u8 *password; - size_t password_len; - int password_hash; /* whether password is hashed with - * nt_password_hash() */ - int phase2; - int force_version; - int ttls_auth; /* bitfield of - * EAP_TTLS_AUTH_{PAP,CHAP,MSCHAP,MSCHAPV2} */ -}; - -struct eap_eapol_interface { - /* Lower layer to full authenticator variables */ - Boolean eapResp; /* shared with EAPOL Backend Authentication */ - struct wpabuf *eapRespData; - Boolean portEnabled; - int retransWhile; - Boolean eapRestart; /* shared with EAPOL Authenticator PAE */ - int eapSRTT; - int eapRTTVAR; - - /* Full authenticator to lower layer variables */ - Boolean eapReq; /* shared with EAPOL Backend Authentication */ - Boolean eapNoReq; /* shared with EAPOL Backend Authentication */ - Boolean eapSuccess; - Boolean eapFail; - Boolean eapTimeout; - struct wpabuf *eapReqData; - u8 *eapKeyData; - size_t eapKeyDataLen; - Boolean eapKeyAvailable; /* called keyAvailable in IEEE 802.1X-2004 */ - - /* AAA interface to full authenticator variables */ - Boolean aaaEapReq; - Boolean aaaEapNoReq; - Boolean aaaSuccess; - Boolean aaaFail; - struct wpabuf *aaaEapReqData; - u8 *aaaEapKeyData; - size_t aaaEapKeyDataLen; - Boolean aaaEapKeyAvailable; - int aaaMethodTimeout; - - /* Full authenticator to AAA interface variables */ - Boolean aaaEapResp; - struct wpabuf *aaaEapRespData; - /* aaaIdentity -> eap_get_identity() */ - Boolean aaaTimeout; -}; - -#define eapol_callbacks SERVER_eapol_callbacks - -struct eapol_callbacks { - int (*get_eap_user)(void *ctx, const u8 *identity, size_t identity_len, - int phase2, struct eap_user *user); - const char * (*get_eap_req_id_text)(void *ctx, size_t *len); -}; +/* + * Mark a context as ready for cryptographic operations + */ +static OM_uint32 +acceptReadyEap(OM_uint32 *minor, gss_ctx_id_t ctx, gss_cred_id_t cred) +{ + OM_uint32 major, tmpMinor; + VALUE_PAIR *vp; + gss_buffer_desc nameBuf = GSS_C_EMPTY_BUFFER; -#define eap_config SERVER_eap_config - -struct eap_config { - void *ssl_ctx; - void *msg_ctx; - void *eap_sim_db_priv; - Boolean backend_auth; - int eap_server; - u8 *pac_opaque_encr_key; - u8 *eap_fast_a_id; - size_t eap_fast_a_id_len; - char *eap_fast_a_id_info; - int eap_fast_prov; - int pac_key_lifetime; - int pac_key_refresh_time; - int eap_sim_aka_result_ind; - int tnc; - struct wps_context *wps; - const struct wpabuf *assoc_wps_ie; - const u8 *peer_addr; - int fragment_size; -}; + /* Cache encryption type derived from selected mechanism OID */ + major = gssEapOidToEnctype(minor, ctx->mechanismUsed, + &ctx->encryptionType); + if (GSS_ERROR(major)) + return major; -struct eap_sm * eap_server_sm_init(void *eapol_ctx, - struct eapol_callbacks *eapol_cb, - struct eap_config *eap_conf); -void eap_server_sm_deinit(struct eap_sm *sm); -int eap_server_sm_step(struct eap_sm *sm); -void eap_sm_notify_cached(struct eap_sm *sm); -void eap_sm_pending_cb(struct eap_sm *sm); -int eap_sm_method_pending(struct eap_sm *sm); -const u8 * eap_get_identity(struct eap_sm *sm, size_t *len); -struct eap_eapol_interface * eap_get_interface(struct eap_sm *sm); + gssEapReleaseName(&tmpMinor, &ctx->initiatorName); -#include + vp = rc_avpair_get(ctx->acceptorCtx.avps, PW_USER_NAME, 0); + if (vp != NULL) { + nameBuf.length = vp->lvalue; + nameBuf.value = vp->strvalue; + } else { + ctx->gssFlags |= GSS_C_ANON_FLAG; + } -static OM_uint32 -initTls(OM_uint32 *minor, - gss_ctx_id_t ctx) -{ - struct tls_config tconf; - struct tls_connection_params tparams; + major = gssEapImportName(minor, &nameBuf, GSS_C_NT_USER_NAME, + &ctx->initiatorName); + if (GSS_ERROR(major)) + return major; - memset(&tconf, 0, sizeof(tconf)); - ctx->acceptorCtx.tlsContext = tls_init(&tconf); - if (ctx->acceptorCtx.tlsContext == NULL) - return GSS_S_FAILURE; + ctx->initiatorName->attrCtx = gssEapCreateAttrContext(cred, ctx); - memset(&tparams, 0, sizeof(tparams)); - tparams.ca_cert = "ca.pem"; - tparams.client_cert = "server.pem"; - tparams.private_key = "server-key.pem"; + vp = rc_avpair_get(ctx->acceptorCtx.avps, + VENDOR_ATTR_MS_MPPE_SEND_KEY, + VENDOR_ID_MICROSOFT); + if (ctx->encryptionType != ENCTYPE_NULL && vp != NULL) { + major = gssEapDeriveRfc3961Key(minor, + (unsigned char *)vp->strvalue, + vp->lvalue, + ctx->encryptionType, + &ctx->rfc3961Key); + if (GSS_ERROR(major)) + return major; - if (tls_global_set_params(ctx->acceptorCtx.tlsContext, &tparams)) { - return GSS_S_FAILURE; + major = rfc3961ChecksumTypeForKey(minor, &ctx->rfc3961Key, + &ctx->checksumType); + if (GSS_ERROR(major)) + return major; + } else { + /* + * draft-howlett-eap-gss says that integrity/confidentialty should + * always be advertised as available, but if we have no keying + * material it seems confusing to the caller to advertise this. + */ + ctx->gssFlags &= ~(GSS_C_INTEG_FLAG | GSS_C_CONF_FLAG); + ctx->encryptionType = ENCTYPE_NULL; } - if (tls_global_set_verify(ctx->acceptorCtx.tlsContext, 0)) { - return GSS_S_FAILURE; - } + major = sequenceInit(minor, + &ctx->seqState, ctx->recvSeq, + ((ctx->gssFlags & GSS_C_REPLAY_FLAG) != 0), + ((ctx->gssFlags & GSS_C_SEQUENCE_FLAG) != 0), + TRUE); + if (GSS_ERROR(major)) + return major; return GSS_S_COMPLETE; } -static int -serverGetEapUser(void *ctx, - const unsigned char *identity, - size_t identityLength, - int phase2, - struct eap_user *user) +static OM_uint32 +eapGssSmAcceptIdentity(OM_uint32 *minor, + gss_ctx_id_t ctx, + gss_cred_id_t cred, + gss_buffer_t inputToken, + gss_channel_bindings_t chanBindings, + gss_buffer_t outputToken) { - gss_ctx_id_t gssCtx = (gss_ctx_id_t)ctx; - OM_uint32 major, minor; - gss_buffer_desc buf; + OM_uint32 major; + union { + struct eap_hdr pdu; + unsigned char data[5]; + } pkt; + gss_buffer_desc pktBuffer; - memset(user, 0, sizeof(*user)); + if (inputToken != GSS_C_NO_BUFFER && inputToken->length != 0) + return GSS_S_DEFECTIVE_TOKEN; - buf.length = identityLength; - buf.value = (void *)identity; + assert(ctx->acceptorCtx.radHandle == NULL); - if (phase2 == 0) { - user->methods[0].vendor = EAP_VENDOR_IETF; - user->methods[0].method = EAP_TYPE_PEAP; - return 0; + major = gssEapRadiusAllocHandle(minor, cred, &ctx->acceptorCtx.radHandle); + if (GSS_ERROR(major)) + return major; + + assert(ctx->acceptorName == GSS_C_NO_NAME); + + if (cred != GSS_C_NO_CREDENTIAL && cred->name != GSS_C_NO_NAME) { + major = gssEapDuplicateName(minor, cred->name, &ctx->acceptorName); + if (GSS_ERROR(major)) + return major; } - major = gssEapImportName(&minor, &buf, GSS_C_NT_USER_NAME, - &gssCtx->initiatorName); + pkt.pdu.code = EAP_CODE_REQUEST; + pkt.pdu.identifier = 0; + pkt.pdu.length = htons(sizeof(pkt.data)); + pkt.data[4] = EAP_TYPE_IDENTITY; + + pktBuffer.length = sizeof(pkt.data); + pktBuffer.value = pkt.data; + + major = duplicateBuffer(minor, &pktBuffer, outputToken); if (GSS_ERROR(major)) - return -1; - - /* - * OK, obviously there is no real security here, this is simply - * for testing the token exchange; this code will be completely - * replaced with libradsec once that library is available. - */ - user->methods[0].vendor = EAP_VENDOR_IETF; - user->methods[0].method = EAP_TYPE_MSCHAPV2; - user->password = (unsigned char *)strdup(" "); - user->password_len = 1; - - return 0; -} + return major; -static const char * -serverGetEapReqIdText(void *ctx, - size_t *len) -{ - *len = 0; - return NULL; + ctx->state = EAP_STATE_AUTHENTICATE; + + return GSS_S_CONTINUE_NEEDED; } -#endif static OM_uint32 -completeAccept(OM_uint32 *minor, gss_ctx_id_t ctx) +setAcceptorIdentity(OM_uint32 *minor, + gss_ctx_id_t ctx, + VALUE_PAIR **avps) { OM_uint32 major; - krb5_context krbContext; + gss_buffer_desc nameBuf; + krb5_context krbContext = NULL; + krb5_principal krbPrinc; + + /* Awaits further specification */ + if (ctx->acceptorName == GSS_C_NO_NAME) + return GSS_S_COMPLETE; GSSEAP_KRB_INIT(&krbContext); - /* Cache encryption type derived from selected mechanism OID */ - major = gssEapOidToEnctype(minor, ctx->mechanismUsed, &ctx->encryptionType); + krbPrinc = ctx->acceptorName->krbPrincipal; + assert(krbPrinc != NULL); + + if (krb5_princ_size(krbContext, krbPrinc) < 2) + return GSS_S_BAD_NAME; + + /* Acceptor-Service-Name */ + krbDataToGssBuffer(krb5_princ_component(krbContext, krbPrinc, 0), &nameBuf); + + major = addAvpFromBuffer(minor, ctx->acceptorCtx.radHandle, avps, + VENDOR_ATTR_GSS_ACCEPTOR_SERVICE_NAME, + VENDOR_ID_UKERNA, + &nameBuf); if (GSS_ERROR(major)) return major; - if (ctx->encryptionType != ENCTYPE_NULL && - ctx->acceptorCtx.eapPolInterface->eapKeyAvailable) { - major = gssEapDeriveRFC3961Key(minor, - ctx->acceptorCtx.eapPolInterface->eapKeyData, - ctx->acceptorCtx.eapPolInterface->eapKeyDataLen, - ctx->encryptionType, - &ctx->rfc3961Key); - if (GSS_ERROR(major)) + /* Acceptor-Host-Name */ + krbDataToGssBuffer(krb5_princ_component(krbContext, krbPrinc, 1), &nameBuf); + + major = addAvpFromBuffer(minor, ctx->acceptorCtx.radHandle, avps, + VENDOR_ATTR_GSS_ACCEPTOR_HOST_NAME, + VENDOR_ID_UKERNA, + &nameBuf); + if (GSS_ERROR(major)) + return major; + + if (krb5_princ_size(krbContext, krbPrinc) > 2) { + /* Acceptor-Service-Specific */ + krb5_principal_data ssiPrinc = *krbPrinc; + char *ssi; + + krb5_princ_size(krbContext, &ssiPrinc) -= 2; + krb5_princ_name(krbContext, &ssiPrinc) += 2; + + *minor = krb5_unparse_name_flags(krbContext, &ssiPrinc, + KRB5_PRINCIPAL_UNPARSE_NO_REALM, &ssi); + if (*minor != 0) + return GSS_S_FAILURE; + + nameBuf.value = ssi; + nameBuf.length = strlen(ssi); + + major = addAvpFromBuffer(minor, ctx->acceptorCtx.radHandle, avps, + VENDOR_ATTR_GSS_ACCEPTOR_SERVICE_SPECIFIC, + VENDOR_ID_UKERNA, + &nameBuf); + + if (GSS_ERROR(major)) { + krb5_free_unparsed_name(krbContext, ssi); return major; - } else { - /* - * draft-howlett-eap-gss says that integrity/confidentialty should - * always be advertised as available, but if we have no keying - * material it seems confusing to the caller to advertise this. - */ - ctx->gssFlags &= ~(GSS_C_INTEG_FLAG | GSS_C_CONF_FLAG); + } + krb5_free_unparsed_name(krbContext, ssi); } - sequenceInit(&ctx->seqState, ctx->recvSeq, - ((ctx->gssFlags & GSS_C_REPLAY_FLAG) != 0), - ((ctx->gssFlags & GSS_C_SEQUENCE_FLAG) != 0), - TRUE); + krbDataToGssBuffer(krb5_princ_realm(krbContext, krbPrinc), &nameBuf); + if (nameBuf.length != 0) { + /* Acceptor-Realm-Name */ + major = addAvpFromBuffer(minor, ctx->acceptorCtx.radHandle, avps, + VENDOR_ATTR_GSS_ACCEPTOR_REALM_NAME, + VENDOR_ID_UKERNA, + &nameBuf); + if (GSS_ERROR(major)) + return major; + } return GSS_S_COMPLETE; } @@ -262,81 +243,184 @@ eapGssSmAcceptAuthenticate(OM_uint32 *minor, gss_channel_bindings_t chanBindings, gss_buffer_t outputToken) { - OM_uint32 major; - OM_uint32 tmpMinor, tmpMajor; + OM_uint32 major, tmpMinor; int code; - struct wpabuf respData; - static struct eapol_callbacks cb = { serverGetEapUser, serverGetEapReqIdText }; - if (ctx->acceptorCtx.eap == NULL) { - struct eap_config eapConfig; + VALUE_PAIR *send = NULL; + VALUE_PAIR *received = NULL; + rc_handle *rh = ctx->acceptorCtx.radHandle; + char msgBuffer[4096]; + struct eap_hdr *pdu; + unsigned char *pos; + gss_buffer_desc nameBuf = GSS_C_EMPTY_BUFFER; + + pdu = (struct eap_hdr *)inputToken->value; + pos = (unsigned char *)(pdu + 1); + + if (inputToken->length > sizeof(*pdu) && + pdu->code == EAP_CODE_RESPONSE && + pos[0] == EAP_TYPE_IDENTITY) { + /* + * XXX TODO do we really need to set User-Name? FreeRADIUS does + * not appear to require it. + */ + major = addAvpFromBuffer(minor, rh, &send, PW_USER_NAME, 0, &nameBuf); + if (GSS_ERROR(major)) + goto cleanup; - major = initTls(minor, ctx); + major = setAcceptorIdentity(minor, ctx, &send); if (GSS_ERROR(major)) goto cleanup; + } - memset(&eapConfig, 0, sizeof(eapConfig)); - eapConfig.eap_server = 1; - eapConfig.ssl_ctx = ctx->acceptorCtx.tlsContext; + major = addAvpFromBuffer(minor, rh, &send, PW_EAP_MESSAGE, 0, inputToken); + if (GSS_ERROR(major)) + goto cleanup; - ctx->acceptorCtx.eap = eap_server_sm_init(ctx, &cb, &eapConfig); - if (ctx->acceptorCtx.eap == NULL) { - major = GSS_S_FAILURE; + if (ctx->acceptorCtx.lastStatus == CHALLENGE_RC) { + major = addAvpFromBuffer(minor, rh, &send, PW_STATE, 0, + &ctx->acceptorCtx.state); + if (GSS_ERROR(major)) goto cleanup; - } - ctx->acceptorCtx.eapPolInterface = eap_get_interface(ctx->acceptorCtx.eap); - ctx->acceptorCtx.eapPolInterface->portEnabled = TRUE; - ctx->acceptorCtx.eapPolInterface->eapRestart = TRUE; + gss_release_buffer(&tmpMinor, &ctx->acceptorCtx.state); } - if (ctx->acceptorName == GSS_C_NO_NAME && - cred != GSS_C_NO_CREDENTIAL && - cred->name != GSS_C_NO_NAME) { - major = gss_duplicate_name(minor, cred->name, &ctx->acceptorName); + code = rc_auth(rh, 0, send, &received, msgBuffer); + switch (code) { + case OK_RC: + case CHALLENGE_RC: + major = GSS_S_CONTINUE_NEEDED; + break; + case TIMEOUT_RC: + major = GSS_S_UNAVAILABLE; + break; + case REJECT_RC: + major = GSS_S_DEFECTIVE_CREDENTIAL; + break; + default: + major = GSS_S_FAILURE; + goto cleanup; + } + + if (GSS_ERROR(major)) + goto cleanup; + + ctx->acceptorCtx.lastStatus = code; + + major = getBufferFromAvps(minor, received, PW_EAP_MESSAGE, 0, + outputToken, TRUE); + if ((major == GSS_S_UNAVAILABLE && code != OK_RC) || + GSS_ERROR(major)) + goto cleanup; + + if (code == CHALLENGE_RC) { + major = getBufferFromAvps(minor, received, PW_STATE, 0, + &ctx->acceptorCtx.state, TRUE); + if (major != GSS_S_UNAVAILABLE && GSS_ERROR(major)) + goto cleanup; + } else { + ctx->acceptorCtx.avps = received; + received = NULL; + + major = acceptReadyEap(minor, ctx, cred); if (GSS_ERROR(major)) goto cleanup; + + ctx->state = EAP_STATE_EXTENSIONS_REQ; } - wpabuf_set(&respData, inputToken->value, inputToken->length); - ctx->acceptorCtx.eapPolInterface->eapRespData = &respData; - ctx->acceptorCtx.eapPolInterface->eapResp = TRUE; + major = GSS_S_CONTINUE_NEEDED; - code = eap_server_sm_step(ctx->acceptorCtx.eap); +cleanup: + if (received != NULL) + rc_avpair_free(received); + + return major; +} + +static OM_uint32 +acceptGssChannelBindings(OM_uint32 *minor, + gss_ctx_id_t ctx, + gss_cred_id_t cred, + gss_buffer_t inputToken, + gss_channel_bindings_t chanBindings) +{ + OM_uint32 major, tmpMinor; + gss_iov_buffer_desc iov[2]; + + iov[0].type = GSS_IOV_BUFFER_TYPE_DATA | GSS_IOV_BUFFER_FLAG_ALLOCATE; + iov[0].buffer.length = 0; + iov[0].buffer.value = NULL; + + iov[1].type = GSS_IOV_BUFFER_TYPE_STREAM; + iov[1].buffer = *inputToken; + + major = gssEapUnwrapOrVerifyMIC(minor, ctx, NULL, NULL, + iov, 2, TOK_TYPE_WRAP); + if (GSS_ERROR(major)) + return major; - if (ctx->acceptorCtx.eapPolInterface->eapReq) { - ctx->acceptorCtx.eapPolInterface->eapReq = 0; + if (chanBindings != GSS_C_NO_CHANNEL_BINDINGS && + !bufferEqual(&iov[0].buffer, &chanBindings->application_data)) { + major = GSS_S_BAD_BINDINGS; + } else { major = GSS_S_CONTINUE_NEEDED; } - if (ctx->acceptorCtx.eapPolInterface->eapSuccess) { - ctx->acceptorCtx.eapPolInterface->eapSuccess = 0; - ctx->state = EAP_STATE_ESTABLISHED; - major = completeAccept(minor, ctx); - } else if (ctx->acceptorCtx.eapPolInterface->eapFail) { - ctx->acceptorCtx.eapPolInterface->eapFail = 0; - major = GSS_S_FAILURE; - } else if (code == 0) { - major = GSS_S_FAILURE; - } + gss_release_buffer(&tmpMinor, &iov[0].buffer); - if (ctx->acceptorCtx.eapPolInterface->eapReqData != NULL) { - gss_buffer_desc buf; + return major; +} - buf.length = wpabuf_len(ctx->acceptorCtx.eapPolInterface->eapReqData); - buf.value = (void *)wpabuf_head(ctx->acceptorCtx.eapPolInterface->eapReqData); +static OM_uint32 +eapGssSmAcceptExtensionsReq(OM_uint32 *minor, + gss_ctx_id_t ctx, + gss_cred_id_t cred, + gss_buffer_t inputToken, + gss_channel_bindings_t chanBindings, + gss_buffer_t outputToken) +{ + OM_uint32 major; - tmpMajor = duplicateBuffer(&tmpMinor, &buf, outputToken); - if (GSS_ERROR(tmpMajor)) { - major = tmpMajor; - *minor = tmpMinor; - goto cleanup; - } + outputToken->length = 0; + outputToken->value = NULL; + + major = acceptGssChannelBindings(minor, ctx, cred, inputToken, + chanBindings); + if (GSS_ERROR(major)) + return major; + + ctx->state = EAP_STATE_EXTENSIONS_RESP; + + return GSS_S_CONTINUE_NEEDED; +} + +static OM_uint32 +eapGssSmAcceptExtensionsResp(OM_uint32 *minor, + gss_ctx_id_t ctx, + gss_cred_id_t cred, + gss_buffer_t inputToken, + gss_channel_bindings_t chanBindings, + gss_buffer_t outputToken) +{ + OM_uint32 major, tmpMinor; + gss_buffer_desc credsToken = GSS_C_EMPTY_BUFFER; + + major = gssEapMakeReauthCreds(minor, ctx, cred, &credsToken); + if (GSS_ERROR(major)) + return major; + + ctx->state = EAP_STATE_ESTABLISHED; + + major = duplicateBuffer(minor, &credsToken, outputToken); + if (GSS_ERROR(major)) { + gss_release_buffer(&tmpMinor, &credsToken); + return major; } -cleanup: - ctx->acceptorCtx.eapPolInterface->eapRespData = NULL; + gss_release_buffer(&tmpMinor, &credsToken); - return major; + return GSS_S_COMPLETE; } static OM_uint32 @@ -352,7 +436,78 @@ eapGssSmAcceptEstablished(OM_uint32 *minor, return GSS_S_BAD_STATUS; } -static struct eap_gss_acceptor_sm { +static OM_uint32 +acceptReadyKrb(OM_uint32 *minor, + gss_ctx_id_t ctx, + gss_cred_id_t cred, + const gss_name_t initiator, + const gss_OID mech, + OM_uint32 timeRec) +{ + OM_uint32 major; + + major = gssEapGlueToMechName(minor, initiator, &ctx->initiatorName); + if (GSS_ERROR(major)) + return major; + + if (cred != GSS_C_NO_CREDENTIAL && cred->name != GSS_C_NO_NAME) { + major = gssEapDuplicateName(minor, cred->name, &ctx->acceptorName); + if (GSS_ERROR(major)) + return major; + } + + major = gssEapReauthComplete(minor, ctx, cred, mech, timeRec); + if (GSS_ERROR(major)) + return major; + + ctx->state = EAP_STATE_ESTABLISHED; + + return GSS_S_COMPLETE; +} + +static OM_uint32 +eapGssSmAcceptGssReauth(OM_uint32 *minor, + gss_ctx_id_t ctx, + gss_cred_id_t cred, + gss_buffer_t inputToken, + gss_channel_bindings_t chanBindings, + gss_buffer_t outputToken) +{ + OM_uint32 major, tmpMinor; + gss_cred_id_t krbCred = GSS_C_NO_CREDENTIAL; + gss_name_t krbInitiator = GSS_C_NO_NAME; + gss_OID mech = GSS_C_NO_OID; + OM_uint32 gssFlags, timeRec = GSS_C_INDEFINITE; + + ctx->flags |= CTX_FLAG_KRB_REAUTH_GSS; + + if (cred != GSS_C_NO_CREDENTIAL) + krbCred = cred->krbCred; + + major = gssAcceptSecContext(minor, + &ctx->kerberosCtx, + krbCred, + inputToken, + chanBindings, + &krbInitiator, + &mech, + outputToken, + &gssFlags, + &timeRec, + NULL); + if (major == GSS_S_COMPLETE) { + major = acceptReadyKrb(minor, ctx, cred, + krbInitiator, mech, timeRec); + } + + ctx->gssFlags = gssFlags & ~(GSS_C_DCE_STYLE); + + gssReleaseName(&tmpMinor, &krbInitiator); + + return major; +} + +static struct gss_eap_acceptor_sm { enum gss_eap_token_type inputTokenType; enum gss_eap_token_type outputTokenType; OM_uint32 (*processToken)(OM_uint32 *, @@ -362,11 +517,12 @@ static struct eap_gss_acceptor_sm { gss_channel_bindings_t, gss_buffer_t); } eapGssAcceptorSm[] = { - { TOK_TYPE_EAP_RESP, TOK_TYPE_EAP_REQ, eapGssSmAcceptAuthenticate }, - { TOK_TYPE_EAP_RESP, TOK_TYPE_EAP_REQ, NULL }, - { TOK_TYPE_EAP_RESP, TOK_TYPE_EAP_REQ, NULL }, - { TOK_TYPE_GSS_CB, TOK_TYPE_NONE, NULL }, - { TOK_TYPE_NONE, TOK_TYPE_NONE, eapGssSmAcceptEstablished }, + { TOK_TYPE_EAP_RESP, TOK_TYPE_EAP_REQ, eapGssSmAcceptIdentity }, + { TOK_TYPE_EAP_RESP, TOK_TYPE_EAP_REQ, eapGssSmAcceptAuthenticate }, + { TOK_TYPE_EXT_REQ, TOK_TYPE_NONE, eapGssSmAcceptExtensionsReq }, + { TOK_TYPE_NONE, TOK_TYPE_EXT_RESP, eapGssSmAcceptExtensionsResp }, + { TOK_TYPE_NONE, TOK_TYPE_NONE, eapGssSmAcceptEstablished }, + { TOK_TYPE_GSS_REAUTH, TOK_TYPE_GSS_REAUTH, eapGssSmAcceptGssReauth }, }; OM_uint32 @@ -385,14 +541,14 @@ gss_accept_sec_context(OM_uint32 *minor, OM_uint32 major; OM_uint32 tmpMajor, tmpMinor; gss_ctx_id_t ctx = *context_handle; - struct eap_gss_acceptor_sm *sm = NULL; - gss_buffer_desc innerInputToken, innerOutputToken; + struct gss_eap_acceptor_sm *sm = NULL; + gss_buffer_desc innerInputToken = GSS_C_EMPTY_BUFFER; + gss_buffer_desc innerOutputToken = GSS_C_EMPTY_BUFFER; + enum gss_eap_token_type tokType; + int initialContextToken = 0; *minor = 0; - innerOutputToken.length = 0; - innerOutputToken.value = NULL; - output_token->length = 0; output_token->value = NULL; @@ -409,6 +565,7 @@ gss_accept_sec_context(OM_uint32 *minor, if (GSS_ERROR(major)) return major; + initialContextToken = 1; *context_handle = ctx; } @@ -417,11 +574,27 @@ gss_accept_sec_context(OM_uint32 *minor, sm = &eapGssAcceptorSm[ctx->state]; major = gssEapVerifyToken(minor, ctx, input_token, - sm->inputTokenType, &innerInputToken); + &tokType, &innerInputToken); if (GSS_ERROR(major)) goto cleanup; + if (tokType == TOK_TYPE_GSS_REAUTH && initialContextToken) { + ctx->state = EAP_STATE_KRB_REAUTH_GSS; + } else if (tokType != sm->inputTokenType) { + major = GSS_S_DEFECTIVE_TOKEN; + goto cleanup; + } + + /* If credentials were provided, check they're usable with this mech */ + if (cred != GSS_C_NO_CREDENTIAL && + !gssEapCredAvailable(cred, ctx->mechanismUsed)) { + major = GSS_S_BAD_MECH; + goto cleanup; + } + do { + sm = &eapGssAcceptorSm[ctx->state]; + major = (sm->processToken)(minor, ctx, cred, @@ -436,7 +609,7 @@ gss_accept_sec_context(OM_uint32 *minor, if (!gssEapInternalizeOid(ctx->mechanismUsed, mech_type)) duplicateOid(&tmpMinor, ctx->mechanismUsed, mech_type); } - if (innerOutputToken.length != 0) { + if (innerOutputToken.value != NULL) { tmpMajor = gssEapMakeToken(&tmpMinor, ctx, &innerOutputToken, sm->outputTokenType, output_token); if (GSS_ERROR(tmpMajor)) { @@ -452,12 +625,12 @@ gss_accept_sec_context(OM_uint32 *minor, if (major == GSS_S_COMPLETE) { if (src_name != NULL && ctx->initiatorName != GSS_C_NO_NAME) { - major = gss_duplicate_name(&tmpMinor, ctx->initiatorName, src_name); + major = gssEapDuplicateName(&tmpMinor, ctx->initiatorName, src_name); if (GSS_ERROR(major)) goto cleanup; } if (time_rec != NULL) - gss_context_time(&tmpMinor, ctx, time_rec); + gssEapContextTime(&tmpMinor, ctx, time_rec); } assert(ctx->state == EAP_STATE_ESTABLISHED || major == GSS_S_CONTINUE_NEEDED);