| /* This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| |
| /* |
| * Support for ENcoding ASN.1 data based on BER/DER (Basic/Distinguished |
| * Encoding Rules). |
| */ |
| |
| #include "secasn1.h" |
| |
| typedef enum { |
| beforeHeader, |
| duringContents, |
| duringGroup, |
| duringSequence, |
| afterContents, |
| afterImplicit, |
| afterInline, |
| afterPointer, |
| afterChoice, |
| notInUse |
| } sec_asn1e_parse_place; |
| |
| typedef enum { |
| allDone, |
| encodeError, |
| keepGoing, |
| needBytes |
| } sec_asn1e_parse_status; |
| |
| typedef enum { |
| hdr_normal = 0, /* encode header normally */ |
| hdr_any = 1, /* header already encoded in content */ |
| hdr_decoder = 2, /* template only used by decoder. skip it. */ |
| hdr_optional = 3, /* optional component, to be omitted */ |
| hdr_placeholder = 4 /* place holder for from_buf content */ |
| } sec_asn1e_hdr_encoding; |
| |
| typedef struct sec_asn1e_state_struct { |
| SEC_ASN1EncoderContext *top; |
| const SEC_ASN1Template *theTemplate; |
| void *src; |
| |
| struct sec_asn1e_state_struct *parent; /* aka prev */ |
| struct sec_asn1e_state_struct *child; /* aka next */ |
| |
| sec_asn1e_parse_place place; /* where we are in encoding process */ |
| |
| /* |
| * XXX explain the next fields as clearly as possible... |
| */ |
| unsigned char tag_modifiers; |
| unsigned char tag_number; |
| unsigned long underlying_kind; |
| |
| int depth; |
| |
| PRBool isExplicit, /* we are handling an isExplicit header */ |
| indefinite, /* need end-of-contents */ |
| is_string, /* encoding a simple string or an ANY */ |
| may_stream, /* when streaming, do indefinite encoding */ |
| optional, /* omit field if it has no contents */ |
| disallowStreaming; /* disallow streaming in all sub-templates */ |
| } sec_asn1e_state; |
| |
| /* |
| * An "outsider" will have an opaque pointer to this, created by calling |
| * SEC_ASN1EncoderStart(). It will be passed back in to all subsequent |
| * calls to SEC_ASN1EncoderUpdate() and related routines, and when done |
| * it is passed to SEC_ASN1EncoderFinish(). |
| */ |
| struct sec_EncoderContext_struct { |
| PLArenaPool *our_pool; /* for our internal allocs */ |
| |
| sec_asn1e_state *current; |
| sec_asn1e_parse_status status; |
| |
| PRBool streaming; |
| PRBool from_buf; |
| |
| SEC_ASN1NotifyProc notify_proc; /* call before/after handling field */ |
| void *notify_arg; /* argument to notify_proc */ |
| PRBool during_notify; /* true during call to notify_proc */ |
| |
| SEC_ASN1WriteProc output_proc; /* pass encoded bytes to this */ |
| void *output_arg; /* argument to that function */ |
| }; |
| |
| static sec_asn1e_state * |
| sec_asn1e_push_state(SEC_ASN1EncoderContext *cx, |
| const SEC_ASN1Template *theTemplate, |
| const void *src, PRBool new_depth) |
| { |
| sec_asn1e_state *state, *new_state; |
| |
| state = cx->current; |
| |
| new_state = (sec_asn1e_state *)PORT_ArenaZAlloc(cx->our_pool, |
| sizeof(*new_state)); |
| if (new_state == NULL) { |
| cx->status = encodeError; |
| return NULL; |
| } |
| |
| new_state->top = cx; |
| new_state->parent = state; |
| new_state->theTemplate = theTemplate; |
| new_state->place = notInUse; |
| if (src != NULL) |
| new_state->src = (char *)src + theTemplate->offset; |
| |
| if (state != NULL) { |
| new_state->depth = state->depth; |
| if (new_depth) |
| new_state->depth++; |
| state->child = new_state; |
| } |
| |
| cx->current = new_state; |
| return new_state; |
| } |
| |
| static void |
| sec_asn1e_scrub_state(sec_asn1e_state *state) |
| { |
| /* |
| * Some default "scrubbing". |
| * XXX right set of initializations? |
| */ |
| state->place = beforeHeader; |
| state->indefinite = PR_FALSE; |
| } |
| |
| static void |
| sec_asn1e_notify_before(SEC_ASN1EncoderContext *cx, void *src, int depth) |
| { |
| if (cx->notify_proc == NULL) |
| return; |
| |
| cx->during_notify = PR_TRUE; |
| (*cx->notify_proc)(cx->notify_arg, PR_TRUE, src, depth); |
| cx->during_notify = PR_FALSE; |
| } |
| |
| static void |
| sec_asn1e_notify_after(SEC_ASN1EncoderContext *cx, void *src, int depth) |
| { |
| if (cx->notify_proc == NULL) |
| return; |
| |
| cx->during_notify = PR_TRUE; |
| (*cx->notify_proc)(cx->notify_arg, PR_FALSE, src, depth); |
| cx->during_notify = PR_FALSE; |
| } |
| |
| static sec_asn1e_state * |
| sec_asn1e_init_state_based_on_template(sec_asn1e_state *state) |
| { |
| PRBool isExplicit, is_string, may_stream, optional, universal; |
| PRBool disallowStreaming; |
| unsigned char tag_modifiers; |
| unsigned long encode_kind, under_kind; |
| unsigned long tag_number; |
| PRBool isInline = PR_FALSE; |
| |
| encode_kind = state->theTemplate->kind; |
| |
| universal = ((encode_kind & SEC_ASN1_CLASS_MASK) == SEC_ASN1_UNIVERSAL) |
| ? PR_TRUE |
| : PR_FALSE; |
| |
| isExplicit = (encode_kind & SEC_ASN1_EXPLICIT) ? PR_TRUE : PR_FALSE; |
| encode_kind &= ~SEC_ASN1_EXPLICIT; |
| |
| optional = (encode_kind & SEC_ASN1_OPTIONAL) ? PR_TRUE : PR_FALSE; |
| encode_kind &= ~SEC_ASN1_OPTIONAL; |
| |
| PORT_Assert(!(isExplicit && universal)); /* bad templates */ |
| |
| may_stream = (encode_kind & SEC_ASN1_MAY_STREAM) ? PR_TRUE : PR_FALSE; |
| encode_kind &= ~SEC_ASN1_MAY_STREAM; |
| |
| disallowStreaming = (encode_kind & SEC_ASN1_NO_STREAM) ? PR_TRUE : PR_FALSE; |
| encode_kind &= ~SEC_ASN1_NO_STREAM; |
| |
| /* Just clear this to get it out of the way; we do not need it here */ |
| encode_kind &= ~SEC_ASN1_DYNAMIC; |
| |
| if (encode_kind & SEC_ASN1_CHOICE) { |
| under_kind = SEC_ASN1_CHOICE; |
| } else if ((encode_kind & (SEC_ASN1_POINTER | SEC_ASN1_INLINE)) || |
| (!universal && !isExplicit)) { |
| const SEC_ASN1Template *subt; |
| void *src = NULL; |
| |
| PORT_Assert((encode_kind & (SEC_ASN1_ANY | SEC_ASN1_SKIP)) == 0); |
| |
| sec_asn1e_scrub_state(state); |
| |
| if (encode_kind & SEC_ASN1_POINTER) { |
| src = *(void **)state->src; |
| state->place = afterPointer; |
| |
| if (src == NULL) { |
| /* |
| * If this is optional, but NULL, then the field does |
| * not need to be encoded. In this case we are done; |
| * we do not want to push a subtemplate. |
| */ |
| if (optional) |
| return state; |
| |
| /* |
| * XXX this is an error; need to figure out |
| * how to handle this |
| */ |
| } |
| } else { |
| src = state->src; |
| if (encode_kind & SEC_ASN1_INLINE) { |
| /* check that there are no extraneous bits */ |
| /* PORT_Assert (encode_kind == SEC_ASN1_INLINE && !optional); */ |
| state->place = afterInline; |
| isInline = PR_TRUE; |
| } else { |
| /* |
| * Save the tag modifiers and tag number here before moving |
| * on to the next state in case this is a member of a |
| * SEQUENCE OF |
| */ |
| state->tag_modifiers = (unsigned char)(encode_kind & (SEC_ASN1_TAG_MASK & ~SEC_ASN1_TAGNUM_MASK)); |
| state->tag_number = (unsigned char)(encode_kind & SEC_ASN1_TAGNUM_MASK); |
| |
| state->place = afterImplicit; |
| state->optional = optional; |
| } |
| } |
| |
| subt = SEC_ASN1GetSubtemplate(state->theTemplate, state->src, PR_TRUE); |
| if (isInline && optional) { |
| /* we only handle a very limited set of optional inline cases at |
| this time */ |
| if (PR_FALSE != SEC_ASN1IsTemplateSimple(subt)) { |
| /* we now know that the target is a SECItem*, so we can check |
| if the source contains one */ |
| SECItem *target = (SECItem *)state->src; |
| if (!target || !target->data || !target->len) { |
| /* no valid data to encode subtemplate */ |
| return state; |
| } |
| } else { |
| PORT_Assert(0); /* complex templates are not handled as |
| inline optional */ |
| } |
| } |
| state = sec_asn1e_push_state(state->top, subt, src, PR_FALSE); |
| if (state == NULL) |
| return state; |
| |
| if (universal) { |
| /* |
| * This is a POINTER or INLINE; just init based on that |
| * and we are done. |
| */ |
| return sec_asn1e_init_state_based_on_template(state); |
| } |
| |
| /* |
| * This is an implicit, non-universal (meaning, application-private |
| * or context-specific) field. This results in a "magic" tag but |
| * encoding based on the underlying type. We pushed a new state |
| * that is based on the subtemplate (the underlying type), but |
| * now we will sort of alias it to give it some of our properties |
| * (tag, optional status, etc.). |
| * |
| * NB: ALL the following flags in the subtemplate are disallowed |
| * and/or ignored: EXPLICIT, OPTIONAL, INNER, INLINE, POINTER. |
| */ |
| |
| under_kind = state->theTemplate->kind; |
| if ((under_kind & SEC_ASN1_MAY_STREAM) && !disallowStreaming) { |
| may_stream = PR_TRUE; |
| } |
| under_kind &= ~(SEC_ASN1_MAY_STREAM | SEC_ASN1_DYNAMIC); |
| } else { |
| under_kind = encode_kind; |
| } |
| |
| /* |
| * Sanity check that there are no unwanted bits marked in under_kind. |
| * These bits were either removed above (after we recorded them) or |
| * they simply should not be found (signalling a bad/broken template). |
| * XXX is this the right set of bits to test here? (i.e. need to add |
| * or remove any?) |
| */ |
| #define UNEXPECTED_FLAGS \ |
| (SEC_ASN1_EXPLICIT | SEC_ASN1_OPTIONAL | SEC_ASN1_SKIP | SEC_ASN1_INNER | \ |
| SEC_ASN1_DYNAMIC | SEC_ASN1_MAY_STREAM | SEC_ASN1_INLINE | SEC_ASN1_POINTER) |
| |
| PORT_Assert((under_kind & UNEXPECTED_FLAGS) == 0); |
| under_kind &= ~UNEXPECTED_FLAGS; |
| #undef UNEXPECTED_FLAGS |
| |
| if (encode_kind & SEC_ASN1_ANY) { |
| PORT_Assert(encode_kind == under_kind); |
| tag_modifiers = 0; |
| tag_number = 0; |
| is_string = PR_TRUE; |
| } else { |
| tag_modifiers = (unsigned char)(encode_kind & (SEC_ASN1_TAG_MASK & ~SEC_ASN1_TAGNUM_MASK)); |
| /* |
| * XXX This assumes only single-octet identifiers. To handle |
| * the HIGH TAG form we would need to do some more work, especially |
| * in how to specify them in the template, because right now we |
| * do not provide a way to specify more *tag* bits in encode_kind. |
| */ |
| tag_number = encode_kind & SEC_ASN1_TAGNUM_MASK; |
| |
| is_string = PR_FALSE; |
| switch (under_kind & SEC_ASN1_TAGNUM_MASK) { |
| case SEC_ASN1_SET: |
| /* |
| * XXX A plain old SET (as opposed to a SET OF) is not implemented. |
| * If it ever is, remove this assert... |
| */ |
| PORT_Assert((under_kind & SEC_ASN1_GROUP) != 0); |
| /* fallthru */ |
| case SEC_ASN1_SEQUENCE: |
| tag_modifiers |= SEC_ASN1_CONSTRUCTED; |
| break; |
| case SEC_ASN1_BIT_STRING: |
| case SEC_ASN1_BMP_STRING: |
| case SEC_ASN1_GENERALIZED_TIME: |
| case SEC_ASN1_IA5_STRING: |
| case SEC_ASN1_OCTET_STRING: |
| case SEC_ASN1_PRINTABLE_STRING: |
| case SEC_ASN1_T61_STRING: |
| case SEC_ASN1_UNIVERSAL_STRING: |
| case SEC_ASN1_UTC_TIME: |
| case SEC_ASN1_UTF8_STRING: |
| case SEC_ASN1_VISIBLE_STRING: |
| /* |
| * We do not yet know if we will be constructing the string, |
| * so we have to wait to do this final tag modification. |
| */ |
| is_string = PR_TRUE; |
| break; |
| } |
| } |
| |
| state->tag_modifiers = tag_modifiers; |
| state->tag_number = (unsigned char)tag_number; |
| state->underlying_kind = under_kind; |
| state->isExplicit = isExplicit; |
| state->may_stream = may_stream; |
| state->is_string = is_string; |
| state->optional = optional; |
| state->disallowStreaming = disallowStreaming; |
| |
| sec_asn1e_scrub_state(state); |
| |
| return state; |
| } |
| |
| static void |
| sec_asn1e_write_part(sec_asn1e_state *state, |
| const char *buf, unsigned long len, |
| SEC_ASN1EncodingPart part) |
| { |
| SEC_ASN1EncoderContext *cx; |
| |
| cx = state->top; |
| (*cx->output_proc)(cx->output_arg, buf, len, state->depth, part); |
| } |
| |
| /* |
| * XXX This assumes only single-octet identifiers. To handle |
| * the HIGH TAG form we would need to modify this interface and |
| * teach it to properly encode the special form. |
| */ |
| static void |
| sec_asn1e_write_identifier_bytes(sec_asn1e_state *state, unsigned char value) |
| { |
| char byte; |
| |
| byte = (char)value; |
| sec_asn1e_write_part(state, &byte, 1, SEC_ASN1_Identifier); |
| } |
| |
| int |
| SEC_ASN1EncodeLength(unsigned char *buf, int value) |
| { |
| int lenlen; |
| |
| lenlen = SEC_ASN1LengthLength(value); |
| if (lenlen == 1) { |
| buf[0] = value; |
| } else { |
| int i; |
| |
| i = lenlen - 1; |
| buf[0] = 0x80 | i; |
| while (i) { |
| buf[i--] = value; |
| value >>= 8; |
| } |
| PORT_Assert(value == 0); |
| } |
| return lenlen; |
| } |
| |
| static void |
| sec_asn1e_write_length_bytes(sec_asn1e_state *state, unsigned long value, |
| PRBool indefinite) |
| { |
| int lenlen; |
| unsigned char buf[sizeof(unsigned long) + 1]; |
| |
| if (indefinite) { |
| PORT_Assert(value == 0); |
| buf[0] = 0x80; |
| lenlen = 1; |
| } else { |
| lenlen = SEC_ASN1EncodeLength(buf, value); |
| } |
| |
| sec_asn1e_write_part(state, (char *)buf, lenlen, SEC_ASN1_Length); |
| } |
| |
| static void |
| sec_asn1e_write_contents_bytes(sec_asn1e_state *state, |
| const char *buf, unsigned long len) |
| { |
| sec_asn1e_write_part(state, buf, len, SEC_ASN1_Contents); |
| } |
| |
| static void |
| sec_asn1e_write_end_of_contents_bytes(sec_asn1e_state *state) |
| { |
| const char eoc[2] = { 0, 0 }; |
| |
| sec_asn1e_write_part(state, eoc, 2, SEC_ASN1_EndOfContents); |
| } |
| |
| static int |
| sec_asn1e_which_choice( |
| void *src, |
| const SEC_ASN1Template *theTemplate) |
| { |
| int rv; |
| unsigned int which = *(unsigned int *)src; |
| |
| for (rv = 1, theTemplate++; theTemplate->kind != 0; rv++, theTemplate++) { |
| if (which == theTemplate->size) { |
| return rv; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static unsigned long |
| sec_asn1e_contents_length(const SEC_ASN1Template *theTemplate, void *src, |
| PRBool disallowStreaming, PRBool insideIndefinite, |
| sec_asn1e_hdr_encoding *pHdrException) |
| { |
| unsigned long encode_kind, underlying_kind; |
| PRBool isExplicit, optional, universal, may_stream; |
| unsigned long len; |
| |
| /* |
| * This function currently calculates the length in all cases |
| * except the following: when writing out the contents of a |
| * template that belongs to a state where it was a sub-template |
| * with the SEC_ASN1_MAY_STREAM bit set and it's parent had the |
| * optional bit set. The information that the parent is optional |
| * and that we should return the length of 0 when that length is |
| * present since that means the optional field is no longer present. |
| * So we add the disallowStreaming flag which is passed in when |
| * writing the contents, but for all recursive calls to |
| * sec_asn1e_contents_length, we pass PR_FALSE, because this |
| * function correctly calculates the length for children templates |
| * from that point on. Confused yet? At least you didn't have |
| * to figure it out. ;) -javi |
| */ |
| encode_kind = theTemplate->kind; |
| |
| universal = ((encode_kind & SEC_ASN1_CLASS_MASK) == SEC_ASN1_UNIVERSAL) |
| ? PR_TRUE |
| : PR_FALSE; |
| |
| isExplicit = (encode_kind & SEC_ASN1_EXPLICIT) ? PR_TRUE : PR_FALSE; |
| encode_kind &= ~SEC_ASN1_EXPLICIT; |
| |
| optional = (encode_kind & SEC_ASN1_OPTIONAL) ? PR_TRUE : PR_FALSE; |
| encode_kind &= ~SEC_ASN1_OPTIONAL; |
| |
| PORT_Assert(!(isExplicit && universal)); /* bad templates */ |
| |
| may_stream = (encode_kind & SEC_ASN1_MAY_STREAM) ? PR_TRUE : PR_FALSE; |
| encode_kind &= ~SEC_ASN1_MAY_STREAM; |
| |
| /* Just clear this to get it out of the way; we do not need it here */ |
| encode_kind &= ~SEC_ASN1_DYNAMIC; |
| |
| if (encode_kind & SEC_ASN1_NO_STREAM) { |
| disallowStreaming = PR_TRUE; |
| } |
| encode_kind &= ~SEC_ASN1_NO_STREAM; |
| |
| if (encode_kind & SEC_ASN1_CHOICE) { |
| void *src2; |
| int indx = sec_asn1e_which_choice(src, theTemplate); |
| if (0 == indx) { |
| /* XXX set an error? "choice not found" */ |
| /* state->top->status = encodeError; */ |
| return 0; |
| } |
| |
| src2 = (void *)((char *)src - theTemplate->offset + theTemplate[indx].offset); |
| |
| return sec_asn1e_contents_length(&theTemplate[indx], src2, |
| disallowStreaming, insideIndefinite, |
| pHdrException); |
| } |
| |
| if ((encode_kind & (SEC_ASN1_POINTER | SEC_ASN1_INLINE)) || !universal) { |
| /* XXX any bits we want to disallow (PORT_Assert against) here? */ |
| theTemplate = SEC_ASN1GetSubtemplate(theTemplate, src, PR_TRUE); |
| if (encode_kind & SEC_ASN1_POINTER) { |
| src = *(void **)src; |
| if (src == NULL) { |
| *pHdrException = optional ? hdr_optional : hdr_normal; |
| return 0; |
| } |
| } else if (encode_kind & SEC_ASN1_INLINE) { |
| /* check that there are no extraneous bits */ |
| if (optional) { |
| if (PR_FALSE != SEC_ASN1IsTemplateSimple(theTemplate)) { |
| /* we now know that the target is a SECItem*, so we can check |
| if the source contains one */ |
| SECItem *target = (SECItem *)src; |
| if (!target || !target->data || !target->len) { |
| /* no valid data to encode subtemplate */ |
| *pHdrException = hdr_optional; |
| return 0; |
| } |
| } else { |
| PORT_Assert(0); /* complex templates not handled as inline |
| optional */ |
| } |
| } |
| } |
| |
| src = (char *)src + theTemplate->offset; |
| |
| /* recurse to find the length of the subtemplate */ |
| len = sec_asn1e_contents_length(theTemplate, src, disallowStreaming, |
| insideIndefinite, pHdrException); |
| if (len == 0 && optional) { |
| *pHdrException = hdr_optional; |
| } else if (isExplicit) { |
| if (*pHdrException == hdr_any) { |
| /* *we* do not want to add in a header, |
| ** but our caller still does. |
| */ |
| *pHdrException = hdr_normal; |
| } else if (*pHdrException == hdr_normal) { |
| /* if the inner content exists, our length is |
| * len(identifier) + len(length) + len(innercontent) |
| * XXX we currently assume len(identifier) == 1; |
| * to support a high-tag-number this would need to be smarter. |
| */ |
| len += 1 + SEC_ASN1LengthLength(len); |
| } |
| } |
| return len; |
| } |
| underlying_kind = encode_kind; |
| |
| /* This is only used in decoding; it plays no part in encoding. */ |
| if (underlying_kind & SEC_ASN1_SAVE) { |
| /* check that there are no extraneous bits */ |
| PORT_Assert(underlying_kind == SEC_ASN1_SAVE); |
| *pHdrException = hdr_decoder; |
| return 0; |
| } |
| |
| #define UNEXPECTED_FLAGS \ |
| (SEC_ASN1_EXPLICIT | SEC_ASN1_OPTIONAL | SEC_ASN1_INLINE | SEC_ASN1_POINTER | \ |
| SEC_ASN1_DYNAMIC | SEC_ASN1_MAY_STREAM | SEC_ASN1_SAVE | SEC_ASN1_SKIP) |
| |
| /* Having any of these bits is not expected here... */ |
| PORT_Assert((underlying_kind & UNEXPECTED_FLAGS) == 0); |
| underlying_kind &= ~UNEXPECTED_FLAGS; |
| #undef UNEXPECTED_FLAGS |
| |
| if (underlying_kind & SEC_ASN1_CHOICE) { |
| void *src2; |
| int indx = sec_asn1e_which_choice(src, theTemplate); |
| if (0 == indx) { |
| /* XXX set an error? "choice not found" */ |
| /* state->top->status = encodeError; */ |
| return 0; |
| } |
| |
| src2 = (void *)((char *)src - theTemplate->offset + theTemplate[indx].offset); |
| len = sec_asn1e_contents_length(&theTemplate[indx], src2, |
| disallowStreaming, insideIndefinite, |
| pHdrException); |
| } else { |
| switch (underlying_kind) { |
| case SEC_ASN1_SEQUENCE_OF: |
| case SEC_ASN1_SET_OF: { |
| const SEC_ASN1Template *tmpt; |
| void *sub_src; |
| unsigned long sub_len; |
| void **group; |
| |
| len = 0; |
| |
| group = *(void ***)src; |
| if (group == NULL) |
| break; |
| |
| tmpt = SEC_ASN1GetSubtemplate(theTemplate, src, PR_TRUE); |
| |
| for (; *group != NULL; group++) { |
| sub_src = (char *)(*group) + tmpt->offset; |
| sub_len = sec_asn1e_contents_length(tmpt, sub_src, |
| disallowStreaming, |
| insideIndefinite, |
| pHdrException); |
| len += sub_len; |
| /* |
| * XXX The 1 below is the presumed length of the identifier; |
| * to support a high-tag-number this would need to be smarter. |
| */ |
| if (*pHdrException == hdr_normal) |
| len += 1 + SEC_ASN1LengthLength(sub_len); |
| } |
| } break; |
| |
| case SEC_ASN1_SEQUENCE: |
| case SEC_ASN1_SET: { |
| const SEC_ASN1Template *tmpt; |
| void *sub_src; |
| unsigned long sub_len; |
| |
| len = 0; |
| for (tmpt = theTemplate + 1; tmpt->kind; tmpt++) { |
| sub_src = (char *)src + tmpt->offset; |
| sub_len = sec_asn1e_contents_length(tmpt, sub_src, |
| disallowStreaming, |
| insideIndefinite, |
| pHdrException); |
| len += sub_len; |
| /* |
| * XXX The 1 below is the presumed length of the identifier; |
| * to support a high-tag-number this would need to be smarter. |
| */ |
| if (*pHdrException == hdr_normal) |
| len += 1 + SEC_ASN1LengthLength(sub_len); |
| } |
| } break; |
| |
| case SEC_ASN1_BIT_STRING: |
| /* convert bit length to byte */ |
| len = (((SECItem *)src)->len + 7) >> 3; |
| /* bit string contents involve an extra octet */ |
| if (len) |
| len++; |
| break; |
| |
| case SEC_ASN1_INTEGER: |
| /* ASN.1 INTEGERs are signed. |
| * If the source is an unsigned integer, the encoder will need |
| * to handle the conversion here. |
| */ |
| { |
| unsigned char *buf = ((SECItem *)src)->data; |
| SECItemType integerType = ((SECItem *)src)->type; |
| len = ((SECItem *)src)->len; |
| while (len > 0) { |
| if (*buf != 0) { |
| if (*buf & 0x80 && integerType == siUnsignedInteger) { |
| len++; /* leading zero needed to make number signed */ |
| } |
| break; /* reached beginning of number */ |
| } |
| if (len == 1) { |
| break; /* the number 0 */ |
| } |
| if (buf[1] & 0x80) { |
| break; /* leading zero already present */ |
| } |
| /* extraneous leading zero, keep going */ |
| buf++; |
| len--; |
| } |
| } |
| break; |
| |
| default: |
| len = ((SECItem *)src)->len; |
| break; |
| } /* end switch */ |
| |
| #ifndef WHAT_PROBLEM_DOES_THIS_SOLVE |
| /* if we're streaming, we may have a secitem w/len 0 as placeholder */ |
| if (!len && insideIndefinite && may_stream && !disallowStreaming) { |
| len = 1; |
| } |
| #endif |
| } /* end else */ |
| |
| if (len == 0 && optional) |
| *pHdrException = hdr_optional; |
| else if (underlying_kind == SEC_ASN1_ANY) |
| *pHdrException = hdr_any; |
| else |
| *pHdrException = hdr_normal; |
| |
| return len; |
| } |
| |
| static void |
| sec_asn1e_write_header(sec_asn1e_state *state) |
| { |
| unsigned long contents_length; |
| unsigned char tag_number, tag_modifiers; |
| sec_asn1e_hdr_encoding hdrException = hdr_normal; |
| PRBool indefinite = PR_FALSE; |
| |
| PORT_Assert(state->place == beforeHeader); |
| |
| tag_number = state->tag_number; |
| tag_modifiers = state->tag_modifiers; |
| |
| if (state->underlying_kind == SEC_ASN1_ANY) { |
| state->place = duringContents; |
| return; |
| } |
| |
| if (state->underlying_kind & SEC_ASN1_CHOICE) { |
| int indx = sec_asn1e_which_choice(state->src, state->theTemplate); |
| if (0 == indx) { |
| /* XXX set an error? "choice not found" */ |
| state->top->status = encodeError; |
| return; |
| } |
| state->place = afterChoice; |
| state = sec_asn1e_push_state(state->top, &state->theTemplate[indx], |
| (char *)state->src - state->theTemplate->offset, |
| PR_TRUE); |
| if (state) { |
| /* |
| * Do the "before" field notification. |
| */ |
| sec_asn1e_notify_before(state->top, state->src, state->depth); |
| (void)sec_asn1e_init_state_based_on_template(state); |
| } |
| return; |
| } |
| |
| /* The !isString test below is apparently intended to ensure that all |
| ** constructed types receive indefinite length encoding. |
| */ |
| indefinite = (PRBool)(state->top->streaming && state->may_stream && |
| (state->top->from_buf || !state->is_string)); |
| |
| /* |
| * If we are doing a definite-length encoding, first we have to |
| * walk the data structure to calculate the entire contents length. |
| * If we are doing an indefinite-length encoding, we still need to |
| * know if the contents is: |
| * optional and to be omitted, or |
| * an ANY (header is pre-encoded), or |
| * a SAVE or some other kind of template used only by the decoder. |
| * So, we call this function either way. |
| */ |
| contents_length = sec_asn1e_contents_length(state->theTemplate, |
| state->src, |
| state->disallowStreaming, |
| indefinite, |
| &hdrException); |
| /* |
| * We might be told explicitly not to put out a header. |
| * But it can also be the case, via a pushed subtemplate, that |
| * sec_asn1e_contents_length could not know that this field is |
| * really optional. So check for that explicitly, too. |
| */ |
| if (hdrException != hdr_normal || |
| (contents_length == 0 && state->optional)) { |
| state->place = afterContents; |
| if (state->top->streaming && |
| state->may_stream && |
| state->top->from_buf) { |
| /* we did not find an optional indefinite string, so we |
| * don't encode it. However, if TakeFromBuf is on, we stop |
| * here anyway to give our caller a chance to intercept at the |
| * same point where we would stop if the field were present. |
| */ |
| state->top->status = needBytes; |
| } |
| return; |
| } |
| |
| if (indefinite) { |
| /* |
| * We need to put out an indefinite-length encoding. |
| * The only universal types that can be constructed are SETs, |
| * SEQUENCEs, and strings; so check that it is one of those, |
| * or that it is not universal (e.g. context-specific). |
| */ |
| state->indefinite = PR_TRUE; |
| PORT_Assert((tag_number == SEC_ASN1_SET) || (tag_number == SEC_ASN1_SEQUENCE) || ((tag_modifiers & SEC_ASN1_CLASS_MASK) != 0) || state->is_string); |
| tag_modifiers |= SEC_ASN1_CONSTRUCTED; |
| contents_length = 0; |
| } |
| |
| sec_asn1e_write_identifier_bytes(state, |
| (unsigned char)(tag_number | tag_modifiers)); |
| sec_asn1e_write_length_bytes(state, contents_length, state->indefinite); |
| |
| if (contents_length == 0 && !state->indefinite) { |
| /* |
| * If no real contents to encode, then we are done with this field. |
| */ |
| state->place = afterContents; |
| return; |
| } |
| |
| /* |
| * An EXPLICIT is nothing but an outer header, which we have already |
| * written. Now we need to do the inner header and contents. |
| */ |
| if (state->isExplicit) { |
| const SEC_ASN1Template *subt = |
| SEC_ASN1GetSubtemplate(state->theTemplate, state->src, PR_TRUE); |
| state->place = afterContents; |
| state = sec_asn1e_push_state(state->top, subt, state->src, PR_TRUE); |
| if (state != NULL) { |
| (void)sec_asn1e_init_state_based_on_template(state); |
| } |
| return; |
| } |
| |
| switch (state->underlying_kind) { |
| case SEC_ASN1_SET_OF: |
| case SEC_ASN1_SEQUENCE_OF: |
| /* |
| * We need to push a child to handle each member. |
| */ |
| { |
| void **group; |
| const SEC_ASN1Template *subt; |
| |
| group = *(void ***)state->src; |
| if (group == NULL || *group == NULL) { |
| /* |
| * Group is empty; we are done. |
| */ |
| state->place = afterContents; |
| return; |
| } |
| state->place = duringGroup; |
| subt = SEC_ASN1GetSubtemplate(state->theTemplate, state->src, |
| PR_TRUE); |
| state = sec_asn1e_push_state(state->top, subt, *group, PR_TRUE); |
| if (state != NULL) { |
| (void)sec_asn1e_init_state_based_on_template(state); |
| } |
| } |
| break; |
| |
| case SEC_ASN1_SEQUENCE: |
| case SEC_ASN1_SET: |
| /* |
| * We need to push a child to handle the individual fields. |
| */ |
| state->place = duringSequence; |
| state = sec_asn1e_push_state(state->top, state->theTemplate + 1, |
| state->src, PR_TRUE); |
| if (state != NULL) { |
| /* |
| * Do the "before" field notification. |
| */ |
| sec_asn1e_notify_before(state->top, state->src, state->depth); |
| (void)sec_asn1e_init_state_based_on_template(state); |
| } |
| break; |
| |
| default: |
| /* |
| * I think we do not need to do anything else. |
| * XXX Correct? |
| */ |
| state->place = duringContents; |
| break; |
| } |
| } |
| |
| static void |
| sec_asn1e_write_contents_from_buf(sec_asn1e_state *state, |
| const char *buf, unsigned long len) |
| { |
| PORT_Assert(state->place == duringContents); |
| PORT_Assert(state->top->from_buf); |
| PORT_Assert(state->may_stream && !state->disallowStreaming); |
| |
| /* |
| * Probably they just turned on "take from buf", but have not |
| * yet given us any bytes. If there is nothing in the buffer |
| * then we have nothing to do but return and wait. |
| */ |
| if (buf == NULL || len == 0) { |
| state->top->status = needBytes; |
| return; |
| } |
| /* |
| * We are streaming, reading from a passed-in buffer. |
| * This means we are encoding a simple string or an ANY. |
| * For the former, we need to put out a substring, with its |
| * own identifier and length. For an ANY, we just write it |
| * out as is (our caller is required to ensure that it |
| * is a properly encoded entity). |
| */ |
| PORT_Assert(state->is_string); /* includes ANY */ |
| if (state->underlying_kind != SEC_ASN1_ANY) { |
| unsigned char identifier; |
| |
| /* |
| * Create the identifier based on underlying_kind. We cannot |
| * use tag_number and tag_modifiers because this can be an |
| * implicitly encoded field. In that case, the underlying |
| * substrings *are* encoded with their real tag. |
| */ |
| identifier = (unsigned char)(state->underlying_kind & SEC_ASN1_TAG_MASK); |
| /* |
| * The underlying kind should just be a simple string; there |
| * should be no bits like CONTEXT_SPECIFIC or CONSTRUCTED set. |
| */ |
| PORT_Assert((identifier & SEC_ASN1_TAGNUM_MASK) == identifier); |
| /* |
| * Write out the tag and length for the substring. |
| */ |
| sec_asn1e_write_identifier_bytes(state, identifier); |
| if (state->underlying_kind == SEC_ASN1_BIT_STRING) { |
| char byte; |
| /* |
| * Assume we have a length in bytes but we need to output |
| * a proper bit string. This interface only works for bit |
| * strings that are full multiples of 8. If support for |
| * real, variable length bit strings is needed then the |
| * caller will have to know to pass in a bit length instead |
| * of a byte length and then this code will have to |
| * perform the encoding necessary (length written is length |
| * in bytes plus 1, and the first octet of string is the |
| * number of bits remaining between the end of the bit |
| * string and the next byte boundary). |
| */ |
| sec_asn1e_write_length_bytes(state, len + 1, PR_FALSE); |
| byte = 0; |
| sec_asn1e_write_contents_bytes(state, &byte, 1); |
| } else { |
| sec_asn1e_write_length_bytes(state, len, PR_FALSE); |
| } |
| } |
| sec_asn1e_write_contents_bytes(state, buf, len); |
| state->top->status = needBytes; |
| } |
| |
| static void |
| sec_asn1e_write_contents(sec_asn1e_state *state) |
| { |
| unsigned long len = 0; |
| |
| PORT_Assert(state->place == duringContents); |
| |
| switch (state->underlying_kind) { |
| case SEC_ASN1_SET: |
| case SEC_ASN1_SEQUENCE: |
| PORT_Assert(0); |
| break; |
| |
| case SEC_ASN1_BIT_STRING: { |
| SECItem *item; |
| char rem; |
| |
| item = (SECItem *)state->src; |
| len = (item->len + 7) >> 3; |
| rem = (unsigned char)((len << 3) - item->len); /* remaining bits */ |
| sec_asn1e_write_contents_bytes(state, &rem, 1); |
| sec_asn1e_write_contents_bytes(state, (char *)item->data, len); |
| } break; |
| |
| case SEC_ASN1_BMP_STRING: |
| /* The number of bytes must be divisable by 2 */ |
| if ((((SECItem *)state->src)->len) % 2) { |
| SEC_ASN1EncoderContext *cx; |
| |
| cx = state->top; |
| cx->status = encodeError; |
| break; |
| } |
| /* otherwise, fall through to write the content */ |
| goto process_string; |
| |
| case SEC_ASN1_UNIVERSAL_STRING: |
| /* The number of bytes must be divisable by 4 */ |
| if ((((SECItem *)state->src)->len) % 4) { |
| SEC_ASN1EncoderContext *cx; |
| |
| cx = state->top; |
| cx->status = encodeError; |
| break; |
| } |
| /* otherwise, fall through to write the content */ |
| goto process_string; |
| |
| case SEC_ASN1_INTEGER: |
| /* ASN.1 INTEGERs are signed. If the source is an unsigned |
| * integer, the encoder will need to handle the conversion here. |
| */ |
| { |
| unsigned int blen; |
| unsigned char *buf; |
| SECItemType integerType; |
| blen = ((SECItem *)state->src)->len; |
| buf = ((SECItem *)state->src)->data; |
| integerType = ((SECItem *)state->src)->type; |
| while (blen > 0) { |
| if (*buf & 0x80 && integerType == siUnsignedInteger) { |
| char zero = 0; /* write a leading 0 */ |
| sec_asn1e_write_contents_bytes(state, &zero, 1); |
| /* and then the remaining buffer */ |
| sec_asn1e_write_contents_bytes(state, |
| (char *)buf, blen); |
| break; |
| } |
| /* Check three possibilities: |
| * 1. No leading zeros, msb of MSB is not 1; |
| * 2. The number is zero itself; |
| * 3. Encoding a signed integer with a leading zero, |
| * keep the zero so that the number is positive. |
| */ |
| if (*buf != 0 || |
| blen == 1 || |
| (buf[1] & 0x80 && integerType != siUnsignedInteger)) { |
| sec_asn1e_write_contents_bytes(state, |
| (char *)buf, blen); |
| break; |
| } |
| /* byte is 0, continue */ |
| buf++; |
| blen--; |
| } |
| } |
| /* done with this content */ |
| break; |
| |
| process_string: |
| default: { |
| SECItem *item; |
| |
| item = (SECItem *)state->src; |
| sec_asn1e_write_contents_bytes(state, (char *)item->data, |
| item->len); |
| } break; |
| } |
| state->place = afterContents; |
| } |
| |
| /* |
| * We are doing a SET OF or SEQUENCE OF, and have just finished an item. |
| */ |
| static void |
| sec_asn1e_next_in_group(sec_asn1e_state *state) |
| { |
| sec_asn1e_state *child; |
| void **group; |
| void *member; |
| |
| PORT_Assert(state->place == duringGroup); |
| PORT_Assert(state->child != NULL); |
| |
| child = state->child; |
| |
| group = *(void ***)state->src; |
| |
| /* |
| * Find placement of current item. |
| */ |
| member = (char *)(state->child->src) - child->theTemplate->offset; |
| while (*group != member) |
| group++; |
| |
| /* |
| * Move forward to next item. |
| */ |
| group++; |
| if (*group == NULL) { |
| /* |
| * That was our last one; we are done now. |
| */ |
| child->place = notInUse; |
| state->place = afterContents; |
| return; |
| } |
| child->src = (char *)(*group) + child->theTemplate->offset; |
| |
| /* |
| * Re-"push" child. |
| */ |
| sec_asn1e_scrub_state(child); |
| state->top->current = child; |
| } |
| |
| /* |
| * We are moving along through a sequence; move forward by one, |
| * (detecting end-of-sequence when it happens). |
| */ |
| static void |
| sec_asn1e_next_in_sequence(sec_asn1e_state *state) |
| { |
| sec_asn1e_state *child; |
| |
| PORT_Assert(state->place == duringSequence); |
| PORT_Assert(state->child != NULL); |
| |
| child = state->child; |
| |
| /* |
| * Do the "after" field notification. |
| */ |
| sec_asn1e_notify_after(state->top, child->src, child->depth); |
| |
| /* |
| * Move forward. |
| */ |
| child->theTemplate++; |
| if (child->theTemplate->kind == 0) { |
| /* |
| * We are done with this sequence. |
| */ |
| child->place = notInUse; |
| state->place = afterContents; |
| return; |
| } |
| |
| /* |
| * Reset state and push. |
| */ |
| |
| child->src = (char *)state->src + child->theTemplate->offset; |
| |
| /* |
| * Do the "before" field notification. |
| */ |
| sec_asn1e_notify_before(state->top, child->src, child->depth); |
| |
| state->top->current = child; |
| (void)sec_asn1e_init_state_based_on_template(child); |
| } |
| |
| static void |
| sec_asn1e_after_contents(sec_asn1e_state *state) |
| { |
| PORT_Assert(state->place == afterContents); |
| |
| if (state->indefinite) |
| sec_asn1e_write_end_of_contents_bytes(state); |
| |
| /* |
| * Just make my parent be the current state. It will then clean |
| * up after me and free me (or reuse me). |
| */ |
| state->top->current = state->parent; |
| } |
| |
| /* |
| * This function is called whether or not we are streaming; if we |
| * *are* streaming, our caller can also instruct us to take bytes |
| * from the passed-in buffer (at buf, for length len, which is likely |
| * bytes but could even mean bits if the current field is a bit string). |
| * If we have been so instructed, we will gobble up bytes from there |
| * (rather than from our src structure) and output them, and then |
| * we will just return, expecting to be called again -- either with |
| * more bytes or after our caller has instructed us that we are done |
| * (for now) with the buffer. |
| */ |
| SECStatus |
| SEC_ASN1EncoderUpdate(SEC_ASN1EncoderContext *cx, |
| const char *buf, unsigned long len) |
| { |
| sec_asn1e_state *state; |
| |
| if (cx->status == needBytes) { |
| cx->status = keepGoing; |
| } |
| |
| while (cx->status == keepGoing) { |
| state = cx->current; |
| switch (state->place) { |
| case beforeHeader: |
| sec_asn1e_write_header(state); |
| break; |
| case duringContents: |
| if (cx->from_buf) |
| sec_asn1e_write_contents_from_buf(state, buf, len); |
| else |
| sec_asn1e_write_contents(state); |
| break; |
| case duringGroup: |
| sec_asn1e_next_in_group(state); |
| break; |
| case duringSequence: |
| sec_asn1e_next_in_sequence(state); |
| break; |
| case afterContents: |
| sec_asn1e_after_contents(state); |
| break; |
| case afterImplicit: |
| case afterInline: |
| case afterPointer: |
| case afterChoice: |
| /* |
| * These states are more documentation than anything. |
| * They just need to force a pop. |
| */ |
| PORT_Assert(!state->indefinite); |
| state->place = afterContents; |
| break; |
| case notInUse: |
| default: |
| /* This is not an error, but rather a plain old BUG! */ |
| PORT_Assert(0); |
| cx->status = encodeError; |
| break; |
| } |
| |
| if (cx->status == encodeError) |
| break; |
| |
| /* It might have changed, so we have to update our local copy. */ |
| state = cx->current; |
| |
| /* If it is NULL, we have popped all the way to the top. */ |
| if (state == NULL) { |
| cx->status = allDone; |
| break; |
| } |
| } |
| |
| if (cx->status == encodeError) { |
| return SECFailure; |
| } |
| |
| return SECSuccess; |
| } |
| |
| void |
| SEC_ASN1EncoderFinish(SEC_ASN1EncoderContext *cx) |
| { |
| /* |
| * XXX anything else that needs to be finished? |
| */ |
| |
| PORT_FreeArena(cx->our_pool, PR_FALSE); |
| } |
| |
| SEC_ASN1EncoderContext * |
| SEC_ASN1EncoderStart(const void *src, const SEC_ASN1Template *theTemplate, |
| SEC_ASN1WriteProc output_proc, void *output_arg) |
| { |
| PLArenaPool *our_pool; |
| SEC_ASN1EncoderContext *cx; |
| |
| our_pool = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE); |
| if (our_pool == NULL) |
| return NULL; |
| |
| cx = (SEC_ASN1EncoderContext *)PORT_ArenaZAlloc(our_pool, sizeof(*cx)); |
| if (cx == NULL) { |
| PORT_FreeArena(our_pool, PR_FALSE); |
| return NULL; |
| } |
| |
| cx->our_pool = our_pool; |
| cx->output_proc = output_proc; |
| cx->output_arg = output_arg; |
| |
| cx->status = keepGoing; |
| |
| if (sec_asn1e_push_state(cx, theTemplate, src, PR_FALSE) == NULL || |
| sec_asn1e_init_state_based_on_template(cx->current) == NULL) { |
| /* |
| * Trouble initializing (probably due to failed allocations) |
| * requires that we just give up. |
| */ |
| PORT_FreeArena(our_pool, PR_FALSE); |
| return NULL; |
| } |
| |
| return cx; |
| } |
| |
| /* |
| * XXX Do we need a FilterProc, too? |
| */ |
| |
| void |
| SEC_ASN1EncoderSetNotifyProc(SEC_ASN1EncoderContext *cx, |
| SEC_ASN1NotifyProc fn, void *arg) |
| { |
| cx->notify_proc = fn; |
| cx->notify_arg = arg; |
| } |
| |
| void |
| SEC_ASN1EncoderClearNotifyProc(SEC_ASN1EncoderContext *cx) |
| { |
| cx->notify_proc = NULL; |
| cx->notify_arg = NULL; /* not necessary; just being clean */ |
| } |
| |
| void |
| SEC_ASN1EncoderAbort(SEC_ASN1EncoderContext *cx, int error) |
| { |
| PORT_Assert(cx); |
| PORT_SetError(error); |
| cx->status = encodeError; |
| } |
| |
| void |
| SEC_ASN1EncoderSetStreaming(SEC_ASN1EncoderContext *cx) |
| { |
| /* XXX is there a way to check that we are "between" fields here? */ |
| |
| cx->streaming = PR_TRUE; |
| } |
| |
| void |
| SEC_ASN1EncoderClearStreaming(SEC_ASN1EncoderContext *cx) |
| { |
| /* XXX is there a way to check that we are "between" fields here? */ |
| |
| cx->streaming = PR_FALSE; |
| } |
| |
| void |
| SEC_ASN1EncoderSetTakeFromBuf(SEC_ASN1EncoderContext *cx) |
| { |
| /* |
| * XXX is there a way to check that we are "between" fields here? this |
| * needs to include a check for being in between groups of items in |
| * a SET_OF or SEQUENCE_OF. |
| */ |
| PORT_Assert(cx->streaming); |
| |
| cx->from_buf = PR_TRUE; |
| } |
| |
| void |
| SEC_ASN1EncoderClearTakeFromBuf(SEC_ASN1EncoderContext *cx) |
| { |
| /* we should actually be taking from buf *now* */ |
| PORT_Assert(cx->from_buf); |
| if (!cx->from_buf) /* if not, just do nothing */ |
| return; |
| |
| cx->from_buf = PR_FALSE; |
| |
| if (cx->status == needBytes) { |
| cx->status = keepGoing; |
| cx->current->place = afterContents; |
| } |
| } |
| |
| SECStatus |
| SEC_ASN1Encode(const void *src, const SEC_ASN1Template *theTemplate, |
| SEC_ASN1WriteProc output_proc, void *output_arg) |
| { |
| SEC_ASN1EncoderContext *ecx; |
| SECStatus rv; |
| |
| ecx = SEC_ASN1EncoderStart(src, theTemplate, output_proc, output_arg); |
| if (ecx == NULL) |
| return SECFailure; |
| |
| rv = SEC_ASN1EncoderUpdate(ecx, NULL, 0); |
| |
| SEC_ASN1EncoderFinish(ecx); |
| return rv; |
| } |
| |
| /* |
| * XXX depth and data_kind are unused; is there a PC way to silence warnings? |
| * (I mean "politically correct", not anything to do with intel/win platform) |
| */ |
| static void |
| sec_asn1e_encode_item_count(void *arg, const char *buf, unsigned long len, |
| int depth, SEC_ASN1EncodingPart data_kind) |
| { |
| unsigned long *count; |
| |
| count = (unsigned long *)arg; |
| PORT_Assert(count != NULL); |
| |
| *count += len; |
| } |
| |
| /* XXX depth and data_kind are unused; is there a PC way to silence warnings? */ |
| static void |
| sec_asn1e_encode_item_store(void *arg, const char *buf, unsigned long len, |
| int depth, SEC_ASN1EncodingPart data_kind) |
| { |
| SECItem *dest; |
| |
| dest = (SECItem *)arg; |
| PORT_Assert(dest != NULL); |
| |
| if (len > 0) { |
| PORT_Memcpy(dest->data + dest->len, buf, len); |
| dest->len += len; |
| } |
| } |
| |
| /* |
| * Allocate an entire SECItem, or just the data part of it, to hold |
| * "len" bytes of stuff. Allocate from the given pool, if specified, |
| * otherwise just do a vanilla PORT_Alloc. |
| * |
| * XXX This seems like a reasonable general-purpose function (for SECITEM_)? |
| */ |
| static SECItem * |
| sec_asn1e_allocate_item(PLArenaPool *poolp, SECItem *dest, unsigned long len) |
| { |
| if (poolp != NULL) { |
| void *release; |
| |
| release = PORT_ArenaMark(poolp); |
| if (dest == NULL) |
| dest = (SECItem *)PORT_ArenaAlloc(poolp, sizeof(SECItem)); |
| if (dest != NULL) { |
| dest->data = (unsigned char *)PORT_ArenaAlloc(poolp, len); |
| if (dest->data == NULL) { |
| dest = NULL; |
| } |
| } |
| if (dest == NULL) { |
| /* one or both allocations failed; release everything */ |
| PORT_ArenaRelease(poolp, release); |
| } else { |
| /* everything okay; unmark the arena */ |
| PORT_ArenaUnmark(poolp, release); |
| } |
| } else { |
| SECItem *indest; |
| |
| indest = dest; |
| if (dest == NULL) |
| dest = (SECItem *)PORT_Alloc(sizeof(SECItem)); |
| if (dest != NULL) { |
| dest->type = siBuffer; |
| dest->data = (unsigned char *)PORT_Alloc(len); |
| if (dest->data == NULL) { |
| if (indest == NULL) |
| PORT_Free(dest); |
| dest = NULL; |
| } |
| } |
| } |
| |
| return dest; |
| } |
| |
| SECItem * |
| SEC_ASN1EncodeItem(PLArenaPool *poolp, SECItem *dest, const void *src, |
| const SEC_ASN1Template *theTemplate) |
| { |
| unsigned long encoding_length; |
| SECStatus rv; |
| |
| PORT_Assert(dest == NULL || dest->data == NULL); |
| |
| encoding_length = 0; |
| rv = SEC_ASN1Encode(src, theTemplate, |
| sec_asn1e_encode_item_count, &encoding_length); |
| if (rv != SECSuccess) |
| return NULL; |
| |
| dest = sec_asn1e_allocate_item(poolp, dest, encoding_length); |
| if (dest == NULL) |
| return NULL; |
| |
| /* XXX necessary? This really just checks for a bug in the allocate fn */ |
| PORT_Assert(dest->data != NULL); |
| if (dest->data == NULL) |
| return NULL; |
| |
| dest->len = 0; |
| (void)SEC_ASN1Encode(src, theTemplate, sec_asn1e_encode_item_store, dest); |
| |
| PORT_Assert(encoding_length == dest->len); |
| return dest; |
| } |
| |
| static SECItem * |
| sec_asn1e_integer(PLArenaPool *poolp, SECItem *dest, unsigned long value, |
| PRBool is_unsigned) |
| { |
| unsigned long copy; |
| unsigned char sign; |
| int len = 0; |
| |
| /* |
| * Determine the length of the encoded value (minimum of 1). |
| */ |
| copy = value; |
| do { |
| len++; |
| sign = (unsigned char)(copy & 0x80); |
| copy >>= 8; |
| } while (copy); |
| |
| /* |
| * If 'value' is non-negative, and the high bit of the last |
| * byte we counted was set, we need to add one to the length so |
| * we put a high-order zero byte in the encoding. |
| */ |
| if (sign && (is_unsigned || (long)value >= 0)) |
| len++; |
| |
| /* |
| * Allocate the item (if necessary) and the data pointer within. |
| */ |
| dest = sec_asn1e_allocate_item(poolp, dest, len); |
| if (dest == NULL) |
| return NULL; |
| |
| /* |
| * Store the value, byte by byte, in the item. |
| */ |
| dest->len = len; |
| while (len) { |
| dest->data[--len] = (unsigned char)value; |
| value >>= 8; |
| } |
| PORT_Assert(value == 0); |
| |
| return dest; |
| } |
| |
| SECItem * |
| SEC_ASN1EncodeInteger(PLArenaPool *poolp, SECItem *dest, long value) |
| { |
| return sec_asn1e_integer(poolp, dest, (unsigned long)value, PR_FALSE); |
| } |
| |
| SECItem * |
| SEC_ASN1EncodeUnsignedInteger(PLArenaPool *poolp, |
| SECItem *dest, unsigned long value) |
| { |
| return sec_asn1e_integer(poolp, dest, value, PR_TRUE); |
| } |