/*
* Copyright (c) 1997 - 2003 Kungliga Tekniska Högskolan
* (Royal Institute of Technology, Stockholm, Sweden).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "gssapi_locl.h"
RCSID("$Id: init_sec_context.c,v 1.63 2006/05/05 10:27:13 lha Exp $");
/*
* copy the addresses from `input_chan_bindings' (if any) to
* the auth context `ac'
*/
static OM_uint32
set_addresses (krb5_auth_context ac,
const gss_channel_bindings_t input_chan_bindings)
{
/* Port numbers are expected to be in application_data.value,
* initator's port first */
krb5_address initiator_addr, acceptor_addr;
krb5_error_code kret;
if (input_chan_bindings == GSS_C_NO_CHANNEL_BINDINGS
|| input_chan_bindings->application_data.length !=
2 * sizeof(ac->local_port))
return 0;
memset(&initiator_addr, 0, sizeof(initiator_addr));
memset(&acceptor_addr, 0, sizeof(acceptor_addr));
ac->local_port =
*(int16_t *) input_chan_bindings->application_data.value;
ac->remote_port =
*((int16_t *) input_chan_bindings->application_data.value + 1);
kret = gss_address_to_krb5addr(input_chan_bindings->acceptor_addrtype,
&input_chan_bindings->acceptor_address,
ac->remote_port,
&acceptor_addr);
if (kret)
return kret;
kret = gss_address_to_krb5addr(input_chan_bindings->initiator_addrtype,
&input_chan_bindings->initiator_address,
ac->local_port,
&initiator_addr);
if (kret) {
krb5_free_address (gssapi_krb5_context, &acceptor_addr);
return kret;
}
kret = krb5_auth_con_setaddrs(gssapi_krb5_context,
ac,
&initiator_addr, /* local address */
&acceptor_addr); /* remote address */
krb5_free_address (gssapi_krb5_context, &initiator_addr);
krb5_free_address (gssapi_krb5_context, &acceptor_addr);
#if 0
free(input_chan_bindings->application_data.value);
input_chan_bindings->application_data.value = NULL;
input_chan_bindings->application_data.length = 0;
#endif
return kret;
}
OM_uint32
_gsskrb5_create_ctx(
OM_uint32 * minor_status,
gss_ctx_id_t * context_handle,
const gss_channel_bindings_t input_chan_bindings,
enum gss_ctx_id_t_state state)
{
krb5_error_code kret;
*context_handle = malloc(sizeof(**context_handle));
if (*context_handle == NULL) {
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
(*context_handle)->auth_context = NULL;
(*context_handle)->source = NULL;
(*context_handle)->target = NULL;
(*context_handle)->state = state;
(*context_handle)->flags = 0;
(*context_handle)->more_flags = 0;
(*context_handle)->service_keyblock = NULL;
(*context_handle)->ticket = NULL;
krb5_data_zero(&(*context_handle)->fwd_data);
(*context_handle)->lifetime = GSS_C_INDEFINITE;
(*context_handle)->order = NULL;
HEIMDAL_MUTEX_init(&(*context_handle)->ctx_id_mutex);
kret = krb5_auth_con_init (gssapi_krb5_context,
&(*context_handle)->auth_context);
if (kret) {
*minor_status = kret;
gssapi_krb5_set_error_string ();
HEIMDAL_MUTEX_destroy(&(*context_handle)->ctx_id_mutex);
return GSS_S_FAILURE;
}
kret = set_addresses((*context_handle)->auth_context,
input_chan_bindings);
if (kret) {
*minor_status = kret;
HEIMDAL_MUTEX_destroy(&(*context_handle)->ctx_id_mutex);
krb5_auth_con_free(gssapi_krb5_context, (*context_handle)->auth_context);
return GSS_S_BAD_BINDINGS;
}
/*
* We need a sequence number
*/
krb5_auth_con_addflags(gssapi_krb5_context,
(*context_handle)->auth_context,
KRB5_AUTH_CONTEXT_DO_SEQUENCE,
NULL);
return GSS_S_COMPLETE;
}
static OM_uint32
gsskrb5_get_creds(
OM_uint32 * minor_status,
krb5_ccache ccache,
gss_ctx_id_t * context_handle,
const gss_name_t target_name,
OM_uint32 time_req,
OM_uint32 * time_rec,
krb5_creds ** cred)
{
OM_uint32 ret;
krb5_error_code kret;
krb5_creds this_cred;
OM_uint32 lifetime_rec;
*cred = NULL;
kret = krb5_cc_get_principal(gssapi_krb5_context,
ccache,
&(*context_handle)->source);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
kret = krb5_copy_principal(gssapi_krb5_context,
target_name,
&(*context_handle)->target);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
memset(&this_cred, 0, sizeof(this_cred));
this_cred.client = (*context_handle)->source;
this_cred.server = (*context_handle)->target;
if (time_req && time_req != GSS_C_INDEFINITE) {
krb5_timestamp ts;
krb5_timeofday (gssapi_krb5_context, &ts);
this_cred.times.endtime = ts + time_req;
} else {
this_cred.times.endtime = 0;
}
this_cred.session.keytype = KEYTYPE_NULL;
kret = krb5_get_credentials(gssapi_krb5_context,
0,
ccache,
&this_cred,
cred);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
(*context_handle)->lifetime = (*cred)->times.endtime;
ret = gssapi_lifetime_left(minor_status,
(*context_handle)->lifetime,
&lifetime_rec);
if (ret) return ret;
if (lifetime_rec == 0) {
*minor_status = 0;
return GSS_S_CONTEXT_EXPIRED;
}
if (time_rec) *time_rec = lifetime_rec;
return GSS_S_COMPLETE;
}
static OM_uint32
gsskrb5_initiator_ready(
OM_uint32 * minor_status,
gss_ctx_id_t * context_handle)
{
OM_uint32 ret;
int32_t seq_number;
int is_cfx = 0;
OM_uint32 flags = (*context_handle)->flags;
krb5_auth_getremoteseqnumber (gssapi_krb5_context,
(*context_handle)->auth_context,
&seq_number);
gsskrb5_is_cfx(*context_handle, &is_cfx);
ret = _gssapi_msg_order_create(minor_status,
&(*context_handle)->order,
_gssapi_msg_order_f(flags),
seq_number, 0, is_cfx);
if (ret) return ret;
(*context_handle)->state = INITIATOR_READY;
(*context_handle)->more_flags |= OPEN;
return GSS_S_COMPLETE;
}
/*
* handle delegated creds in init-sec-context
*/
static void
do_delegation (krb5_auth_context ac,
krb5_ccache ccache,
krb5_creds *cred,
const gss_name_t target_name,
krb5_data *fwd_data,
OM_uint32 *flags)
{
krb5_creds creds;
krb5_kdc_flags fwd_flags;
krb5_error_code kret;
memset (&creds, 0, sizeof(creds));
krb5_data_zero (fwd_data);
kret = krb5_cc_get_principal(gssapi_krb5_context, ccache, &creds.client);
if (kret)
goto out;
kret = krb5_build_principal(gssapi_krb5_context,
&creds.server,
strlen(creds.client->realm),
creds.client->realm,
KRB5_TGS_NAME,
creds.client->realm,
NULL);
if (kret)
goto out;
creds.times.endtime = 0;
fwd_flags.i = 0;
fwd_flags.b.forwarded = 1;
fwd_flags.b.forwardable = 1;
if ( /*target_name->name.name_type != KRB5_NT_SRV_HST ||*/
target_name->name.name_string.len < 2)
goto out;
kret = krb5_get_forwarded_creds(gssapi_krb5_context,
ac,
ccache,
fwd_flags.i,
target_name->name.name_string.val[1],
&creds,
fwd_data);
out:
if (kret)
*flags &= ~GSS_C_DELEG_FLAG;
else
*flags |= GSS_C_DELEG_FLAG;
if (creds.client)
krb5_free_principal(gssapi_krb5_context, creds.client);
if (creds.server)
krb5_free_principal(gssapi_krb5_context, creds.server);
}
/*
* first stage of init-sec-context
*/
static OM_uint32
gsskrb5_initiator_start
(OM_uint32 * minor_status,
krb5_ccache ccache,
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_buffer_t output_token,
OM_uint32 * ret_flags,
OM_uint32 * time_rec
)
{
OM_uint32 ret = GSS_S_FAILURE;
krb5_error_code kret;
krb5_flags ap_options;
krb5_creds *cred = NULL;
krb5_data outbuf;
OM_uint32 flags;
krb5_data authenticator;
Checksum cksum;
krb5_enctype enctype;
krb5_data fwd_data;
int is_cfx;
krb5_data_zero(&outbuf);
krb5_data_zero(&fwd_data);
(*context_handle)->more_flags |= LOCAL;
/* We need to get the credentials for the requested target */
ret = gsskrb5_get_creds(minor_status,
ccache,
context_handle,
target_name,
time_req,
time_rec,
&cred);
if (ret) return ret;
/*
* We need to setup some compat stuff, this assumes that context_handle->target is already set
*/
ret = _gss_DES3_get_mic_compat(minor_status, *context_handle);
if (ret) return ret;
/* We need the key and a random local subkey */
{
kret = krb5_auth_con_setkey(gssapi_krb5_context,
(*context_handle)->auth_context,
&cred->session);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
kret = krb5_auth_con_generatelocalsubkey(gssapi_krb5_context,
(*context_handle)->auth_context,
&cred->session);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
}
/* We need to prepare the flags used for this context */
{
flags = 0;
ap_options = 0;
/*
* The KDC may have issued us a service ticket marked NOT
* ok-as-delegate. We may still wish to force the matter, and to
* allow this we check a per-realm gssapi [appdefaults] config
* option. If ok-as-delegate in the config file is set to TRUE
* (default FALSE) and our caller has so requested, we will still
* attempt to forward the ticket.
*
* Otherwise, strip the GSS_C_DELEG_FLAG (so we don't attempt a
* delegation)
*/
if (!cred->flags.b.ok_as_delegate) {
krb5_boolean delegate;
krb5_appdefault_boolean(gssapi_krb5_context,
"gssapi", target_name->realm,
"ok-as-delegate", FALSE, &delegate);
if (!delegate)
req_flags &= ~GSS_C_DELEG_FLAG;
}
if (req_flags & GSS_C_DELEG_FLAG) {
do_delegation((*context_handle)->auth_context,
ccache, cred, target_name, &fwd_data, &flags);
}
if (req_flags & GSS_C_MUTUAL_FLAG) {
flags |= GSS_C_MUTUAL_FLAG;
ap_options |= AP_OPTS_MUTUAL_REQUIRED;
}
if (req_flags & GSS_C_REPLAY_FLAG) {
flags |= GSS_C_REPLAY_FLAG;
}
if (req_flags & GSS_C_SEQUENCE_FLAG) {
flags |= GSS_C_SEQUENCE_FLAG;
}
if (req_flags & GSS_C_ANON_FLAG) {
;/* XXX */
}
if (req_flags & GSS_C_DCE_STYLE) {
flags |= GSS_C_DCE_STYLE;
/* GSS_C_DCE_STYLE implies GSS_C_MUTUAL_FLAG */
flags |= GSS_C_MUTUAL_FLAG;
ap_options |= AP_OPTS_MUTUAL_REQUIRED;
}
if (req_flags & GSS_C_IDENTIFY_FLAG) {
flags |= GSS_C_IDENTIFY_FLAG;
}
if (req_flags & GSS_C_EXTENDED_ERROR_FLAG) {
flags |= GSS_C_EXTENDED_ERROR_FLAG;
}
/* TODO: why are this always there? --metze */
flags |= GSS_C_CONF_FLAG;
flags |= GSS_C_INTEG_FLAG;
flags |= GSS_C_TRANS_FLAG;
if (ret_flags) *ret_flags = flags;
(*context_handle)->flags = flags;
}
/* We need to generate the 8003 checksum */
{
ret = gssapi_krb5_create_8003_checksum(minor_status,
input_chan_bindings,
flags,
&fwd_data,
&cksum);
krb5_data_free (&fwd_data);
if (ret) return ret;
}
enctype = (*context_handle)->auth_context->keyblock->keytype;
gsskrb5_is_cfx(*context_handle, &is_cfx);
if (is_cfx != 0) {
kret = krb5_auth_con_addflags(gssapi_krb5_context,
(*context_handle)->auth_context,
KRB5_AUTH_CONTEXT_USE_SUBKEY,
NULL);
(*context_handle)->more_flags |= ACCEPTOR_SUBKEY;
}
/* We need to create an Authenticator */
{
kret = krb5_build_authenticator (gssapi_krb5_context,
(*context_handle)->auth_context,
enctype,
cred,
&cksum,
NULL,
&authenticator,
KRB5_KU_AP_REQ_AUTH);
free_Checksum(&cksum);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
}
/* We need to create the AP_REQ */
{
kret = krb5_build_ap_req(gssapi_krb5_context,
enctype,
cred,
ap_options,
authenticator,
&outbuf);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
}
/* We need to encapsulate the AP_REQ if GSS_C_DCE_STYLE isn't in use */
{
if (!(flags & GSS_C_DCE_STYLE)) {
ret = gssapi_krb5_encapsulate(minor_status, &outbuf, output_token,
"\x01\x00", GSS_KRB5_MECHANISM);
krb5_data_free (&outbuf);
if (ret) return ret;
} else {
output_token->length = outbuf.length;
output_token->value = outbuf.data;
}
}
/* We no longer need the creds */
krb5_free_creds(gssapi_krb5_context, cred);
/* We are done if GSS_C_MUTUAL_FLAG is in use */
if (flags & GSS_C_MUTUAL_FLAG) {
(*context_handle)->state = INITIATOR_WAIT_FOR_MUTAL;
return GSS_S_CONTINUE_NEEDED;
}
return gsskrb5_initiator_ready(minor_status, context_handle);
}
static OM_uint32
gsskrb5_initiator_wait_for_mutual(
OM_uint32 * minor_status,
krb5_ccache ccache,
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_buffer_t output_token,
OM_uint32 * ret_flags,
OM_uint32 * time_rec)
{
OM_uint32 ret;
krb5_error_code kret;
krb5_data inbuf;
OM_uint32 flags = (*context_handle)->flags;
int32_t l_seq_number;
int32_t r_seq_number;
/* We need to decapsulate the AP_REP if GSS_C_DCE_STYLE isn't in use */
{
if (!(flags & GSS_C_DCE_STYLE)) {
ret = gssapi_krb5_decapsulate(minor_status, input_token, &inbuf,
"\x02\x00", GSS_KRB5_MECHANISM);
if (ret) return ret;
} else {
inbuf.length = input_token->length;
inbuf.data = input_token->value;
}
}
/* We need to verify the AP_REP */
{
krb5_ap_rep_enc_part *repl;
kret = krb5_rd_rep(gssapi_krb5_context,
(*context_handle)->auth_context,
&inbuf,
&repl);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
krb5_free_ap_rep_enc_part(gssapi_krb5_context, repl);
}
/* We need to check the liftime */
{
OM_uint32 lifetime_rec;
ret = gssapi_lifetime_left(minor_status,
(*context_handle)->lifetime,
&lifetime_rec);
if (ret) return ret;
if (lifetime_rec == 0) {
return GSS_S_CONTEXT_EXPIRED;
}
if (time_rec) *time_rec = lifetime_rec;
}
/* We need to give the caller the flags which are in use */
if (ret_flags) *ret_flags = (*context_handle)->flags;
/* We are done here if GSS_C_DCE_STYLE isn't in use */
if (!(flags & GSS_C_DCE_STYLE)) {
return gsskrb5_initiator_ready(minor_status, context_handle);
}
/*
* We need to set the local seq_number to the remote one just for the krb5_mk_rep(),
* and then we need to use the old local seq_number again for the GSS_Wrap() messages
*/
{
kret = krb5_auth_getremoteseqnumber(gssapi_krb5_context,
(*context_handle)->auth_context,
&r_seq_number);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
kret = krb5_auth_con_getlocalseqnumber(gssapi_krb5_context,
(*context_handle)->auth_context,
&l_seq_number);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
kret = krb5_auth_con_setlocalseqnumber(gssapi_krb5_context,
(*context_handle)->auth_context,
r_seq_number);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
}
/* We need to create an AP_REP */
{
krb5_data outbuf;
kret = krb5_mk_rep(gssapi_krb5_context,
(*context_handle)->auth_context,
&outbuf);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
output_token->length = outbuf.length;
output_token->value = outbuf.data;
}
/* We need to reset the local seq_number */
{
kret = krb5_auth_con_setlocalseqnumber(gssapi_krb5_context,
(*context_handle)->auth_context,
l_seq_number);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
}
return gsskrb5_initiator_ready(minor_status, context_handle);
}
static OM_uint32
gsskrb5_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
)
{
OM_uint32 ret;
krb5_error_code kret;
krb5_ccache ccache = NULL;
if (*context_handle == GSS_C_NO_CONTEXT) {
ret = _gsskrb5_create_ctx(minor_status,
context_handle,
input_chan_bindings,
INITIATOR_START);
if (ret) return ret;
}
if (actual_mech_type) *actual_mech_type = GSS_KRB5_MECHANISM;
if (initiator_cred_handle == GSS_C_NO_CREDENTIAL) {
kret = krb5_cc_default (gssapi_krb5_context, &ccache);
if (kret) {
gssapi_krb5_set_error_string ();
*minor_status = kret;
return GSS_S_FAILURE;
}
} else {
ccache = initiator_cred_handle->ccache;
}
HEIMDAL_MUTEX_lock(&(*context_handle)->ctx_id_mutex);
switch ((*context_handle)->state) {
case INITIATOR_START:
ret = gsskrb5_initiator_start(minor_status,
ccache,
context_handle,
target_name,
mech_type,
req_flags,
time_req,
input_chan_bindings,
input_token,
output_token,
ret_flags,
time_rec);
break;
case INITIATOR_WAIT_FOR_MUTAL:
ret = gsskrb5_initiator_wait_for_mutual(minor_status,
ccache,
context_handle,
target_name,
mech_type,
req_flags,
time_req,
input_chan_bindings,
input_token,
output_token,
ret_flags,
time_rec);
break;
case INITIATOR_READY:
/* should this be GSS_S_BAD_STATUS ? --metze */
/* We need to check the liftime */
{
OM_uint32 lifetime_rec;
ret = gssapi_lifetime_left(minor_status,
(*context_handle)->lifetime,
&lifetime_rec);
if (ret) break;
if (lifetime_rec == 0) {
*minor_status = 0;
ret = GSS_S_CONTEXT_EXPIRED;
break;
}
if (time_rec) *time_rec = lifetime_rec;
}
/* We need to give the caller the flags which are in use */
if (ret_flags) *ret_flags = (*context_handle)->flags;
ret = GSS_S_COMPLETE;
break;
default:
/* TODO: is this correct here? --metze */
ret = GSS_S_BAD_STATUS;
break;
}
if (initiator_cred_handle == GSS_C_NO_CREDENTIAL) {
krb5_cc_close(gssapi_krb5_context, ccache);
}
HEIMDAL_MUTEX_unlock(&(*context_handle)->ctx_id_mutex);
return ret;
}
static OM_uint32
spnego_reply
(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
)
{
OM_uint32 ret;
krb5_data indata;
NegTokenTarg targ;
u_char oidbuf[17];
size_t oidlen;
gss_buffer_desc sub_token;
ssize_t mech_len;
const u_char *p;
size_t len, taglen;
krb5_boolean require_mic;
output_token->length = 0;
output_token->value = NULL;
/*
* SPNEGO doesn't include gss wrapping on SubsequentContextToken
* like the Kerberos 5 mech does. But lets check for it anyway.
*/
mech_len = gssapi_krb5_get_mech (input_token->value,
input_token->length,
&p);
if (mech_len < 0) {
indata.data = input_token->value;
indata.length = input_token->length;
} else if (mech_len == GSS_KRB5_MECHANISM->length
&& memcmp(GSS_KRB5_MECHANISM->elements, p, mech_len) == 0)
return gsskrb5_init_sec_context (minor_status,
initiator_cred_handle,
context_handle,
target_name,
GSS_KRB5_MECHANISM,
req_flags,
time_req,
input_chan_bindings,
input_token,
actual_mech_type,
output_token,
ret_flags,
time_rec);
else if (mech_len == GSS_SPNEGO_MECHANISM->length
&& memcmp(GSS_SPNEGO_MECHANISM->elements, p, mech_len) == 0){
ret = _gssapi_decapsulate (minor_status,
input_token,
&indata,
GSS_SPNEGO_MECHANISM);
if (ret)
return ret;
} else
return GSS_S_BAD_MECH;
ret = der_match_tag_and_length((const char *)indata.data,
indata.length,
ASN1_C_CONTEXT, CONS, 1, &len, &taglen);
if (ret) {
gssapi_krb5_set_status("Failed to decode NegToken choice");
*minor_status = ret;
return GSS_S_FAILURE;
}
if(len > indata.length - taglen) {
gssapi_krb5_set_status("Buffer overrun in NegToken choice");
*minor_status = ASN1_OVERRUN;
return GSS_S_FAILURE;
}
ret = decode_NegTokenTarg((const char *)indata.data + taglen,
len, &targ, NULL);
if (ret) {
gssapi_krb5_set_status("Failed to decode NegTokenTarg");
*minor_status = ret;
return GSS_S_FAILURE;
}
if (targ.negResult == NULL
|| *(targ.negResult) == reject
|| targ.supportedMech == NULL) {
free_NegTokenTarg(&targ);
return GSS_S_BAD_MECH;
}
ret = der_put_oid(oidbuf + sizeof(oidbuf) - 1,
sizeof(oidbuf),
targ.supportedMech,
&oidlen);
if (ret || oidlen != GSS_KRB5_MECHANISM->length
|| memcmp(oidbuf + sizeof(oidbuf) - oidlen,
GSS_KRB5_MECHANISM->elements,
oidlen) != 0) {
free_NegTokenTarg(&targ);
return GSS_S_BAD_MECH;
}
if (targ.responseToken != NULL) {
sub_token.length = targ.responseToken->length;
sub_token.value = targ.responseToken->data;
} else {
sub_token.length = 0;
sub_token.value = NULL;
}
ret = gsskrb5_init_sec_context(minor_status,
initiator_cred_handle,
context_handle,
target_name,
GSS_KRB5_MECHANISM,
req_flags,
time_req,
input_chan_bindings,
&sub_token,
actual_mech_type,
output_token,
ret_flags,
time_rec);
if (ret) {
free_NegTokenTarg(&targ);
return ret;
}
/*
* Verify the mechListMIC if CFX was used; or if local policy
* dictated so.
*/
ret = _gss_spnego_require_mechlist_mic(minor_status, *context_handle,
&require_mic);
if (ret) {
free_NegTokenTarg(&targ);
return ret;
}
if (require_mic) {
MechTypeList mechlist;
MechType m0;
size_t buf_len;
gss_buffer_desc mic_buf, mech_buf;
if (targ.mechListMIC == NULL) {
free_NegTokenTarg(&targ);
*minor_status = 0;
return GSS_S_BAD_MIC;
}
mechlist.len = 1;
mechlist.val = &m0;
ret = der_get_oid(GSS_KRB5_MECHANISM->elements,
GSS_KRB5_MECHANISM->length,
&m0,
NULL);
if (ret) {
free_NegTokenTarg(&targ);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
ASN1_MALLOC_ENCODE(MechTypeList, mech_buf.value, mech_buf.length,
&mechlist, &buf_len, ret);
if (ret) {
free_NegTokenTarg(&targ);
free_oid(&m0);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
if (mech_buf.length != buf_len)
abort();
mic_buf.length = targ.mechListMIC->length;
mic_buf.value = targ.mechListMIC->data;
ret = gss_verify_mic(minor_status, *context_handle,
&mech_buf, &mic_buf, NULL);
free(mech_buf.value);
free_oid(&m0);
}
free_NegTokenTarg(&targ);
return ret;
}
static OM_uint32
spnego_initial
(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
)
{
NegTokenInit ni;
int ret;
OM_uint32 sub, minor;
gss_buffer_desc mech_token;
u_char *buf;
size_t buf_size, buf_len;
krb5_data data;
memset (&ni, 0, sizeof(ni));
ALLOC(ni.mechTypes, 1);
if (ni.mechTypes == NULL) {
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
ALLOC_SEQ(ni.mechTypes, 1);
if (ni.mechTypes->val == NULL) {
free_NegTokenInit(&ni);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
ret = der_get_oid(GSS_KRB5_MECHANISM->elements,
GSS_KRB5_MECHANISM->length,
&ni.mechTypes->val[0],
NULL);
if (ret) {
free_NegTokenInit(&ni);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
#if 0
ALLOC(ni.reqFlags, 1);
if (ni.reqFlags == NULL) {
free_NegTokenInit(&ni);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
ni.reqFlags->delegFlag = req_flags & GSS_C_DELEG_FLAG;
ni.reqFlags->mutualFlag = req_flags & GSS_C_MUTUAL_FLAG;
ni.reqFlags->replayFlag = req_flags & GSS_C_REPLAY_FLAG;
ni.reqFlags->sequenceFlag = req_flags & GSS_C_SEQUENCE_FLAG;
ni.reqFlags->anonFlag = req_flags & GSS_C_ANON_FLAG;
ni.reqFlags->confFlag = req_flags & GSS_C_CONF_FLAG;
ni.reqFlags->integFlag = req_flags & GSS_C_INTEG_FLAG;
#else
ni.reqFlags = NULL;
#endif
sub = gsskrb5_init_sec_context(&minor,
initiator_cred_handle,
context_handle,
target_name,
GSS_KRB5_MECHANISM,
req_flags,
time_req,
input_chan_bindings,
GSS_C_NO_BUFFER,
actual_mech_type,
&mech_token,
ret_flags,
time_rec);
if (GSS_ERROR(sub)) {
free_NegTokenInit(&ni);
return sub;
}
if (mech_token.length != 0) {
ALLOC(ni.mechToken, 1);
if (ni.mechToken == NULL) {
free_NegTokenInit(&ni);
gss_release_buffer(&minor, &mech_token);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
ni.mechToken->length = mech_token.length;
ni.mechToken->data = malloc(mech_token.length);
if (ni.mechToken->data == NULL && mech_token.length != 0) {
free_NegTokenInit(&ni);
gss_release_buffer(&minor, &mech_token);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
memcpy(ni.mechToken->data, mech_token.value, mech_token.length);
gss_release_buffer(&minor, &mech_token);
} else
ni.mechToken = NULL;
/* XXX ignore mech list mic for now */
ni.mechListMIC = NULL;
{
NegotiationToken nt;
nt.element = choice_NegotiationToken_negTokenInit;
nt.u.negTokenInit = ni;
ASN1_MALLOC_ENCODE(NegotiationToken, buf, buf_size,
&nt, &buf_len, ret);
if (ret == 0 && buf_size != buf_len)
abort();
}
data.data = buf;
data.length = buf_size;
free_NegTokenInit(&ni);
if (ret)
return ret;
sub = _gssapi_encapsulate(minor_status,
&data,
output_token,
GSS_SPNEGO_MECHANISM);
free (buf);
if (sub)
return sub;
return GSS_S_CONTINUE_NEEDED;
}
static OM_uint32
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
)
{
if (input_token == GSS_C_NO_BUFFER || input_token->length == 0)
return spnego_initial (minor_status,
initiator_cred_handle,
context_handle,
target_name,
mech_type,
req_flags,
time_req,
input_chan_bindings,
input_token,
actual_mech_type,
output_token,
ret_flags,
time_rec);
else
return spnego_reply (minor_status,
initiator_cred_handle,
context_handle,
target_name,
mech_type,
req_flags,
time_req,
input_chan_bindings,
input_token,
actual_mech_type,
output_token,
ret_flags,
time_rec);
}
/*
* gss_init_sec_context
*/
OM_uint32 gss_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
)
{
GSSAPI_KRB5_INIT ();
output_token->length = 0;
output_token->value = NULL;
if (ret_flags)
*ret_flags = 0;
if (time_rec)
*time_rec = 0;
if (target_name == GSS_C_NO_NAME) {
if (actual_mech_type)
*actual_mech_type = GSS_C_NO_OID;
*minor_status = 0;
return GSS_S_BAD_NAME;
}
if (mech_type == GSS_C_NO_OID ||
gss_oid_equal(mech_type, GSS_KRB5_MECHANISM))
return gsskrb5_init_sec_context(minor_status,
initiator_cred_handle,
context_handle,
target_name,
mech_type,
req_flags,
time_req,
input_chan_bindings,
input_token,
actual_mech_type,
output_token,
ret_flags,
time_rec);
else if (gss_oid_equal(mech_type, GSS_SPNEGO_MECHANISM))
return spnego_init_sec_context (minor_status,
initiator_cred_handle,
context_handle,
target_name,
mech_type,
req_flags,
time_req,
input_chan_bindings,
input_token,
actual_mech_type,
output_token,
ret_flags,
time_rec);
else
return GSS_S_BAD_MECH;
}