C++ (Cpp) der_put_length_and_tag示例

示例#1

文件： asn1_Event.c 项目： mikekmv/aeriebsd-src

int
encode_Event(unsigned char *p, size_t len, const Event *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
if((data)->principal)
{
int oldret = ret;
ret = 0;
e = encode_Principal(p, len, (data)->principal, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_KerberosTime(p, len, &(data)->time, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#2

文件： asn1_ChopstixPayment.c 项目： WrathOfChris/chopstix

int
encode_ChopstixPayment(unsigned char *p, size_t len, const ChopstixPayment *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
if((data)->ccinfo)
{
int oldret = ret;
ret = 0;
e = encode_ChopstixCreditInfo(p, len, (data)->ccinfo, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_CHOPSTIX_PAYMENTTYPE(p, len, &(data)->type, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#3

文件： asn1_PA_DATA.c 项目： mikekmv/aeriebsd-src

int
encode_PA_DATA(unsigned char *p, size_t len, const PA_DATA *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
int oldret = ret;
ret = 0;
e = encode_octet_string(p, len, &(data)->padata_value, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_PADATA_TYPE(p, len, &(data)->padata_type, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#4

文件： asn1_ChopstixItemStyle.c 项目： WrathOfChris/chopstix

int
encode_ChopstixItemStyle(unsigned char *p, size_t len, const ChopstixItemStyle *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
int oldret = ret;
ret = 0;
e = encode_general_string(p, len, &(data)->name, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->num, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#5

文件： asn1_TransitedEncoding.c 项目： mikekmv/aeriebsd-src

int
encode_TransitedEncoding(unsigned char *p, size_t len, const TransitedEncoding *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
int oldret = ret;
ret = 0;
e = encode_octet_string(p, len, &(data)->contents, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->tr_type, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#6

文件： spnego_asn1.c 项目： execunix/vinos

static int
encode_NegTokenResp(unsigned char *p, size_t len, const NegTokenResp * data, size_t * size)
{
	size_t ret = 0;
	size_t l;
	int e;

	if ((data)->mechListMIC) {
		size_t oldret = ret;
		ret = 0;
		e = encode_octet_string(p, len, (data)->mechListMIC, &l);
		BACK;
		e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
		BACK;
		ret += oldret;
	}
	if ((data)->responseToken) {
		size_t oldret = ret;
		ret = 0;
		e = encode_octet_string(p, len, (data)->responseToken, &l);
		BACK;
		e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
		BACK;
		ret += oldret;
	}
	if ((data)->supportedMech) {
		size_t oldret = ret;
		ret = 0;
		e = encode_MechType(p, len, (data)->supportedMech, &l);
		BACK;
		e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
		BACK;
		ret += oldret;
	}
	if ((data)->negState) {
		size_t oldret = ret;
		ret = 0;
		e = encode_enumerated(p, len, (data)->negState, &l);
		BACK;
		e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
		BACK;
		ret += oldret;
	}
	e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
	BACK;
	*size = ret;
	return 0;
}

示例#7

文件： asn1_ContextFlags.c 项目： KMNR/mod_auth_kerb

int
encode_ContextFlags(unsigned char *p, size_t len, const ContextFlags *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
unsigned char c = 0;
*p-- = c; len--; ret++;
c = 0;
*p-- = c; len--; ret++;
c = 0;
*p-- = c; len--; ret++;
c = 0;
if(data->integFlag) c |= 1<<1;
if(data->confFlag) c |= 1<<2;
if(data->anonFlag) c |= 1<<3;
if(data->sequenceFlag) c |= 1<<4;
if(data->replayFlag) c |= 1<<5;
if(data->mutualFlag) c |= 1<<6;
if(data->delegFlag) c |= 1<<7;
*p-- = c;
*p-- = 0;
len -= 2;
ret += 2;
}

e = der_put_length_and_tag (p, len, ret, UNIV, PRIM,UT_BitString, &l);
BACK;
*size = ret;
return 0;
}

示例#8

文件： asn1_APOptions.c 项目： mikekmv/aeriebsd-src

int
encode_APOptions(unsigned char *p, size_t len, const APOptions *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
unsigned char c = 0;
*p-- = c; len--; ret++;
c = 0;
*p-- = c; len--; ret++;
c = 0;
*p-- = c; len--; ret++;
c = 0;
if(data->mutual_required) c |= 1<<5;
if(data->use_session_key) c |= 1<<6;
if(data->reserved) c |= 1<<7;
*p-- = c;
*p-- = 0;
len -= 2;
ret += 2;
}

e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM,UT_BitString, &l);
BACK;
*size = ret;
return 0;
}

示例#9

文件： spnego_asn1.c 项目： execunix/vinos

static int
encode_NegTokenInit(unsigned char *p, size_t len, const NegTokenInit * data, size_t * size)
{
	size_t ret = 0;
	size_t l;
	int e;

	if ((data)->mechListMIC) {
		size_t oldret = ret;
		ret = 0;
		e = encode_octet_string(p, len, (data)->mechListMIC, &l);
		BACK;
		e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
		BACK;
		ret += oldret;
	}
	if ((data)->mechToken) {
		size_t oldret = ret;
		ret = 0;
		e = encode_octet_string(p, len, (data)->mechToken, &l);
		BACK;
		e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
		BACK;
		ret += oldret;
	}
	if ((data)->reqFlags) {
		size_t oldret = ret;
		ret = 0;
		e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
		BACK;
		e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
		BACK;
		ret += oldret;
	} {
		size_t oldret = ret;
		ret = 0;
		e = encode_MechTypeList(p, len, &(data)->mechTypes, &l);
		BACK;
		e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
		BACK;
		ret += oldret;
	}
	e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
	BACK;
	*size = ret;
	return 0;
}

示例#10

文件： asn1_KRB_CRED.c 项目： mikekmv/aeriebsd-src

int
encode_KRB_CRED(unsigned char *p, size_t len, const KRB_CRED *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
int oldret = ret;
ret = 0;
e = encode_EncryptedData(p, len, &(data)->enc_part, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
for(i = (&(data)->tickets)->len - 1; i >= 0; --i) {
int oldret = ret;
ret = 0;
e = encode_Ticket(p, len, &(&(data)->tickets)->val[i], &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_MESSAGE_TYPE(p, len, &(data)->msg_type, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->pvno, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 22, &l);
BACK;
*size = ret;
return 0;
}

示例#11

文件： asn1_EncryptedData.c 项目： mikekmv/aeriebsd-src

int
encode_EncryptedData(unsigned char *p, size_t len, const EncryptedData *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
int oldret = ret;
ret = 0;
e = encode_octet_string(p, len, &(data)->cipher, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
if((data)->kvno)
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, (data)->kvno, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_ENCTYPE(p, len, &(data)->etype, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#12

文件： asn1_ChopstixSubItem.c 项目： WrathOfChris/chopstix

int
encode_ChopstixSubItem(unsigned char *p, size_t len, const ChopstixSubItem *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
if((data)->special)
{
int oldret = ret;
ret = 0;
e = encode_ChopstixSpecial(p, len, (data)->special, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->pricedelta, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->style, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_ChopstixItemCode(p, len, &(data)->code, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->qty, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#13

文件： asn1_PA_PAC_REQUEST.c 项目： mikekmv/aeriebsd-src

int
encode_PA_PAC_REQUEST(unsigned char *p, size_t len, const PA_PAC_REQUEST *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
int oldret = ret;
ret = 0;
e = encode_boolean(p, len, &(data)->include_pac, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#14

文件： asn1_PrincipalName.c 项目： mikekmv/aeriebsd-src

int
encode_PrincipalName(unsigned char *p, size_t len, const PrincipalName *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
int oldret = ret;
ret = 0;
for(i = (&(data)->name_string)->len - 1; i >= 0; --i) {
int oldret = ret;
ret = 0;
e = encode_general_string(p, len, &(&(data)->name_string)->val[i], &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_NAME_TYPE(p, len, &(data)->name_type, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#15

文件： asn1_AS_REQ.c 项目： mikekmv/aeriebsd-src

int
encode_AS_REQ(unsigned char *p, size_t len, const AS_REQ *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
e = encode_KDC_REQ(p, len, data, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 10, &l);
BACK;
*size = ret;
return 0;
}

示例#16

文件： spnego_asn1.c 项目： execunix/vinos

static int
encode_MechTypeList(unsigned char *p, size_t len, const MechTypeList * data, size_t * size)
{
	size_t ret = 0;
	size_t l;
	int i, e;

	for (i = (data)->len - 1; i >= 0; --i) {
		size_t oldret = ret;
		ret = 0;
		e = encode_MechType(p, len, &(data)->val[i], &l);
		BACK;
		ret += oldret;
	}
	e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
	BACK;
	*size = ret;
	return 0;
}

示例#17

文件： asn1_ETYPE_INFO.c 项目： sofuture/bitrig

int
encode_ETYPE_INFO(unsigned char *p, size_t len, const ETYPE_INFO *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
for(i = (data)->len - 1; i >= 0; --i) {
int oldret = ret;
ret = 0;
e = encode_ETYPE_INFO_ENTRY(p, len, &(data)->val[i], &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#18

文件： init_sec_context.c 项目： dariaphoebe/heimdal

static OM_uint32
spnego_initial
           (OM_uint32 * minor_status,
	    gssspnego_cred cred,
            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;
    gss_buffer_desc data;
    size_t ni_len;
    gss_ctx_id_t context;
    gssspnego_ctx ctx;
    spnego_name name = (spnego_name)target_name;

    *minor_status = 0;

    memset (&ni, 0, sizeof(ni));

    *context_handle = GSS_C_NO_CONTEXT;

    if (target_name == GSS_C_NO_NAME)
	return GSS_S_BAD_NAME;

    sub = _gss_spnego_alloc_sec_context(&minor, &context);
    if (GSS_ERROR(sub)) {
	*minor_status = minor;
	return sub;
    }
    ctx = (gssspnego_ctx)context;

    HEIMDAL_MUTEX_lock(&ctx->ctx_id_mutex);

    ctx->local = 1;

    sub = gss_import_name(&minor, &name->value, &name->type, &ctx->target_name);
    if (GSS_ERROR(sub)) {
	*minor_status = minor;
	_gss_spnego_internal_delete_sec_context(&minor, &context, GSS_C_NO_BUFFER);
	return sub;
    }

    sub = _gss_spnego_indicate_mechtypelist(&minor,
					    ctx->target_name,
					    initiator_approved,
					    0,
					    cred,
					    &ni.mechTypes,
					    &ctx->preferred_mech_type);
    if (GSS_ERROR(sub)) {
	*minor_status = minor;
	_gss_spnego_internal_delete_sec_context(&minor, &context, GSS_C_NO_BUFFER);
	return sub;
    }

    ni.reqFlags = NULL;

    /*
     * If we have a credential handle, use it to select the mechanism
     * that we will use
     */

    /* generate optimistic token */
    sub = gss_init_sec_context(&minor,
			       (cred != NULL) ? cred->negotiated_cred_id :
			          GSS_C_NO_CREDENTIAL,
			       &ctx->negotiated_ctx_id,
			       ctx->target_name,
			       ctx->preferred_mech_type,
			       req_flags,
			       time_req,
			       input_chan_bindings,
			       input_token,
			       &ctx->negotiated_mech_type,
			       &mech_token,
			       &ctx->mech_flags,
			       &ctx->mech_time_rec);
    if (GSS_ERROR(sub)) {
	free_NegTokenInit(&ni);
	*minor_status = minor;
	gss_mg_collect_error(ctx->preferred_mech_type, sub, minor);
	_gss_spnego_internal_delete_sec_context(&minor, &context, GSS_C_NO_BUFFER);
	return sub;
    }
    if (sub == GSS_S_COMPLETE)
	ctx->maybe_open = 1;

    if (mech_token.length != 0) {
	ALLOC(ni.mechToken, 1);
	if (ni.mechToken == NULL) {
	    free_NegTokenInit(&ni);
	    gss_release_buffer(&minor, &mech_token);
	    _gss_spnego_internal_delete_sec_context(&minor, &context, GSS_C_NO_BUFFER);
	    *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;
	    _gss_spnego_internal_delete_sec_context(&minor, &context, GSS_C_NO_BUFFER);
	    return GSS_S_FAILURE;
	}
	memcpy(ni.mechToken->data, mech_token.value, mech_token.length);
	gss_release_buffer(&minor, &mech_token);
    } else
	ni.mechToken = NULL;

    ni.mechListMIC = NULL;

    ni_len = length_NegTokenInit(&ni);
    buf_size = 1 + der_length_len(ni_len) + ni_len;

    buf = malloc(buf_size);
    if (buf == NULL) {
	free_NegTokenInit(&ni);
	*minor_status = ENOMEM;
	_gss_spnego_internal_delete_sec_context(&minor, &context, GSS_C_NO_BUFFER);
	return GSS_S_FAILURE;
    }

    ret = encode_NegTokenInit(buf + buf_size - 1,
			      ni_len,
			      &ni, &buf_len);
    if (ret == 0 && ni_len != buf_len)
	abort();

    if (ret == 0) {
	size_t tmp;

	ret = der_put_length_and_tag(buf + buf_size - buf_len - 1,
				     buf_size - buf_len,
				     buf_len,
				     ASN1_C_CONTEXT,
				     CONS,
				     0,
				     &tmp);
	if (ret == 0 && tmp + buf_len != buf_size)
	    abort();
    }
    if (ret) {
	*minor_status = ret;
	free(buf);
	free_NegTokenInit(&ni);
	_gss_spnego_internal_delete_sec_context(&minor, &context, GSS_C_NO_BUFFER);
	return GSS_S_FAILURE;
    }

    data.value  = buf;
    data.length = buf_size;

    ctx->initiator_mech_types.len = ni.mechTypes.len;
    ctx->initiator_mech_types.val = ni.mechTypes.val;
    ni.mechTypes.len = 0;
    ni.mechTypes.val = NULL;

    free_NegTokenInit(&ni);

    sub = gss_encapsulate_token(&data,
				GSS_SPNEGO_MECHANISM,
				output_token);
    free (buf);

    if (sub) {
	_gss_spnego_internal_delete_sec_context(&minor, &context, GSS_C_NO_BUFFER);
	return sub;
    }

    if (actual_mech_type)
	*actual_mech_type = ctx->negotiated_mech_type;
    if (ret_flags)
	*ret_flags = ctx->mech_flags;
    if (time_rec)
	*time_rec = ctx->mech_time_rec;

    HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex);

    *context_handle = context;

    return GSS_S_CONTINUE_NEEDED;
}

示例#19

文件： accept_sec_context.c 项目： KMNR/mod_auth_kerb

static OM_uint32
code_NegTokenArg(OM_uint32 *minor_status,
		 const NegTokenTarg *targ,
		 unsigned char **outbuf,
		 size_t *outbuf_size)
{
    OM_uint32 ret;
    u_char *buf;
    size_t buf_size, buf_len;

    buf_size = 1024;
    buf = malloc(buf_size);
    if (buf == NULL) {
	*minor_status = ENOMEM;
	return GSS_S_FAILURE;
    }

    do {
	ret = encode_NegTokenTarg(buf + buf_size -1,
				  buf_size,
				  targ, &buf_len);
	if (ret == 0) {
	    size_t tmp;

	    ret = der_put_length_and_tag(buf + buf_size - buf_len - 1,
					 buf_size - buf_len,
					 buf_len,
					 KERB_CTXT,
					 CONS,
					 1,
					 &tmp);
	    if (ret == 0)
		buf_len += tmp;
	}
	if (ret) {
	    if (ret == ASN1_OVERFLOW) {
		u_char *tmp;

		buf_size *= 2;
		tmp = realloc (buf, buf_size);
		if (tmp == NULL) {
		    *minor_status = ENOMEM;
		    free(buf);
		    return GSS_S_FAILURE;
		}
		buf = tmp;
	    } else {
		*minor_status = ret;
		free(buf);
		return GSS_S_FAILURE;
	    }
	}
    } while (ret == ASN1_OVERFLOW);

    *outbuf = malloc(buf_len);
    if (*outbuf == NULL) {
       *minor_status = ENOMEM;
       free(buf);
       return GSS_S_FAILURE;
    }

    memcpy(*outbuf, buf + buf_size - buf_len, buf_len);
    *outbuf_size = buf_len;

    free(buf);
    
    return GSS_S_COMPLETE;
}

示例#20

文件： asn1_EncKrbCredPart.c 项目： sofuture/bitrig

int
encode_EncKrbCredPart(unsigned char *p, size_t len, const EncKrbCredPart *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
if((data)->r_address)
{
int oldret = ret;
ret = 0;
e = encode_HostAddress(p, len, (data)->r_address, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
BACK;
ret += oldret;
}
if((data)->s_address)
{
int oldret = ret;
ret = 0;
e = encode_HostAddress(p, len, (data)->s_address, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
BACK;
ret += oldret;
}
if((data)->usec)
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, (data)->usec, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
BACK;
ret += oldret;
}
if((data)->timestamp)
{
int oldret = ret;
ret = 0;
e = encode_KerberosTime(p, len, (data)->timestamp, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
if((data)->nonce)
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, (data)->nonce, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
for(i = (&(data)->ticket_info)->len - 1; i >= 0; --i) {
int oldret = ret;
ret = 0;
e = encode_KrbCredInfo(p, len, &(&(data)->ticket_info)->val[i], &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_APPL, CONS, 29, &l);
BACK;
*size = ret;
return 0;
}

示例#21

文件： asn1_ChopstixMenuitem.c 项目： WrathOfChris/chopstix

int
encode_ChopstixMenuitem(unsigned char *p, size_t len, const ChopstixMenuitem *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
{
int oldret = ret;
ret = 0;
e = encode_ChopstixFlags(p, len, &(data)->flags, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
BACK;
ret += oldret;
}
if((data)->subitems)
{
int oldret = ret;
ret = 0;
e = encode_ChopstixItemExtras(p, len, (data)->subitems, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_ChopstixItemExtras(p, len, &(data)->extras, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_ChopstixItemStyles(p, len, &(data)->styles, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->price, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_general_string(p, len, &(data)->name, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_ChopstixItemCode(p, len, &(data)->code, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->gen, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}

示例#22

文件： init_sec_context.c 项目： adaltas/spnego_world

OM_uint32 KRB5_LIB_FUNCTION gss_init_sec_context_spnego(
	    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 token_init;
   OM_uint32 major_status, minor_status2;
   gss_buffer_desc krb5_output_token = GSS_C_EMPTY_BUFFER;
   unsigned char *buf = NULL;
   size_t buf_size;
   size_t len;
   int ret;

   memset(&token_init, 0, sizeof(token_init));

   ALLOC(token_init.mechTypes);
   if (token_init.mechTypes == NULL) {
      *minor_status = ENOMEM;
      return GSS_S_FAILURE;
   }

   ret = add_mech(token_init.mechTypes, GSS_KRB5_MECH);
   if (ret) {
      *minor_status = ret;
      ret = GSS_S_FAILURE;
      goto end;
   }

#if 0
   ALLOC(token_init.reqFlags);
   if (token_init.reqFlags == NULL) {
      *minor_status = ENOMEM;
      ret = GSS_S_FAILURE;
      goto end;
   }
   set_context_flags(req_flags, token_init.reqFlags);
#endif

  major_status = gss_init_sec_context(minor_status,
	 			       initiator_cred_handle,
				       context_handle,
				       target_name,
				       GSS_KRB5_MECH,
				       req_flags,
				       time_req,
				       input_chan_bindings,
				       input_token,
				       actual_mech_type,
				       &krb5_output_token,
				       ret_flags,
				       time_rec);
  if (GSS_ERROR(major_status)) {
    ret = major_status;
    goto end;
  }
  if (krb5_output_token.length > 0) {
    printf("\nOK COUCOU INITSECCONTEXT L:117\n\n");
    ALLOC(token_init.mechToken);
    if (token_init.mechToken == NULL) {
      *minor_status = ENOMEM;
      ret = GSS_S_FAILURE;
      goto end;
    }
    token_init.mechToken->data = krb5_output_token.value;
    token_init.mechToken->length = krb5_output_token.length;
    krb5_output_token.length = 0; /* don't free it later */
  }
  printf("\nOK COUCOU INITSECCONTEXT L:128\n\n");

   /* The MS implementation of SPNEGO seems to not like the mechListMIC field,
    * so we omit it (it's optional anyway) */

  buf_size = 1024;
  buf = malloc(buf_size);

  do {
    ret = encode_NegTokenInit(buf + buf_size -1,
				  buf_size,
				  &token_init, &len);
    if (ret == 0) {
      size_t tmp;
      ret = der_put_length_and_tag(buf + buf_size - len - 1,
					 buf_size - len,
					 len,
					 KERB_CTXT,
					 CONS,
					 0,
					 &tmp);
      if (ret == 0) len += tmp;
      printf("\nOK COUCOU INITSECCONTEXT L:150\n\n");
    }
    if (ret) {
      if (ret == ASN1_OVERFLOW) {
        u_char *tmp;
        buf_size *= 2;
        tmp = realloc (buf, buf_size);
        if (tmp == NULL) {
          *minor_status = ENOMEM;
          ret = GSS_S_FAILURE;
          goto end;
        }
        buf = tmp;
        printf("\nOK COUCOU INITSECCONTEXT L:163\n\n");
      }
      else {
        *minor_status = ret;
        printf("\nOK COUCOU INITSECCONTEXT L:167\n\n");
        ret = GSS_S_FAILURE;
        goto end;
      }
    }
  } while (ret == ASN1_OVERFLOW);

  ret = gssapi_spnego_encapsulate(minor_status, buf + buf_size - len, len, output_token, GSS_SPNEGO_MECH);
  ret = major_status;

end:
  free_NegTokenInit(&token_init);
  if (krb5_output_token.length > 0)
    gss_release_buffer(&minor_status2, &krb5_output_token);
    if (buf)
      free(buf);
   return ret;
}

示例#23

文件： asn1_KrbCredInfo.c 项目： mikekmv/aeriebsd-src

int
encode_KrbCredInfo(unsigned char *p, size_t len, const KrbCredInfo *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;

i = 0;
if((data)->caddr)
{
int oldret = ret;
ret = 0;
e = encode_HostAddresses(p, len, (data)->caddr, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 10, &l);
BACK;
ret += oldret;
}
if((data)->sname)
{
int oldret = ret;
ret = 0;
e = encode_PrincipalName(p, len, (data)->sname, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 9, &l);
BACK;
ret += oldret;
}
if((data)->srealm)
{
int oldret = ret;
ret = 0;
e = encode_Realm(p, len, (data)->srealm, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 8, &l);
BACK;
ret += oldret;
}
if((data)->renew_till)
{
int oldret = ret;
ret = 0;
e = encode_KerberosTime(p, len, (data)->renew_till, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 7, &l);
BACK;
ret += oldret;
}
if((data)->endtime)
{
int oldret = ret;
ret = 0;
e = encode_KerberosTime(p, len, (data)->endtime, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 6, &l);
BACK;
ret += oldret;
}
if((data)->starttime)
{
int oldret = ret;
ret = 0;
e = encode_KerberosTime(p, len, (data)->starttime, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 5, &l);
BACK;
ret += oldret;
}
if((data)->authtime)
{
int oldret = ret;
ret = 0;
e = encode_KerberosTime(p, len, (data)->authtime, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
BACK;
ret += oldret;
}
if((data)->flags)
{
int oldret = ret;
ret = 0;
e = encode_TicketFlags(p, len, (data)->flags, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
BACK;
ret += oldret;
}
if((data)->pname)
{
int oldret = ret;
ret = 0;
e = encode_PrincipalName(p, len, (data)->pname, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
if((data)->prealm)
{
int oldret = ret;
ret = 0;
e = encode_Realm(p, len, (data)->prealm, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_EncryptionKey(p, len, &(data)->key, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}