X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=init_sec_context.c;h=f7eda203d6bb060a3de85a81ddc1a1131cf8444d;hb=15c93f06ee6ddefa7e7b095351f6e66698c7cc9e;hp=050f33549d290dee6c95f6a1604fb413984d2646;hpb=849faf84b633a519a29c54f182a4ac643425b760;p=mech_eap.git diff --git a/init_sec_context.c b/init_sec_context.c index 050f335..f7eda20 100644 --- a/init_sec_context.c +++ b/init_sec_context.c @@ -32,6 +32,20 @@ #include "gssapiP_eap.h" +#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 + static OM_uint32 policyVariableToFlag(enum eapol_bool_var variable) { @@ -195,6 +209,13 @@ peerConfigInit(OM_uint32 *minor, krb5_error_code code; char *identity; + eapPeerConfig->identity = NULL; + eapPeerConfig->identity_len = 0; + eapPeerConfig->password = NULL; + eapPeerConfig->password_len = 0; + + assert(cred != GSS_C_NO_CREDENTIAL); + GSSEAP_KRB_INIT(&krbContext); eapPeerConfig->fragment_size = 1024; @@ -229,51 +250,48 @@ peerConfigFree(OM_uint32 *minor, } static OM_uint32 -initReady(OM_uint32 *minor, gss_ctx_id_t ctx) +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 */ + if (reqFlags & GSS_C_MUTUAL_FLAG) + ctx->gssFlags |= GSS_C_MUTUAL_FLAG; +#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, @@ -283,50 +301,59 @@ initReady(OM_uint32 *minor, gss_ctx_id_t ctx) if (GSS_ERROR(major)) return major; + *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) +initBegin(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) { - time_t now; OM_uint32 major; - int initialContextToken; - initialContextToken = (inputToken == GSS_C_NO_BUFFER || - inputToken->length == 0); - if (!initialContextToken) - return GSS_S_DEFECTIVE_TOKEN; + assert(cred != GSS_C_NO_CREDENTIAL); - time(&now); - if (timeReq == 0 || timeReq == GSS_C_INDEFINITE) + if (cred->expiryTime) + ctx->expiryTime = cred->expiryTime; + else if (timeReq == 0 || timeReq == GSS_C_INDEFINITE) ctx->expiryTime = 0; else - ctx->expiryTime = now + timeReq; + ctx->expiryTime = time(NULL) + timeReq; - major = gss_duplicate_name(minor, cred->name, &ctx->initiatorName); + /* + * 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 = gss_duplicate_name(minor, target, &ctx->acceptorName); - if (GSS_ERROR(major)) + GSSEAP_MUTEX_LOCK(&target->mutex); + + major = gssEapDuplicateName(minor, target, &ctx->acceptorName); + if (GSS_ERROR(major)) { + GSSEAP_MUTEX_UNLOCK(&target->mutex); return major; + } - if (mech == GSS_C_NULL_OID || oidEqual(mech, GSS_EAP_MECHANISM)) { + GSSEAP_MUTEX_UNLOCK(&target->mutex); + + if (mech == GSS_C_NULL_OID) { major = gssEapDefaultMech(minor, &ctx->mechanismUsed); } else if (gssEapIsConcreteMechanismOid(mech)) { if (!gssEapInternalizeOid(mech, &ctx->mechanismUsed)) major = duplicateOid(minor, mech, &ctx->mechanismUsed); } else { + *minor = GSSEAP_WRONG_MECH; major = GSS_S_BAD_MECH; } if (GSS_ERROR(major)) @@ -336,6 +363,36 @@ eapGssSmInitIdentity(OM_uint32 *minor, if (!gssEapCredAvailable(cred, ctx->mechanismUsed)) return GSS_S_BAD_MECH; + 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) +{ + OM_uint32 major; + int initialContextToken; + + initialContextToken = (inputToken->length == 0); + if (!initialContextToken) { + *minor = GSSEAP_WRONG_SIZE; + return GSS_S_DEFECTIVE_TOKEN; + } + + major = initBegin(minor, cred, ctx, target, mech, + reqFlags, timeReq, chanBindings, + inputToken, outputToken); + if (GSS_ERROR(major)) + return major; + ctx->state = EAP_STATE_AUTHENTICATE; return GSS_S_CONTINUE_NEEDED; @@ -378,6 +435,7 @@ eapGssSmInitAuthenticate(OM_uint32 *minor, ctx, &eapConfig); if (ctx->initiatorCtx.eap == NULL) { + *minor = GSSEAP_PEER_INIT_FAILURE; major = GSS_S_FAILURE; goto cleanup; } @@ -398,19 +456,21 @@ eapGssSmInitAuthenticate(OM_uint32 *minor, resp = eap_get_eapRespData(ctx->initiatorCtx.eap); } else if (ctx->flags & CTX_FLAG_EAP_SUCCESS) { - major = initReady(minor, ctx); + major = initReady(minor, ctx, reqFlags); if (GSS_ERROR(major)) goto cleanup; ctx->flags &= ~(CTX_FLAG_EAP_SUCCESS); major = GSS_S_CONTINUE_NEEDED; - ctx->state = EAP_STATE_GSS_CHANNEL_BINDINGS; + ctx->state = EAP_STATE_EXTENSIONS_REQ; } else if (ctx->flags & CTX_FLAG_EAP_FAIL) { + *minor = GSSEAP_PEER_AUTH_FAILURE; major = GSS_S_DEFECTIVE_CREDENTIAL; } else if (code == 0 && initialContextToken) { resp = &emptyWpaBuffer; major = GSS_S_CONTINUE_NEEDED; } else { + *minor = GSSEAP_PEER_BAD_MESSAGE; major = GSS_S_DEFECTIVE_TOKEN; } @@ -438,55 +498,51 @@ cleanup: } static OM_uint32 -eapGssSmInitGssChannelBindings(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) +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) { OM_uint32 major; - gss_iov_buffer_desc iov[2]; - gss_buffer_desc buf; - - iov[0].type = GSS_IOV_BUFFER_TYPE_DATA; - iov[0].buffer.length = 0; - iov[0].buffer.value = NULL; - iov[1].type = GSS_IOV_BUFFER_TYPE_HEADER | GSS_IOV_BUFFER_FLAG_ALLOCATE; - iov[1].buffer.length = 0; - iov[1].buffer.value = NULL; + major = gssEapMakeExtensions(minor, cred, ctx, chanBindings, outputToken); + if (GSS_ERROR(major)) + return major; - if (chanBindings != GSS_C_NO_CHANNEL_BINDINGS) - iov[0].buffer = chanBindings->application_data; + assert(outputToken->value != NULL); - major = gssEapWrapOrGetMIC(minor, ctx, FALSE, FALSE, iov, 2, - TOK_TYPE_GSS_CB); - if (GSS_ERROR(major)) - goto cleanup; + ctx->state = EAP_STATE_EXTENSIONS_RESP; - /* Skip past token ID */ - assert(iov[1].buffer.length > 2); - assert(load_uint16_be(iov[1].buffer.value) == TOK_TYPE_GSS_CB); + return GSS_S_CONTINUE_NEEDED; +} - buf.length = iov[1].buffer.length - 2; - buf.value = (unsigned char *)iov[1].buffer.value + 2; +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) +{ + OM_uint32 major; - major = duplicateBuffer(minor, &buf, outputToken); + major = gssEapVerifyExtensions(minor, cred, ctx, chanBindings, inputToken); if (GSS_ERROR(major)) - goto cleanup; + return major; - major = GSS_S_COMPLETE; ctx->state = EAP_STATE_ESTABLISHED; -cleanup: - gssEapReleaseIov(iov, 2); - - return major; + return GSS_S_COMPLETE; } static OM_uint32 @@ -502,7 +558,7 @@ eapGssSmInitEstablished(OM_uint32 *minor, gss_buffer_t outputToken) { /* Called with already established context */ - *minor = EINVAL; + *minor = GSSEAP_CONTEXT_ESTABLISHED; return GSS_S_BAD_STATUS; } @@ -520,10 +576,14 @@ static struct gss_eap_initiator_sm { 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_GSS_CB, eapGssSmInitGssChannelBindings }, - { TOK_TYPE_NONE, TOK_TYPE_NONE, eapGssSmInitEstablished }, + { 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 }, +#ifdef GSSEAP_ENABLE_REAUTH + { TOK_TYPE_GSS_REAUTH, TOK_TYPE_GSS_REAUTH, eapGssSmInitGssReauth }, +#endif }; OM_uint32 @@ -547,18 +607,18 @@ gss_init_sec_context(OM_uint32 *minor, 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; output_token->length = 0; output_token->value = NULL; - if (cred != GSS_C_NO_CREDENTIAL && !(cred->flags & CRED_FLAG_INITIATE)) { - return GSS_S_NO_CRED; - } - 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; } @@ -568,18 +628,56 @@ gss_init_sec_context(OM_uint32 *minor, ctx->flags |= CTX_FLAG_INITIATOR; + initialContextToken = 1; *context_handle = ctx; } GSSEAP_MUTEX_LOCK(&ctx->mutex); + if (cred == GSS_C_NO_CREDENTIAL) { + if (ctx->initiatorCtx.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, + NULL, + NULL); + if (GSS_ERROR(major)) + goto cleanup; + } + + cred = ctx->initiatorCtx.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) { + *minor = GSSEAP_CRED_USAGE_MISMATCH; + major = GSS_S_NO_CRED; + goto cleanup; + } + sm = &eapGssInitiatorSm[ctx->state]; if (input_token != GSS_C_NO_BUFFER) { major = gssEapVerifyToken(minor, ctx, input_token, - sm->inputTokenType, &innerInputToken); + &tokType, &innerInputToken); if (GSS_ERROR(major)) goto cleanup; + + if (tokType != sm->inputTokenType) { + *minor = GSSEAP_WRONG_TOK_ID; + major = GSS_S_DEFECTIVE_TOKEN; + goto cleanup; + } } else { innerInputToken.length = 0; innerInputToken.value = NULL; @@ -622,11 +720,13 @@ gss_init_sec_context(OM_uint32 *minor, if (ret_flags != NULL) *ret_flags = ctx->gssFlags; 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); cleanup: + if (cred != GSS_C_NO_CREDENTIAL) + GSSEAP_MUTEX_UNLOCK(&cred->mutex); GSSEAP_MUTEX_UNLOCK(&ctx->mutex); if (GSS_ERROR(major)) @@ -636,3 +736,69 @@ cleanup: 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 */