/* 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; if (theTemplate == NULL) { cx->status = encodeError; return NULL; } 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); }