gss_OID mech,
OM_uint32 reqFlags,
OM_uint32 timeReq,
- gss_channel_bindings_t chanBindings,
- gss_buffer_t inputToken)
+ gss_channel_bindings_t chanBindings)
{
OM_uint32 major;
if (GSS_ERROR(major))
return major;
- GSSEAP_MUTEX_LOCK(&target->mutex);
+ 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;
+ }
- 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);
} else if (gssEapIsConcreteMechanismOid(mech)) {
assert(cred != GSS_C_NO_CREDENTIAL);
- if (ctx->state == GSSEAP_STATE_INITIAL) {
+ 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);
- if (GSS_ERROR(major))
- goto cleanup;
-
ctx->flags |= CTX_FLAG_KRB_REAUTH;
} else if ((ctx->flags & CTX_FLAG_KRB_REAUTH) == 0) {
major = GSS_S_DEFECTIVE_TOKEN;
&ctx->kerberosCtx,
mechTarget,
(gss_OID)gss_mech_krb5,
- reqFlags,
+ reqFlags | GSS_C_MUTUAL_FLAG,
timeReq,
chanBindings,
inputToken,
ctx->gssFlags = gssFlags;
- *smFlags |= SM_FLAG_STOP_EVAL;
-
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;
- ctx->state = GSSEAP_STATE_ESTABLISHED;
+ GSSEAP_SM_TRANSITION(ctx, GSSEAP_STATE_ESTABLISHED);
} else {
- *smFlags |= SM_FLAG_TRANSITION;
+ GSSEAP_SM_TRANSITION(ctx, GSSEAP_STATE_REAUTHENTICATE);
}
cleanup:
#endif
static OM_uint32
+eapGssSmInitAcceptorName(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 *smFlags)
+{
+ 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 OM_uint32
eapGssSmInitIdentity(OM_uint32 *minor,
gss_cred_id_t cred,
gss_ctx_id_t ctx,
gss_buffer_t outputToken,
OM_uint32 *smFlags)
{
- OM_uint32 major;
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);
- major = initBegin(minor, cred, ctx, target, mech,
- reqFlags, timeReq, chanBindings,
- inputToken);
- if (GSS_ERROR(major))
- return major;
-
memset(&eapConfig, 0, sizeof(eapConfig));
ctx->initiatorCtx.eap = eap_peer_sm_init(ctx,
return GSS_S_FAILURE;
}
- /* force sending of empty token */
+ GSSEAP_SM_TRANSITION_NEXT(ctx);
+
*minor = 0;
- *smFlags |= SM_FLAG_TRANSITION | SM_FLAG_FORCE_SEND_TOKEN;
return GSS_S_CONTINUE_NEEDED;
}
ctx->flags &= ~(CTX_FLAG_EAP_SUCCESS);
major = GSS_S_CONTINUE_NEEDED;
- *smFlags |= SM_FLAG_TRANSITION;
+ GSSEAP_SM_TRANSITION_NEXT(ctx);
} else if (ctx->flags & CTX_FLAG_EAP_FAIL) {
major = GSS_S_DEFECTIVE_CREDENTIAL;
*minor = GSSEAP_PEER_AUTH_FAILURE;
major = tmpMajor;
*minor = tmpMinor;
}
+
+ *smFlags |= SM_FLAG_OUTPUT_TOKEN_CRITICAL;
}
wpabuf_set(&ctx->initiatorCtx.reqData, NULL, 0);
assert(outputToken->value != NULL);
*minor = 0;
+ *smFlags |= SM_FLAG_OUTPUT_TOKEN_CRITICAL;
+
return GSS_S_CONTINUE_NEEDED;
}
{
OM_uint32 major;
- major = gssEapStoreReauthCreds(minor, ctx, cred, inputToken);
- if (GSS_ERROR(major))
- return major;
+ if (ctx->gssFlags & GSS_C_MUTUAL_FLAG) {
+ major = gssEapStoreReauthCreds(minor, ctx, cred, inputToken);
+ if (GSS_ERROR(major))
+ return major;
+ }
*minor = 0;
return GSS_S_CONTINUE_NEEDED;
#endif /* GSSEAP_ENABLE_REAUTH */
static OM_uint32
-eapGssSmInitCompleteExts(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 *smFlags)
+eapGssSmInitCompleteInitiatorExts(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 *smFlags)
+{
+ GSSEAP_SM_TRANSITION_NEXT(ctx);
+
+ *minor = 0;
+ *smFlags |= SM_FLAG_FORCE_SEND_TOKEN;
+
+ return GSS_S_CONTINUE_NEEDED;
+}
+
+static OM_uint32
+eapGssSmInitCompleteAcceptorExts(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 *smFlags)
{
+ GSSEAP_SM_TRANSITION(ctx, GSSEAP_STATE_ESTABLISHED);
+
*minor = 0;
- *smFlags |= SM_FLAG_TRANSITION | SM_FLAG_STOP_EVAL;
- return (ctx->state == GSSEAP_STATE_INITIATOR_EXTS) ?
- GSS_S_CONTINUE_NEEDED : GSS_S_COMPLETE;
+
+ return GSS_S_COMPLETE;
}
static struct gss_eap_sm eapGssInitiatorSm[] = {
ITOK_TYPE_CONTEXT_ERR,
ITOK_TYPE_NONE,
GSSEAP_STATE_ALL & ~(GSSEAP_STATE_INITIAL),
- SM_ITOK_FLAG_CRITICAL,
- eapGssSmInitError,
+ 0,
+ eapGssSmInitError
},
-#ifdef GSSEAP_ENABLE_REAUTH
{
- ITOK_TYPE_REAUTH_RESP,
- ITOK_TYPE_REAUTH_REQ,
+ ITOK_TYPE_ACCEPTOR_NAME_RESP,
+ ITOK_TYPE_ACCEPTOR_NAME_REQ,
GSSEAP_STATE_INITIAL | GSSEAP_STATE_AUTHENTICATE,
0,
- eapGssSmInitGssReauth,
+ eapGssSmInitAcceptorName
},
-#endif
#ifdef GSSEAP_DEBUG
{
ITOK_TYPE_NONE,
ITOK_TYPE_VENDOR_INFO,
GSSEAP_STATE_INITIAL,
0,
- eapGssSmInitVendorInfo,
+ 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
+ GSSEAP_STATE_REAUTHENTICATE |
+#endif
GSSEAP_STATE_INITIAL,
- SM_ITOK_FLAG_CRITICAL | SM_ITOK_FLAG_REQUIRED,
- eapGssSmInitIdentity,
+ SM_ITOK_FLAG_REQUIRED,
+ eapGssSmInitIdentity
},
{
ITOK_TYPE_EAP_REQ,
ITOK_TYPE_EAP_RESP,
GSSEAP_STATE_AUTHENTICATE,
- SM_ITOK_FLAG_CRITICAL | SM_ITOK_FLAG_REQUIRED,
- eapGssSmInitAuthenticate,
+ SM_ITOK_FLAG_REQUIRED,
+ eapGssSmInitAuthenticate
},
{
ITOK_TYPE_NONE,
ITOK_TYPE_GSS_CHANNEL_BINDINGS,
GSSEAP_STATE_INITIATOR_EXTS,
- SM_ITOK_FLAG_CRITICAL | SM_ITOK_FLAG_REQUIRED,
- eapGssSmInitGssChannelBindings,
+ SM_ITOK_FLAG_REQUIRED,
+ eapGssSmInitGssChannelBindings
},
{
ITOK_TYPE_NONE,
ITOK_TYPE_NONE,
GSSEAP_STATE_INITIATOR_EXTS,
0,
- eapGssSmInitCompleteExts
+ eapGssSmInitCompleteInitiatorExts
},
#ifdef GSSEAP_ENABLE_REAUTH
{
ITOK_TYPE_NONE,
GSSEAP_STATE_ACCEPTOR_EXTS,
0,
- eapGssSmInitReauthCreds,
+ eapGssSmInitReauthCreds
},
#endif
/* other extensions go here */
ITOK_TYPE_NONE,
GSSEAP_STATE_ACCEPTOR_EXTS,
0,
- eapGssSmInitCompleteExts
+ eapGssSmInitCompleteAcceptorExts
}
};
ctx->flags |= CTX_FLAG_INITIATOR;
+ 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;
}
if (time_rec != NULL)
gssEapContextTime(&tmpMinor, ctx, time_rec);
- assert(ctx->state == GSSEAP_STATE_ESTABLISHED || major == GSS_S_CONTINUE_NEEDED);
+ assert(CTX_IS_ESTABLISHED(ctx) || major == GSS_S_CONTINUE_NEEDED);
cleanup:
if (cred != GSS_C_NO_CREDENTIAL)