X-Git-Url: http://www.project-moonshot.org/gitweb/?p=mech_eap.git;a=blobdiff_plain;f=init_sec_context.c;h=951ea2b7d9abb80bdbdace6b31a7074ead4f91dd;hp=6a7caff84852ebb5a9076a305f9ed61463383f1d;hb=ae79fdae047f980d01b2b4e84ccea52e24d8c7a0;hpb=7bc9efe3999f6a7e069f9249a00a540b5b2b3eaf diff --git a/init_sec_context.c b/init_sec_context.c index 6a7caff..951ea2b 100644 --- a/init_sec_context.c +++ b/init_sec_context.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010, JANET(UK) + * Copyright (c) 2011, JANET(UK) * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -30,21 +30,12 @@ * SUCH DAMAGE. */ -#include "gssapiP_eap.h" +/* + * Establish a security context on the initiator (client). These functions + * wrap around libeap. + */ -#ifdef GSSEAP_ENABLE_REAUTH -static OM_uint32 -eapGssSmInitGssReauth(OM_uint32 *minor, - gss_cred_id_t cred, - gss_ctx_id_t ctx, - gss_name_t target, - gss_OID mech, - OM_uint32 reqFlags, - OM_uint32 timeReq, - gss_channel_bindings_t chanBindings, - gss_buffer_t inputToken, - gss_buffer_t outputToken); -#endif +#include "gssapiP_eap.h" static OM_uint32 policyVariableToFlag(enum eapol_bool_var variable) @@ -170,18 +161,20 @@ peerGetEapReqData(void *ctx) } static void -peerSetConfigBlob(void *ctx, struct wpa_config_blob *blob) +peerSetConfigBlob(void *ctx GSSEAP_UNUSED, + struct wpa_config_blob *blob GSSEAP_UNUSED) { } static const struct wpa_config_blob * -peerGetConfigBlob(void *ctx, const char *name) +peerGetConfigBlob(void *ctx GSSEAP_UNUSED, + const char *name GSSEAP_UNUSED) { return NULL; } static void -peerNotifyPending(void *ctx) +peerNotifyPending(void *ctx GSSEAP_UNUSED) { } @@ -197,7 +190,9 @@ static struct eapol_callbacks gssEapPolicyCallbacks = { peerNotifyPending, }; +#ifdef GSSEAP_DEBUG extern int wpa_debug_level; +#endif static OM_uint32 peerConfigInit(OM_uint32 *minor, @@ -207,7 +202,7 @@ peerConfigInit(OM_uint32 *minor, krb5_context krbContext; struct eap_peer_config *eapPeerConfig = &ctx->initiatorCtx.eapPeerConfig; krb5_error_code code; - char *identity; + char *identity, *anonymousIdentity; eapPeerConfig->identity = NULL; eapPeerConfig->identity_len = 0; @@ -219,7 +214,16 @@ peerConfigInit(OM_uint32 *minor, GSSEAP_KRB_INIT(&krbContext); eapPeerConfig->fragment_size = 1024; +#ifdef GSSEAP_DEBUG wpa_debug_level = 0; +#endif + + assert(cred->name != GSS_C_NO_NAME); + + if ((cred->name->flags & (NAME_FLAG_NAI | NAME_FLAG_SERVICE)) == 0) { + *minor = GSSEAP_BAD_INITIATOR_NAME; + return GSS_S_BAD_NAME; + } code = krb5_unparse_name(krbContext, cred->name->krbPrincipal, &identity); if (code != 0) { @@ -227,11 +231,18 @@ peerConfigInit(OM_uint32 *minor, return GSS_S_FAILURE; } + anonymousIdentity = strchr(identity, '@'); + if (anonymousIdentity == NULL) + anonymousIdentity = ""; + eapPeerConfig->identity = (unsigned char *)identity; eapPeerConfig->identity_len = strlen(identity); + eapPeerConfig->anonymous_identity = (unsigned char *)anonymousIdentity; + eapPeerConfig->anonymous_identity_len = strlen(anonymousIdentity); eapPeerConfig->password = (unsigned char *)cred->password.value; eapPeerConfig->password_len = cred->password.length; + *minor = 0; return GSS_S_COMPLETE; } @@ -246,17 +257,19 @@ peerConfigFree(OM_uint32 *minor, krb5_free_unparsed_name(krbContext, (char *)eapPeerConfig->identity); + *minor = 0; return GSS_S_COMPLETE; } +/* + * Mark an initiator context as ready for cryptographic operations + */ static OM_uint32 initReady(OM_uint32 *minor, gss_ctx_id_t ctx, OM_uint32 reqFlags) { OM_uint32 major; const unsigned char *key; size_t keyLength; - krb5_enctype encryptionType; - int gotKey = 0; #if 1 /* XXX actually check for mutual auth */ @@ -265,42 +278,35 @@ initReady(OM_uint32 *minor, gss_ctx_id_t ctx, OM_uint32 reqFlags) #endif /* Cache encryption type derived from selected mechanism OID */ - major = gssEapOidToEnctype(minor, ctx->mechanismUsed, &encryptionType); + major = gssEapOidToEnctype(minor, ctx->mechanismUsed, &ctx->encryptionType); if (GSS_ERROR(major)) return major; - if (encryptionType != ENCTYPE_NULL && - eap_key_available(ctx->initiatorCtx.eap)) { - key = eap_get_eapKeyData(ctx->initiatorCtx.eap, &keyLength); - - if (keyLength >= EAP_EMSK_LEN) { - major = gssEapDeriveRfc3961Key(minor, - &key[EAP_EMSK_LEN / 2], - EAP_EMSK_LEN / 2, - encryptionType, - &ctx->rfc3961Key); - if (GSS_ERROR(major)) - return major; - - major = rfc3961ChecksumTypeForKey(minor, &ctx->rfc3961Key, - &ctx->checksumType); - if (GSS_ERROR(major)) - return major; - gotKey++; - } + if (!eap_key_available(ctx->initiatorCtx.eap)) { + *minor = GSSEAP_KEY_UNAVAILABLE; + return GSS_S_UNAVAILABLE; } - if (gotKey) { - ctx->encryptionType = encryptionType; - } 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); + key = eap_get_eapKeyData(ctx->initiatorCtx.eap, &keyLength); + + if (keyLength < EAP_EMSK_LEN) { + *minor = GSSEAP_KEY_TOO_SHORT; + return GSS_S_UNAVAILABLE; } + major = gssEapDeriveRfc3961Key(minor, + &key[EAP_EMSK_LEN / 2], + EAP_EMSK_LEN / 2, + ctx->encryptionType, + &ctx->rfc3961Key); + if (GSS_ERROR(major)) + return major; + + major = rfc3961ChecksumTypeForKey(minor, &ctx->rfc3961Key, + &ctx->checksumType); + if (GSS_ERROR(major)) + return major; + major = sequenceInit(minor, &ctx->seqState, ctx->recvSeq, @@ -310,6 +316,7 @@ initReady(OM_uint32 *minor, gss_ctx_id_t ctx, OM_uint32 reqFlags) if (GSS_ERROR(major)) return major; + *minor = 0; return GSS_S_COMPLETE; } @@ -319,11 +326,9 @@ initBegin(OM_uint32 *minor, gss_ctx_id_t ctx, gss_name_t target, gss_OID mech, - OM_uint32 reqFlags, + OM_uint32 reqFlags GSSEAP_UNUSED, OM_uint32 timeReq, - gss_channel_bindings_t chanBindings, - gss_buffer_t inputToken, - gss_buffer_t outputToken) + gss_channel_bindings_t chanBindings GSSEAP_UNUSED) { OM_uint32 major; @@ -336,13 +341,26 @@ initBegin(OM_uint32 *minor, else ctx->expiryTime = time(NULL) + timeReq; + /* + * The credential mutex protects its name, however we need to + * explicitly lock the acceptor name (unlikely as it may be + * that it has attributes set on it). + */ major = gssEapDuplicateName(minor, cred->name, &ctx->initiatorName); if (GSS_ERROR(major)) return major; - major = gssEapDuplicateName(minor, target, &ctx->acceptorName); - if (GSS_ERROR(major)) - return major; + if (target != GSS_C_NO_NAME) { + GSSEAP_MUTEX_LOCK(&target->mutex); + + major = gssEapDuplicateName(minor, target, &ctx->acceptorName); + if (GSS_ERROR(major)) { + GSSEAP_MUTEX_UNLOCK(&target->mutex); + return major; + } + + GSSEAP_MUTEX_UNLOCK(&target->mutex); + } if (mech == GSS_C_NULL_OID) { major = gssEapDefaultMech(minor, &ctx->mechanismUsed); @@ -351,90 +369,281 @@ initBegin(OM_uint32 *minor, major = duplicateOid(minor, mech, &ctx->mechanismUsed); } else { major = GSS_S_BAD_MECH; + *minor = GSSEAP_WRONG_MECH; } if (GSS_ERROR(major)) return major; /* If credentials were provided, check they're usable with this mech */ - if (!gssEapCredAvailable(cred, ctx->mechanismUsed)) + if (!gssEapCredAvailable(cred, ctx->mechanismUsed)) { + *minor = GSSEAP_CRED_MECH_MISMATCH; return GSS_S_BAD_MECH; + } + *minor = 0; return GSS_S_COMPLETE; } static OM_uint32 -eapGssSmInitIdentity(OM_uint32 *minor, - gss_cred_id_t cred, - gss_ctx_id_t ctx, - gss_name_t target, - gss_OID mech, - OM_uint32 reqFlags, - OM_uint32 timeReq, - gss_channel_bindings_t chanBindings, - gss_buffer_t inputToken, - gss_buffer_t outputToken) +eapGssSmInitError(OM_uint32 *minor, + gss_cred_id_t cred GSSEAP_UNUSED, + gss_ctx_id_t ctx GSSEAP_UNUSED, + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings GSSEAP_UNUSED, + gss_buffer_t inputToken, + gss_buffer_t outputToken GSSEAP_UNUSED, + OM_uint32 *smFlags GSSEAP_UNUSED) { OM_uint32 major; - int initialContextToken; + unsigned char *p; - initialContextToken = (inputToken->length == 0); - if (!initialContextToken) + if (inputToken->length < 8) { + *minor = GSSEAP_TOK_TRUNC; return GSS_S_DEFECTIVE_TOKEN; + } + + p = (unsigned char *)inputToken->value; + + major = load_uint32_be(&p[0]); + *minor = ERROR_TABLE_BASE_eapg + load_uint32_be(&p[4]); + + if (!GSS_ERROR(major) || !IS_WIRE_ERROR(*minor)) { + major = GSS_S_FAILURE; + *minor = GSSEAP_BAD_ERROR_TOKEN; + } + + assert(GSS_ERROR(major)); + + return major; +} + +#ifdef GSSEAP_ENABLE_REAUTH +static OM_uint32 +eapGssSmInitGssReauth(OM_uint32 *minor, + gss_cred_id_t cred, + gss_ctx_id_t ctx, + gss_name_t target, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags, + OM_uint32 timeReq, + gss_channel_bindings_t chanBindings, + gss_buffer_t inputToken, + gss_buffer_t outputToken, + OM_uint32 *smFlags GSSEAP_UNUSED) +{ + OM_uint32 major, tmpMinor; + gss_name_t mechTarget = GSS_C_NO_NAME; + gss_OID actualMech = GSS_C_NO_OID; + OM_uint32 gssFlags, timeRec; + + assert(cred != GSS_C_NO_CREDENTIAL); + + if (GSSEAP_SM_STATE(ctx) == GSSEAP_STATE_INITIAL) { + if (!gssEapCanReauthP(cred, target, timeReq)) + return GSS_S_CONTINUE_NEEDED; - major = initBegin(minor, cred, ctx, target, mech, - reqFlags, timeReq, chanBindings, - inputToken, outputToken); + ctx->flags |= CTX_FLAG_KRB_REAUTH; + } else if ((ctx->flags & CTX_FLAG_KRB_REAUTH) == 0) { + major = GSS_S_DEFECTIVE_TOKEN; + *minor = GSSEAP_WRONG_ITOK; + goto cleanup; + } + + major = gssEapMechToGlueName(minor, target, &mechTarget); + if (GSS_ERROR(major)) + goto cleanup; + + major = gssInitSecContext(minor, + cred->krbCred, + &ctx->kerberosCtx, + mechTarget, + (gss_OID)gss_mech_krb5, + reqFlags | GSS_C_MUTUAL_FLAG, + timeReq, + chanBindings, + inputToken, + &actualMech, + outputToken, + &gssFlags, + &timeRec); + if (GSS_ERROR(major)) + goto cleanup; + + ctx->gssFlags = gssFlags; + + if (major == GSS_S_COMPLETE) { + assert(GSSEAP_SM_STATE(ctx) == GSSEAP_STATE_REAUTHENTICATE); + + major = gssEapReauthComplete(minor, ctx, cred, actualMech, timeRec); + if (GSS_ERROR(major)) + goto cleanup; + GSSEAP_SM_TRANSITION(ctx, GSSEAP_STATE_ESTABLISHED); + } else { + GSSEAP_SM_TRANSITION(ctx, GSSEAP_STATE_REAUTHENTICATE); + } + +cleanup: + gssReleaseName(&tmpMinor, &mechTarget); + + return major; +} +#endif /* GSSEAP_ENABLE_REAUTH */ + +#ifdef GSSEAP_DEBUG +static OM_uint32 +eapGssSmInitVendorInfo(OM_uint32 *minor, + gss_cred_id_t cred GSSEAP_UNUSED, + gss_ctx_id_t ctx GSSEAP_UNUSED, + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings GSSEAP_UNUSED, + gss_buffer_t inputToken GSSEAP_UNUSED, + gss_buffer_t outputToken, + OM_uint32 *smFlags GSSEAP_UNUSED) +{ + OM_uint32 major; + + major = makeStringBuffer(minor, "JANET(UK)", outputToken); if (GSS_ERROR(major)) return major; - ctx->state = EAP_STATE_AUTHENTICATE; + return GSS_S_CONTINUE_NEEDED; +} +#endif + +static OM_uint32 +eapGssSmInitAcceptorName(OM_uint32 *minor, + gss_cred_id_t cred GSSEAP_UNUSED, + gss_ctx_id_t ctx, + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings GSSEAP_UNUSED, + gss_buffer_t inputToken GSSEAP_UNUSED, + gss_buffer_t outputToken, + OM_uint32 *smFlags GSSEAP_UNUSED) +{ + OM_uint32 major; + + if (GSSEAP_SM_STATE(ctx) == GSSEAP_STATE_INITIAL && + ctx->acceptorName != GSS_C_NO_NAME) { + + /* Send desired target name to acceptor */ + major = gssEapDisplayName(minor, ctx->acceptorName, + outputToken, NULL); + if (GSS_ERROR(major)) + return major; + } else if (inputToken != GSS_C_NO_BUFFER && + ctx->acceptorName == GSS_C_NO_NAME) { + /* Accept target name hint from acceptor */ + major = gssEapImportName(minor, inputToken, + GSS_C_NT_USER_NAME, &ctx->acceptorName); + if (GSS_ERROR(major)) + return major; + } + + /* + * Currently, other parts of the code assume that the acceptor name + * is available, hence this check. + */ + if (ctx->acceptorName == GSS_C_NO_NAME) { + *minor = GSSEAP_NO_ACCEPTOR_NAME; + return GSS_S_FAILURE; + } return GSS_S_CONTINUE_NEEDED; } -static struct wpabuf emptyWpaBuffer; +static OM_uint32 +eapGssSmInitIdentity(OM_uint32 *minor, + gss_cred_id_t cred GSSEAP_UNUSED, + gss_ctx_id_t ctx, + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings GSSEAP_UNUSED, + gss_buffer_t inputToken GSSEAP_UNUSED, + gss_buffer_t outputToken GSSEAP_UNUSED, + OM_uint32 *smFlags) +{ + struct eap_config eapConfig; + +#ifdef GSSEAP_ENABLE_REAUTH + if (GSSEAP_SM_STATE(ctx) == GSSEAP_STATE_REAUTHENTICATE) { + OM_uint32 tmpMinor; + + /* server didn't support reauthentication, sent EAP request */ + gssDeleteSecContext(&tmpMinor, &ctx->kerberosCtx, GSS_C_NO_BUFFER); + ctx->flags &= ~(CTX_FLAG_KRB_REAUTH); + GSSEAP_SM_TRANSITION(ctx, GSSEAP_STATE_INITIAL); + } else +#endif + *smFlags |= SM_FLAG_FORCE_SEND_TOKEN; + + assert((ctx->flags & CTX_FLAG_KRB_REAUTH) == 0); + assert(inputToken == GSS_C_NO_BUFFER); + + memset(&eapConfig, 0, sizeof(eapConfig)); + + ctx->initiatorCtx.eap = eap_peer_sm_init(ctx, + &gssEapPolicyCallbacks, + ctx, + &eapConfig); + if (ctx->initiatorCtx.eap == NULL) { + *minor = GSSEAP_PEER_SM_INIT_FAILURE; + return GSS_S_FAILURE; + } + + ctx->flags |= CTX_FLAG_EAP_RESTART | CTX_FLAG_EAP_PORT_ENABLED; + + /* poke EAP state machine */ + if (eap_peer_sm_step(ctx->initiatorCtx.eap) != 0) { + *minor = GSSEAP_PEER_SM_STEP_FAILURE; + return GSS_S_FAILURE; + } + + GSSEAP_SM_TRANSITION_NEXT(ctx); + + *minor = 0; + + return GSS_S_CONTINUE_NEEDED; +} static OM_uint32 eapGssSmInitAuthenticate(OM_uint32 *minor, gss_cred_id_t cred, gss_ctx_id_t ctx, - gss_name_t target, - gss_OID mech, - OM_uint32 reqFlags, - OM_uint32 timeReq, - gss_channel_bindings_t chanBindings, - gss_buffer_t inputToken, - gss_buffer_t outputToken) + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings GSSEAP_UNUSED, + gss_buffer_t inputToken GSSEAP_UNUSED, + gss_buffer_t outputToken, + OM_uint32 *smFlags) { OM_uint32 major; OM_uint32 tmpMinor; int code; struct wpabuf *resp = NULL; - int initialContextToken; - initialContextToken = (inputToken == GSS_C_NO_BUFFER || - inputToken->length == 0); + *minor = 0; + + assert(inputToken != GSS_C_NO_BUFFER); major = peerConfigInit(minor, cred, ctx); if (GSS_ERROR(major)) goto cleanup; - if (ctx->initiatorCtx.eap == NULL) { - struct eap_config eapConfig; - - memset(&eapConfig, 0, sizeof(eapConfig)); - - ctx->initiatorCtx.eap = eap_peer_sm_init(ctx, - &gssEapPolicyCallbacks, - ctx, - &eapConfig); - if (ctx->initiatorCtx.eap == NULL) { - major = GSS_S_FAILURE; - goto cleanup; - } - - ctx->flags |= CTX_FLAG_EAP_RESTART | CTX_FLAG_EAP_PORT_ENABLED; - } + assert(ctx->initiatorCtx.eap != NULL); + assert(ctx->flags & CTX_FLAG_EAP_PORT_ENABLED); ctx->flags |= CTX_FLAG_EAP_REQ; /* we have a Request from the acceptor */ @@ -455,14 +664,13 @@ eapGssSmInitAuthenticate(OM_uint32 *minor, ctx->flags &= ~(CTX_FLAG_EAP_SUCCESS); major = GSS_S_CONTINUE_NEEDED; - ctx->state = EAP_STATE_EXTENSIONS_REQ; + GSSEAP_SM_TRANSITION_NEXT(ctx); } else if (ctx->flags & CTX_FLAG_EAP_FAIL) { major = GSS_S_DEFECTIVE_CREDENTIAL; - } else if (code == 0 && initialContextToken) { - resp = &emptyWpaBuffer; - major = GSS_S_CONTINUE_NEEDED; + *minor = GSSEAP_PEER_AUTH_FAILURE; } else { major = GSS_S_DEFECTIVE_TOKEN; + *minor = GSSEAP_PEER_BAD_MESSAGE; } cleanup: @@ -480,6 +688,8 @@ cleanup: major = tmpMajor; *minor = tmpMinor; } + + *smFlags |= SM_FLAG_OUTPUT_TOKEN_CRITICAL; } wpabuf_set(&ctx->initiatorCtx.reqData, NULL, 0); @@ -489,122 +699,186 @@ cleanup: } static OM_uint32 -initGssChannelBindings(OM_uint32 *minor, - gss_ctx_id_t ctx, - gss_channel_bindings_t chanBindings, - gss_buffer_t outputToken) +eapGssSmInitGssChannelBindings(OM_uint32 *minor, + gss_cred_id_t cred GSSEAP_UNUSED, + gss_ctx_id_t ctx, + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings, + gss_buffer_t inputToken GSSEAP_UNUSED, + gss_buffer_t outputToken, + OM_uint32 *smFlags) { OM_uint32 major; gss_buffer_desc buffer = GSS_C_EMPTY_BUFFER; - if (chanBindings != GSS_C_NO_CHANNEL_BINDINGS) buffer = chanBindings->application_data; major = gssEapWrap(minor, ctx, TRUE, GSS_C_QOP_DEFAULT, &buffer, NULL, outputToken); if (GSS_ERROR(major)) - return major; + return major; + + assert(outputToken->value != NULL); + + *minor = 0; + *smFlags |= SM_FLAG_OUTPUT_TOKEN_CRITICAL; return GSS_S_CONTINUE_NEEDED; } +#ifdef GSSEAP_ENABLE_REAUTH static OM_uint32 -eapGssSmInitExtensionsReq(OM_uint32 *minor, - gss_cred_id_t cred, - gss_ctx_id_t ctx, - gss_name_t target, - gss_OID mech, - OM_uint32 reqFlags, - OM_uint32 timeReq, - gss_channel_bindings_t chanBindings, - gss_buffer_t inputToken, - gss_buffer_t outputToken) +eapGssSmInitReauthCreds(OM_uint32 *minor, + gss_cred_id_t cred, + gss_ctx_id_t ctx, + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings GSSEAP_UNUSED, + gss_buffer_t inputToken, + gss_buffer_t outputToken GSSEAP_UNUSED, + OM_uint32 *smFlags GSSEAP_UNUSED) { - OM_uint32 major, tmpMinor; - gss_buffer_desc cbToken = GSS_C_EMPTY_BUFFER; - - major = initGssChannelBindings(minor, ctx, chanBindings, &cbToken); - if (GSS_ERROR(major)) - return major; - - ctx->state = EAP_STATE_EXTENSIONS_RESP; + OM_uint32 major; - major = duplicateBuffer(minor, &cbToken, outputToken); - if (GSS_ERROR(major)) { - gss_release_buffer(&tmpMinor, &cbToken); - return major; + if (ctx->gssFlags & GSS_C_MUTUAL_FLAG) { + major = gssEapStoreReauthCreds(minor, ctx, cred, inputToken); + if (GSS_ERROR(major)) + return major; } - gss_release_buffer(&tmpMinor, &cbToken); - + *minor = 0; return GSS_S_CONTINUE_NEEDED; } +#endif /* GSSEAP_ENABLE_REAUTH */ static OM_uint32 -eapGssSmInitExtensionsResp(OM_uint32 *minor, - gss_cred_id_t cred, - gss_ctx_id_t ctx, - gss_name_t target, - gss_OID mech, - OM_uint32 reqFlags, - OM_uint32 timeReq, - gss_channel_bindings_t chanBindings, - gss_buffer_t inputToken, - gss_buffer_t outputToken) +eapGssSmInitCompleteInitiatorExts(OM_uint32 *minor, + gss_cred_id_t cred GSSEAP_UNUSED, + gss_ctx_id_t ctx, + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings GSSEAP_UNUSED, + gss_buffer_t inputToken GSSEAP_UNUSED, + gss_buffer_t outputToken GSSEAP_UNUSED, + OM_uint32 *smFlags) { -#ifdef GSSEAP_ENABLE_REAUTH - OM_uint32 major; + GSSEAP_SM_TRANSITION_NEXT(ctx); - major = gssEapStoreReauthCreds(minor, ctx, cred, inputToken); - if (GSS_ERROR(major)) - return major; -#endif - - ctx->state = EAP_STATE_ESTABLISHED; + *minor = 0; + *smFlags |= SM_FLAG_FORCE_SEND_TOKEN; - return GSS_S_COMPLETE; + return GSS_S_CONTINUE_NEEDED; } static OM_uint32 -eapGssSmInitEstablished(OM_uint32 *minor, - gss_cred_id_t cred, - gss_ctx_id_t ctx, - gss_name_t target, - gss_OID mech, - OM_uint32 reqFlags, - OM_uint32 timeReq, - gss_channel_bindings_t chanBindings, - gss_buffer_t inputToken, - gss_buffer_t outputToken) +eapGssSmInitCompleteAcceptorExts(OM_uint32 *minor, + gss_cred_id_t cred GSSEAP_UNUSED, + gss_ctx_id_t ctx, + gss_name_t target GSSEAP_UNUSED, + gss_OID mech GSSEAP_UNUSED, + OM_uint32 reqFlags GSSEAP_UNUSED, + OM_uint32 timeReq GSSEAP_UNUSED, + gss_channel_bindings_t chanBindings GSSEAP_UNUSED, + gss_buffer_t inputToken GSSEAP_UNUSED, + gss_buffer_t outputToken GSSEAP_UNUSED, + OM_uint32 *smFlags GSSEAP_UNUSED) { - /* Called with already established context */ - *minor = EINVAL; - return GSS_S_BAD_STATUS; + GSSEAP_SM_TRANSITION(ctx, GSSEAP_STATE_ESTABLISHED); + + *minor = 0; + + return GSS_S_COMPLETE; } -static struct gss_eap_initiator_sm { - enum gss_eap_token_type inputTokenType; - enum gss_eap_token_type outputTokenType; - OM_uint32 (*processToken)(OM_uint32 *, - gss_cred_id_t, - gss_ctx_id_t, - gss_name_t, - gss_OID, - OM_uint32, - OM_uint32, - gss_channel_bindings_t, - gss_buffer_t, - gss_buffer_t); -} eapGssInitiatorSm[] = { - { TOK_TYPE_NONE, TOK_TYPE_EAP_RESP, eapGssSmInitIdentity }, - { TOK_TYPE_EAP_REQ, TOK_TYPE_EAP_RESP, eapGssSmInitAuthenticate }, - { TOK_TYPE_NONE, TOK_TYPE_EXT_REQ, eapGssSmInitExtensionsReq }, - { TOK_TYPE_EXT_RESP,TOK_TYPE_NONE, eapGssSmInitExtensionsResp }, - { TOK_TYPE_NONE, TOK_TYPE_NONE, eapGssSmInitEstablished }, +static struct gss_eap_sm eapGssInitiatorSm[] = { + { + ITOK_TYPE_CONTEXT_ERR, + ITOK_TYPE_NONE, + GSSEAP_STATE_ALL & ~(GSSEAP_STATE_INITIAL), + 0, + eapGssSmInitError + }, + { + ITOK_TYPE_ACCEPTOR_NAME_RESP, + ITOK_TYPE_ACCEPTOR_NAME_REQ, + GSSEAP_STATE_INITIAL | GSSEAP_STATE_AUTHENTICATE, + 0, + eapGssSmInitAcceptorName + }, +#ifdef GSSEAP_DEBUG + { + ITOK_TYPE_NONE, + ITOK_TYPE_VENDOR_INFO, + GSSEAP_STATE_INITIAL, + 0, + eapGssSmInitVendorInfo + }, +#endif +#ifdef GSSEAP_ENABLE_REAUTH + { + ITOK_TYPE_REAUTH_RESP, + ITOK_TYPE_REAUTH_REQ, + GSSEAP_STATE_INITIAL | GSSEAP_STATE_REAUTHENTICATE, + 0, + eapGssSmInitGssReauth + }, +#endif + { + ITOK_TYPE_NONE, + ITOK_TYPE_NONE, #ifdef GSSEAP_ENABLE_REAUTH - { TOK_TYPE_GSS_REAUTH, TOK_TYPE_GSS_REAUTH, eapGssSmInitGssReauth }, + GSSEAP_STATE_REAUTHENTICATE | #endif + GSSEAP_STATE_INITIAL, + SM_ITOK_FLAG_REQUIRED, + eapGssSmInitIdentity + }, + { + ITOK_TYPE_EAP_REQ, + ITOK_TYPE_EAP_RESP, + GSSEAP_STATE_AUTHENTICATE, + SM_ITOK_FLAG_REQUIRED, + eapGssSmInitAuthenticate + }, + { + ITOK_TYPE_NONE, + ITOK_TYPE_GSS_CHANNEL_BINDINGS, + GSSEAP_STATE_INITIATOR_EXTS, + SM_ITOK_FLAG_REQUIRED, + eapGssSmInitGssChannelBindings + }, + { + ITOK_TYPE_NONE, + ITOK_TYPE_NONE, + GSSEAP_STATE_INITIATOR_EXTS, + 0, + eapGssSmInitCompleteInitiatorExts + }, +#ifdef GSSEAP_ENABLE_REAUTH + { + ITOK_TYPE_REAUTH_CREDS, + ITOK_TYPE_NONE, + GSSEAP_STATE_ACCEPTOR_EXTS, + 0, + eapGssSmInitReauthCreds + }, +#endif + /* other extensions go here */ + { + ITOK_TYPE_NONE, + ITOK_TYPE_NONE, + GSSEAP_STATE_ACCEPTOR_EXTS, + 0, + eapGssSmInitCompleteAcceptorExts + } }; OM_uint32 @@ -622,15 +896,8 @@ gss_init_sec_context(OM_uint32 *minor, OM_uint32 *ret_flags, OM_uint32 *time_rec) { - OM_uint32 major; - OM_uint32 tmpMajor, tmpMinor; + OM_uint32 major, tmpMinor; gss_ctx_id_t ctx = *context_handle; - struct gss_eap_initiator_sm *sm = NULL; - gss_buffer_desc innerInputToken; - gss_buffer_desc innerOutputToken = GSS_C_EMPTY_BUFFER; - enum gss_eap_token_type tokType; - gss_cred_id_t defaultCred = GSS_C_NO_CREDENTIAL; - int initialContextToken = 0; *minor = 0; @@ -639,6 +906,7 @@ gss_init_sec_context(OM_uint32 *minor, if (ctx == GSS_C_NO_CONTEXT) { if (input_token != GSS_C_NO_BUFFER && input_token->length != 0) { + *minor = GSSEAP_WRONG_SIZE; return GSS_S_DEFECTIVE_TOKEN; } @@ -648,99 +916,70 @@ gss_init_sec_context(OM_uint32 *minor, ctx->flags |= CTX_FLAG_INITIATOR; - initialContextToken = 1; + major = initBegin(minor, cred, ctx, target_name, mech_type, + req_flags, time_req, input_chan_bindings); + if (GSS_ERROR(major)) { + gssEapReleaseContext(minor, &ctx); + return major; + } + *context_handle = ctx; } GSSEAP_MUTEX_LOCK(&ctx->mutex); if (cred == GSS_C_NO_CREDENTIAL) { - if (ctx->initiatorCtx.defaultCred == GSS_C_NO_CREDENTIAL) { + if (ctx->defaultCred == GSS_C_NO_CREDENTIAL) { major = gssEapAcquireCred(minor, GSS_C_NO_NAME, GSS_C_NO_BUFFER, time_req, GSS_C_NO_OID_SET, GSS_C_INITIATE, - &defaultCred, + &ctx->defaultCred, NULL, NULL); if (GSS_ERROR(major)) goto cleanup; } - cred = ctx->initiatorCtx.defaultCred; + cred = ctx->defaultCred; } GSSEAP_MUTEX_LOCK(&cred->mutex); -#ifdef GSSEAP_ENABLE_REAUTH - if (initialContextToken && gssEapCanReauthP(cred, target_name, time_req)) - ctx->state = EAP_STATE_KRB_REAUTH_GSS; -#endif if ((cred->flags & CRED_FLAG_INITIATE) == 0) { major = GSS_S_NO_CRED; + *minor = GSSEAP_CRED_USAGE_MISMATCH; goto cleanup; } - sm = &eapGssInitiatorSm[ctx->state]; - - if (input_token != GSS_C_NO_BUFFER) { - major = gssEapVerifyToken(minor, ctx, input_token, - &tokType, &innerInputToken); - if (GSS_ERROR(major)) - goto cleanup; - - if (tokType != sm->inputTokenType) { - major = GSS_S_DEFECTIVE_TOKEN; - goto cleanup; - } - } else { - innerInputToken.length = 0; - innerInputToken.value = NULL; - } - - /* - * Advance through state machine whilst empty tokens are emitted and - * the status is not GSS_S_COMPLETE or an error status. - */ - do { - sm = &eapGssInitiatorSm[ctx->state]; - - major = (sm->processToken)(minor, - cred, - ctx, - target_name, - mech_type, - req_flags, - time_req, - input_chan_bindings, - &innerInputToken, - &innerOutputToken); - if (GSS_ERROR(major)) - goto cleanup; - } while (major == GSS_S_CONTINUE_NEEDED && innerOutputToken.value == NULL); + major = gssEapSmStep(minor, + cred, + ctx, + target_name, + mech_type, + req_flags, + time_req, + input_chan_bindings, + input_token, + output_token, + eapGssInitiatorSm, + sizeof(eapGssInitiatorSm) / sizeof(eapGssInitiatorSm[0])); + if (GSS_ERROR(major)) + goto cleanup; if (actual_mech_type != NULL) { if (!gssEapInternalizeOid(ctx->mechanismUsed, actual_mech_type)) duplicateOid(&tmpMinor, ctx->mechanismUsed, actual_mech_type); } - if (innerOutputToken.value != NULL) { - tmpMajor = gssEapMakeToken(&tmpMinor, ctx, &innerOutputToken, - sm->outputTokenType, output_token); - if (GSS_ERROR(tmpMajor)) { - major = tmpMajor; - *minor = tmpMinor; - goto cleanup; - } - } if (ret_flags != NULL) *ret_flags = ctx->gssFlags; if (time_rec != NULL) gssEapContextTime(&tmpMinor, ctx, time_rec); - assert(ctx->state == EAP_STATE_ESTABLISHED || major == GSS_S_CONTINUE_NEEDED); + assert(CTX_IS_ESTABLISHED(ctx) || major == GSS_S_CONTINUE_NEEDED); cleanup: if (cred != GSS_C_NO_CREDENTIAL) @@ -750,73 +989,5 @@ cleanup: if (GSS_ERROR(major)) gssEapReleaseContext(&tmpMinor, context_handle); - gss_release_buffer(&tmpMinor, &innerOutputToken); - return major; } - -#ifdef GSSEAP_ENABLE_REAUTH -static OM_uint32 -eapGssSmInitGssReauth(OM_uint32 *minor, - gss_cred_id_t cred, - gss_ctx_id_t ctx, - gss_name_t target, - gss_OID mech, - OM_uint32 reqFlags, - OM_uint32 timeReq, - gss_channel_bindings_t chanBindings, - gss_buffer_t inputToken, - gss_buffer_t outputToken) -{ - OM_uint32 major, tmpMinor; - gss_name_t mechTarget = GSS_C_NO_NAME; - gss_OID actualMech = GSS_C_NO_OID; - OM_uint32 gssFlags, timeRec; - - assert(cred != GSS_C_NO_CREDENTIAL); - - ctx->flags |= CTX_FLAG_KRB_REAUTH_GSS; - - if (inputToken->length == 0) { - major = initBegin(minor, cred, ctx, target, mech, - reqFlags, timeReq, chanBindings, - inputToken, outputToken); - if (GSS_ERROR(major)) - goto cleanup; - } - - major = gssEapMechToGlueName(minor, target, &mechTarget); - if (GSS_ERROR(major)) - goto cleanup; - - major = gssInitSecContext(minor, - cred->krbCred, - &ctx->kerberosCtx, - mechTarget, - (gss_OID)gss_mech_krb5, - reqFlags, /* | GSS_C_DCE_STYLE, */ - timeReq, - chanBindings, - inputToken, - &actualMech, - outputToken, - &gssFlags, - &timeRec); - if (GSS_ERROR(major)) - goto cleanup; - - ctx->gssFlags = gssFlags; - - if (major == GSS_S_COMPLETE) { - major = gssEapReauthComplete(minor, ctx, cred, actualMech, timeRec); - if (GSS_ERROR(major)) - goto cleanup; - ctx->state = EAP_STATE_ESTABLISHED; - } - -cleanup: - gssReleaseName(&tmpMinor, &mechTarget); - - return major; -} -#endif /* GSSEAP_ENABLE_REAUTH */