init_sec_context.c [plain text]
#include "spnego_locl.h"
#define GKIS(name) \
static \
OM_uint32 name(OM_uint32 *, gss_cred_id_t, gssspnego_ctx, \
gss_name_t, const gss_OID, \
OM_uint32, OM_uint32, const gss_channel_bindings_t, \
const gss_buffer_t, gss_buffer_t, \
OM_uint32 *, OM_uint32 *)
GKIS(spnego_initial);
GKIS(spnego_reply);
GKIS(wait_server_mic);
GKIS(step_completed);
struct mech_selection {
OM_uint32 req_flags;
gss_name_t target_name;
OM_uint32 time_req;
gss_channel_bindings_t input_chan_bindings;
gss_OID preferred_mech_type;
gss_OID negotiated_mech_type;
gss_buffer_desc optimistic_token;
OM_uint32 optimistic_flags;
gss_ctx_id_t gssctx;
int complete;
};
static OM_uint32
initiator_approved(void *userptr,
gss_name_t target_name,
const gss_cred_id_t cred,
gss_OID mech)
{
OM_uint32 min_stat, maj_stat;
gss_ctx_id_t ctx = GSS_C_NO_CONTEXT;
gss_buffer_desc out;
struct mech_selection *sel = userptr;
gss_OID negotiated_mech_type = GSS_C_NO_OID;
OM_uint32 flags = 0;
maj_stat = gss_init_sec_context(&min_stat,
cred,
&ctx,
sel->target_name,
mech,
sel->req_flags,
sel->time_req,
sel->input_chan_bindings,
GSS_C_NO_BUFFER,
&negotiated_mech_type,
&out,
&flags,
NULL);
if (GSS_ERROR(maj_stat)) {
gss_mg_collect_error(mech, GSS_S_BAD_MECH, min_stat);
return GSS_S_BAD_MECH;
}
if (sel->preferred_mech_type == NULL) {
sel->preferred_mech_type = mech;
sel->negotiated_mech_type = negotiated_mech_type;
sel->optimistic_token = out;
sel->optimistic_flags = flags;
sel->gssctx = ctx;
if (maj_stat == GSS_S_COMPLETE)
sel->complete = 1;
} else {
gss_release_buffer(&min_stat, &out);
gss_delete_sec_context(&min_stat, &ctx, NULL);
}
return GSS_S_COMPLETE;
}
static OM_uint32
make_reply(OM_uint32 *minor_status,
gssspnego_ctx ctx,
gss_buffer_t mech_token,
gss_buffer_t output_token)
{
NegotiationToken nt;
gss_buffer_desc mic_buf;
OM_uint32 ret;
size_t size;
NegResultEnum result;
memset(&nt, 0, sizeof(nt));
nt.element = choice_NegotiationToken_negTokenResp;
nt.u.negTokenResp.negResult = NULL;
nt.u.negTokenResp.supportedMech = NULL;
output_token->length = 0;
output_token->value = NULL;
if (ctx->flags.open) {
if (ctx->flags.verified_mic == 1 || ctx->flags.require_mic == 0)
result = accept_completed;
else
result = accept_incomplete;
} else {
result = accept_incomplete;
}
if (mech_token->length == 0) {
nt.u.negTokenResp.responseToken = NULL;
} else {
ALLOC(nt.u.negTokenResp.responseToken, 1);
if (nt.u.negTokenResp.responseToken == NULL) {
free_NegotiationToken(&nt);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
nt.u.negTokenResp.responseToken->length = mech_token->length;
nt.u.negTokenResp.responseToken->data = mech_token->value;
mech_token->length = 0;
mech_token->value = NULL;
}
if (ctx->flags.open && ctx->flags.sent_mic == 0) {
ctx->flags.sent_mic = 1;
ret = gss_get_mic(minor_status,
ctx->negotiated_ctx_id,
0,
&ctx->NegTokenInit_mech_types,
&mic_buf);
if (ret == GSS_S_COMPLETE) {
ALLOC(nt.u.negTokenResp.mechListMIC, 1);
if (nt.u.negTokenResp.mechListMIC == NULL) {
gss_release_buffer(minor_status, &mic_buf);
free_NegotiationToken(&nt);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
nt.u.negTokenResp.mechListMIC->length = mic_buf.length;
nt.u.negTokenResp.mechListMIC->data = mic_buf.value;
} else if (ret == GSS_S_UNAVAILABLE) {
nt.u.negTokenResp.mechListMIC = NULL;
ctx->flags.require_mic = 0;
} else {
free_NegotiationToken(&nt);
*minor_status = ENOMEM;
return gss_mg_set_error_string(GSS_SPNEGO_MECHANISM,
ret, *minor_status,
"SPNEGO failed to sign MIC");
}
} else {
nt.u.negTokenResp.mechListMIC = NULL;
}
if (gss_oid_equal(ctx->negotiated_mech_type, GSS_NTLM_MECHANISM) == 0) {
ALLOC(nt.u.negTokenResp.negResult, 1);
if (nt.u.negTokenResp.negResult == NULL) {
free_NegotiationToken(&nt);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
*nt.u.negTokenResp.negResult = result;
}
ASN1_MALLOC_ENCODE(NegotiationToken,
output_token->value, output_token->length,
&nt, &size, ret);
free_NegotiationToken(&nt);
if (ret) {
*minor_status = ret;
return GSS_S_FAILURE;
}
if (result != accept_completed)
return GSS_S_CONTINUE_NEEDED;
_gss_spnego_fixup_ntlm(ctx);
return GSS_S_COMPLETE;
}
static OM_uint32
spnego_initial(OM_uint32 * minor_status,
gss_cred_id_t cred,
gssspnego_ctx ctx,
const gss_name_t target_name,
const gss_OID mech_type,
OM_uint32 req_flags,
OM_uint32 time_req,
const gss_channel_bindings_t input_chan_bindings,
const gss_buffer_t input_token,
gss_buffer_t output_token,
OM_uint32 * ret_flags,
OM_uint32 * time_rec)
{
NegotiationToken nt;
int ret;
OM_uint32 sub, minor;
gss_buffer_desc mech_token;
size_t size;
gss_buffer_desc data;
spnego_name name = (spnego_name)target_name;
struct mech_selection sel;
*minor_status = 0;
memset (&nt, 0, sizeof(nt));
if (target_name == GSS_C_NO_NAME)
return GSS_S_BAD_NAME;
ctx->flags.local = 1;
sub = gss_import_name(&minor, &name->value, &name->type, &ctx->target_name);
if (GSS_ERROR(sub)) {
*minor_status = minor;
return sub;
}
nt.element = choice_NegotiationToken_negTokenInit;
memset(&sel, 0, sizeof(sel));
sel.target_name = ctx->target_name;
sel.preferred_mech_type = GSS_C_NO_OID;
sel.req_flags = req_flags;
sel.time_req = time_req;
sel.input_chan_bindings = (gss_channel_bindings_t)input_chan_bindings;
sub = _gss_spnego_indicate_mechtypelist(&minor,
ctx->target_name,
initiator_approved,
&sel,
0,
cred,
&nt.u.negTokenInit.mechTypes,
&ctx->preferred_mech_type);
if (GSS_ERROR(sub)) {
*minor_status = minor;
return sub;
}
nt.u.negTokenInit.reqFlags = NULL;
if (sel.gssctx == NULL) {
free_NegotiationToken(&nt);
*minor_status = 0;
return gss_mg_set_error_string(GSS_C_NO_OID, GSS_S_NO_CONTEXT, 0,
"SPNEGO could not find a prefered mechanism");
}
mech_token = sel.optimistic_token;
ctx->mech_flags = sel.optimistic_flags;
ctx->negotiated_mech_type = sel.negotiated_mech_type;
ctx->negotiated_ctx_id = sel.gssctx;
ctx->flags.maybe_open = sel.complete;
if (mech_token.length != 0) {
ALLOC(nt.u.negTokenInit.mechToken, 1);
if (nt.u.negTokenInit.mechToken == NULL) {
free_NegotiationToken(&nt);
gss_release_buffer(&minor, &mech_token);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
nt.u.negTokenInit.mechToken->length = mech_token.length;
nt.u.negTokenInit.mechToken->data = malloc(mech_token.length);
if (nt.u.negTokenInit.mechToken->data == NULL && mech_token.length != 0) {
free_NegotiationToken(&nt);
gss_release_buffer(&minor, &mech_token);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
memcpy(nt.u.negTokenInit.mechToken->data, mech_token.value, mech_token.length);
gss_release_buffer(&minor, &mech_token);
} else
nt.u.negTokenInit.mechToken = NULL;
nt.u.negTokenInit.mechListMIC = NULL;
{
MechTypeList mt;
mt.len = nt.u.negTokenInit.mechTypes.len;
mt.val = nt.u.negTokenInit.mechTypes.val;
ASN1_MALLOC_ENCODE(MechTypeList,
ctx->NegTokenInit_mech_types.value,
ctx->NegTokenInit_mech_types.length,
&mt, &size, ret);
if (ret) {
*minor_status = ret;
free_NegotiationToken(&nt);
return GSS_S_FAILURE;
}
}
ASN1_MALLOC_ENCODE(NegotiationToken, data.value, data.length, &nt, &size, ret);
free_NegotiationToken(&nt);
if (ret) {
return GSS_S_FAILURE;
}
if (data.length != size)
abort();
sub = gss_encapsulate_token(&data,
GSS_SPNEGO_MECHANISM,
output_token);
free (data.value);
if (sub) {
return sub;
}
if (ret_flags)
*ret_flags = ctx->mech_flags;
if (time_rec)
*time_rec = ctx->mech_time_rec;
ctx->initiator_state = spnego_reply;
return GSS_S_CONTINUE_NEEDED;
}
static OM_uint32
spnego_reply(OM_uint32 * minor_status,
const gss_cred_id_t cred,
gssspnego_ctx ctx,
const gss_name_t target_name,
const gss_OID mech_type,
OM_uint32 req_flags,
OM_uint32 time_req,
const gss_channel_bindings_t input_chan_bindings,
const gss_buffer_t input_token,
gss_buffer_t output_token,
OM_uint32 * ret_flags,
OM_uint32 * time_rec)
{
OM_uint32 ret, minor;
NegotiationToken resp;
gss_buffer_desc mech_output_token;
*minor_status = 0;
output_token->length = 0;
output_token->value = NULL;
mech_output_token.length = 0;
mech_output_token.value = NULL;
ret = decode_NegotiationToken(input_token->value, input_token->length,
&resp, NULL);
if (ret)
return ret;
if (resp.element != choice_NegotiationToken_negTokenResp) {
free_NegotiationToken(&resp);
*minor_status = 0;
return GSS_S_BAD_MECH;
}
if (resp.u.negTokenResp.negResult == NULL
|| *resp.u.negTokenResp.negResult == reject)
{
free_NegotiationToken(&resp);
return GSS_S_BAD_MECH;
}
if (resp.u.negTokenResp.supportedMech || ctx->flags.seen_supported_mech == 0) {
gss_OID_desc oid;
size_t len;
ctx->flags.seen_supported_mech = 1;
oid.length = der_length_oid(resp.u.negTokenResp.supportedMech);
oid.elements = malloc(oid.length);
if (oid.elements == NULL) {
free_NegotiationToken(&resp);
return GSS_S_BAD_MECH;
}
ret = der_put_oid(((uint8_t *)oid.elements) + oid.length - 1,
oid.length,
resp.u.negTokenResp.supportedMech,
&len);
if (ret || len != oid.length) {
free(oid.elements);
free_NegotiationToken(&resp);
return GSS_S_BAD_MECH;
}
if (gss_oid_equal(GSS_SPNEGO_MECHANISM, &oid)) {
free(oid.elements);
free_NegotiationToken(&resp);
return GSS_S_BAD_MECH;
}
if (!gss_oid_equal(ctx->preferred_mech_type, &oid) &&
(!gss_oid_equal(ctx->preferred_mech_type, GSS_KRB5_MECHANISM) ||
!gss_oid_equal(&oid, &_gss_spnego_mskrb_mechanism_oid_desc)))
{
free(oid.elements);
gss_delete_sec_context(&minor, &ctx->negotiated_ctx_id,
GSS_C_NO_BUFFER);
ctx->negotiated_ctx_id = GSS_C_NO_CONTEXT;
} else {
gss_duplicate_oid(minor_status, &oid, &ctx->selected_mech_type);
free(oid.elements);
}
} else if (!ctx->flags.seen_supported_mech) {
free_NegotiationToken(&resp);
return gss_mg_set_error_string(GSS_SPNEGO_MECHANISM,
GSS_S_BAD_MECH, (*minor_status = EINVAL),
"SPNEGO acceptor didn't send supportedMech");
}
if ((resp.u.negTokenResp.responseToken != NULL && resp.u.negTokenResp.responseToken->length) ||
ctx->negotiated_ctx_id == GSS_C_NO_CONTEXT) {
gss_buffer_desc mech_input_token;
if (resp.u.negTokenResp.responseToken) {
mech_input_token.length = resp.u.negTokenResp.responseToken->length;
mech_input_token.value = resp.u.negTokenResp.responseToken->data;
} else {
mech_input_token.length = 0;
mech_input_token.value = NULL;
}
ret = gss_init_sec_context(&minor,
cred,
&ctx->negotiated_ctx_id,
ctx->target_name,
ctx->selected_mech_type,
req_flags,
time_req,
input_chan_bindings,
&mech_input_token,
&ctx->negotiated_mech_type,
&mech_output_token,
&ctx->mech_flags,
&ctx->mech_time_rec);
if (GSS_ERROR(ret)) {
free_NegotiationToken(&resp);
gss_mg_collect_error(ctx->selected_mech_type, ret, minor);
*minor_status = minor;
return ret;
}
if (ret == GSS_S_COMPLETE) {
ctx->flags.open = 1;
}
} else if (*resp.u.negTokenResp.negResult == accept_completed) {
if (ctx->flags.maybe_open)
ctx->flags.open = 1;
}
if (*resp.u.negTokenResp.negResult == request_mic) {
ctx->flags.peer_require_mic = 1;
}
if (ctx->flags.open && ctx->flags.verified_mic == 0) {
ctx->flags.require_mic = _gss_spnego_require_mechlist_mic(ctx);
if (resp.u.negTokenResp.mechListMIC) {
heim_octet_string *m = resp.u.negTokenResp.mechListMIC;
ctx->flags.require_mic = 1;
if (ctx->flags.safe_omit
&& resp.u.negTokenResp.responseToken
&& der_heim_octet_string_cmp(m, resp.u.negTokenResp.responseToken) == 0)
{
ctx->flags.require_mic = 0;
}
}
} else {
ctx->flags.require_mic = 0;
}
if (ctx->flags.require_mic && resp.u.negTokenResp.mechListMIC) {
ret = _gss_spnego_verify_mechtypes_mic(minor_status, ctx,
resp.u.negTokenResp.mechListMIC);
if (ret) {
free_NegotiationToken(&resp);
return ret;
}
}
if (ctx->flags.open) {
if (*resp.u.negTokenResp.negResult == accept_completed && ctx->flags.safe_omit) {
ctx->initiator_state = step_completed;
ret = GSS_S_COMPLETE;
} else if (ctx->flags.require_mic != 0 && ctx->flags.verified_mic == 0) {
ctx->initiator_state = wait_server_mic;
ret = GSS_S_CONTINUE_NEEDED;
} else {
ctx->initiator_state = step_completed;
ret = GSS_S_COMPLETE;
}
}
if (*resp.u.negTokenResp.negResult != accept_completed ||
ctx->initiator_state != step_completed ||
mech_output_token.length)
{
OM_uint32 ret2;
ret2 = make_reply(minor_status, ctx,
&mech_output_token,
output_token);
if (ret2)
ret = ret2;
}
free_NegotiationToken(&resp);
gss_release_buffer(&minor, &mech_output_token);
if (ret_flags)
*ret_flags = ctx->mech_flags;
if (time_rec)
*time_rec = ctx->mech_time_rec;
return ret;
}
static OM_uint32
wait_server_mic(OM_uint32 * minor_status,
const gss_cred_id_t cred,
gssspnego_ctx ctx,
const gss_name_t target_name,
const gss_OID mech_type,
OM_uint32 req_flags,
OM_uint32 time_req,
const gss_channel_bindings_t input_chan_bindings,
const gss_buffer_t input_token,
gss_buffer_t output_token,
OM_uint32 * ret_flags,
OM_uint32 * time_rec)
{
OM_uint32 major_status;
NegotiationToken resp;
int ret;
ret = decode_NegotiationToken(input_token->value, input_token->length, &resp, NULL);
if (ret)
return gss_mg_set_error_string(GSS_SPNEGO_MECHANISM,
GSS_S_BAD_MECH, ret,
"Failed to decode NegotiationToken");
if (resp.element != choice_NegotiationToken_negTokenResp
|| resp.u.negTokenResp.negResult == NULL
|| *resp.u.negTokenResp.negResult != accept_completed)
{
free_NegotiationToken(&resp);
return gss_mg_set_error_string(GSS_SPNEGO_MECHANISM,
GSS_S_BAD_MECH, (*minor_status = EINVAL),
"NegToken not accept_completed");
}
if (resp.u.negTokenResp.mechListMIC) {
major_status = _gss_spnego_verify_mechtypes_mic(minor_status, ctx,
resp.u.negTokenResp.mechListMIC);
} else if (ctx->flags.safe_omit == 0) {
free_NegotiationToken(&resp);
return gss_mg_set_error_string(GSS_SPNEGO_MECHANISM,
GSS_S_BAD_MECH, (*minor_status = EINVAL),
"Waiting for MIC, but its missing in server request");
} else {
major_status = GSS_S_COMPLETE;
}
free_NegotiationToken(&resp);
if (major_status != GSS_S_COMPLETE)
return major_status;
ctx->flags.verified_mic = 1;
ctx->initiator_state = step_completed;
if (ret_flags)
*ret_flags = ctx->mech_flags;
if (time_rec)
*time_rec = ctx->mech_time_rec;
*minor_status = 0;
return GSS_S_COMPLETE;
}
static OM_uint32
step_completed(OM_uint32 * minor_status,
gss_cred_id_t cred,
gssspnego_ctx ctx,
gss_name_t name,
const gss_OID mech_type,
OM_uint32 req_flags,
OM_uint32 time_req,
const gss_channel_bindings_t input_chan_bindings,
const gss_buffer_t input_token,
gss_buffer_t output_token,
OM_uint32 * ret_flags,
OM_uint32 * time_rec)
{
return gss_mg_set_error_string(GSS_SPNEGO_MECHANISM,
GSS_S_BAD_STATUS, (*minor_status = EINVAL),
"SPNEGO called got ISC call one too many");
}
OM_uint32
_gss_spnego_init_sec_context(OM_uint32 * minor_status,
const gss_cred_id_t initiator_cred_handle,
gss_ctx_id_t * context_handle,
const gss_name_t target_name,
const gss_OID mech_type,
OM_uint32 req_flags,
OM_uint32 time_req,
const gss_channel_bindings_t input_chan_bindings,
const gss_buffer_t input_token,
gss_OID * actual_mech_type,
gss_buffer_t output_token,
OM_uint32 * ret_flags,
OM_uint32 * time_rec)
{
gssspnego_ctx ctx;
OM_uint32 ret;
if (*context_handle == GSS_C_NO_CONTEXT) {
ret = _gss_spnego_alloc_sec_context(minor_status, context_handle);
if (GSS_ERROR(ret))
return ret;
ctx = (gssspnego_ctx)*context_handle;
ctx->initiator_state = spnego_initial;
} else {
ctx = (gssspnego_ctx)*context_handle;
}
HEIMDAL_MUTEX_lock(&ctx->ctx_id_mutex);
do {
ret = ctx->initiator_state(minor_status, initiator_cred_handle, ctx, target_name,
mech_type, req_flags, time_req, input_chan_bindings, input_token,
output_token, ret_flags, time_rec);
} while (ret == GSS_S_COMPLETE &&
ctx->initiator_state != step_completed &&
output_token->length == 0);
HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex);
if (GSS_ERROR(ret)) {
OM_uint32 junk;
_gss_spnego_internal_delete_sec_context(&junk, context_handle, GSS_C_NO_BUFFER);
} else {
if (actual_mech_type)
*actual_mech_type = ctx->negotiated_mech_type;
}
return ret;
}