| /* 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/. */ |
| |
| /* |
| * CMS attributes. |
| */ |
| |
| #include "cmslocal.h" |
| |
| #include "secasn1.h" |
| #include "secitem.h" |
| #include "secoid.h" |
| #include "pk11func.h" |
| #include "prtime.h" |
| #include "secerr.h" |
| |
| /* |
| * ------------------------------------------------------------------- |
| * XXX The following Attribute stuff really belongs elsewhere. |
| * The Attribute type is *not* part of CMS but rather X.501. |
| * But for now, since CMS is the only customer of attributes, |
| * we define them here. Once there is a use outside of CMS, |
| * then change the attribute types and functions from internal |
| * to external naming convention, and move them elsewhere! |
| */ |
| |
| /* |
| * NSS_CMSAttribute_Create - create an attribute |
| * |
| * if value is NULL, the attribute won't have a value. It can be added later |
| * with NSS_CMSAttribute_AddValue. |
| */ |
| NSSCMSAttribute * |
| NSS_CMSAttribute_Create(PLArenaPool *poolp, SECOidTag oidtag, SECItem *value, |
| PRBool encoded) |
| { |
| NSSCMSAttribute *attr; |
| SECItem *copiedvalue; |
| void *mark; |
| |
| PORT_Assert(poolp != NULL); |
| |
| mark = PORT_ArenaMark(poolp); |
| |
| attr = (NSSCMSAttribute *)PORT_ArenaZAlloc(poolp, sizeof(NSSCMSAttribute)); |
| if (attr == NULL) |
| goto loser; |
| |
| attr->typeTag = SECOID_FindOIDByTag(oidtag); |
| if (attr->typeTag == NULL) |
| goto loser; |
| |
| if (SECITEM_CopyItem(poolp, &(attr->type), &(attr->typeTag->oid)) != SECSuccess) |
| goto loser; |
| |
| if (value != NULL) { |
| if ((copiedvalue = SECITEM_ArenaDupItem(poolp, value)) == NULL) |
| goto loser; |
| |
| if (NSS_CMSArray_Add(poolp, (void ***)&(attr->values), (void *)copiedvalue) != SECSuccess) |
| goto loser; |
| } |
| |
| attr->encoded = encoded; |
| |
| PORT_ArenaUnmark(poolp, mark); |
| |
| return attr; |
| |
| loser: |
| PORT_Assert(mark != NULL); |
| PORT_ArenaRelease(poolp, mark); |
| return NULL; |
| } |
| |
| /* |
| * NSS_CMSAttribute_AddValue - add another value to an attribute |
| */ |
| SECStatus |
| NSS_CMSAttribute_AddValue(PLArenaPool *poolp, NSSCMSAttribute *attr, SECItem *value) |
| { |
| SECItem *copiedvalue; |
| void *mark; |
| |
| PORT_Assert(poolp != NULL); |
| |
| mark = PORT_ArenaMark(poolp); |
| |
| if (value == NULL) { |
| PORT_SetError(SEC_ERROR_INVALID_ARGS); |
| goto loser; |
| } |
| |
| if ((copiedvalue = SECITEM_ArenaDupItem(poolp, value)) == NULL) |
| goto loser; |
| |
| if (NSS_CMSArray_Add(poolp, (void ***)&(attr->values), (void *)copiedvalue) != SECSuccess) |
| goto loser; |
| |
| PORT_ArenaUnmark(poolp, mark); |
| return SECSuccess; |
| |
| loser: |
| PORT_Assert(mark != NULL); |
| PORT_ArenaRelease(poolp, mark); |
| return SECFailure; |
| } |
| |
| /* |
| * NSS_CMSAttribute_GetType - return the OID tag |
| */ |
| SECOidTag |
| NSS_CMSAttribute_GetType(NSSCMSAttribute *attr) |
| { |
| SECOidData *typetag; |
| |
| typetag = SECOID_FindOID(&(attr->type)); |
| if (typetag == NULL) |
| return SEC_OID_UNKNOWN; |
| |
| return typetag->offset; |
| } |
| |
| /* |
| * NSS_CMSAttribute_GetValue - return the first attribute value |
| * |
| * We do some sanity checking first: |
| * - Multiple values are *not* expected. |
| * - Empty values are *not* expected. |
| */ |
| SECItem * |
| NSS_CMSAttribute_GetValue(NSSCMSAttribute *attr) |
| { |
| SECItem *value; |
| |
| if (attr == NULL) |
| return NULL; |
| |
| value = attr->values[0]; |
| |
| if (value == NULL || value->data == NULL || value->len == 0) |
| return NULL; |
| |
| if (attr->values[1] != NULL) |
| return NULL; |
| |
| return value; |
| } |
| |
| /* |
| * NSS_CMSAttribute_CompareValue - compare the attribute's first value against data |
| */ |
| PRBool |
| NSS_CMSAttribute_CompareValue(NSSCMSAttribute *attr, SECItem *av) |
| { |
| SECItem *value; |
| |
| if (attr == NULL) |
| return PR_FALSE; |
| |
| value = NSS_CMSAttribute_GetValue(attr); |
| |
| return (value != NULL && value->len == av->len && |
| PORT_Memcmp(value->data, av->data, value->len) == 0); |
| } |
| |
| /* |
| * templates and functions for separate ASN.1 encoding of attributes |
| * |
| * used in NSS_CMSAttributeArray_Reorder |
| */ |
| |
| /* |
| * helper function for dynamic template determination of the attribute value |
| */ |
| static const SEC_ASN1Template * |
| cms_attr_choose_attr_value_template(void *src_or_dest, PRBool encoding) |
| { |
| const SEC_ASN1Template *theTemplate; |
| NSSCMSAttribute *attribute; |
| SECOidData *oiddata; |
| PRBool encoded; |
| |
| PORT_Assert(src_or_dest != NULL); |
| if (src_or_dest == NULL) |
| return NULL; |
| |
| attribute = (NSSCMSAttribute *)src_or_dest; |
| |
| if (encoding && (!attribute->values || !attribute->values[0] || |
| attribute->encoded)) { |
| /* we're encoding, and the attribute has no value or the attribute |
| * value is already encoded. */ |
| return SEC_ASN1_GET(SEC_AnyTemplate); |
| } |
| |
| /* get attribute's typeTag */ |
| oiddata = attribute->typeTag; |
| if (oiddata == NULL) { |
| oiddata = SECOID_FindOID(&attribute->type); |
| attribute->typeTag = oiddata; |
| } |
| |
| if (oiddata == NULL) { |
| /* still no OID tag? OID is unknown then. en/decode value as ANY. */ |
| encoded = PR_TRUE; |
| theTemplate = SEC_ASN1_GET(SEC_AnyTemplate); |
| } else { |
| switch (oiddata->offset) { |
| case SEC_OID_PKCS9_SMIME_CAPABILITIES: |
| case SEC_OID_SMIME_ENCRYPTION_KEY_PREFERENCE: |
| /* these guys need to stay DER-encoded */ |
| default: |
| /* same goes for OIDs that are not handled here */ |
| encoded = PR_TRUE; |
| theTemplate = SEC_ASN1_GET(SEC_AnyTemplate); |
| break; |
| /* otherwise choose proper template */ |
| case SEC_OID_PKCS9_EMAIL_ADDRESS: |
| case SEC_OID_RFC1274_MAIL: |
| case SEC_OID_PKCS9_UNSTRUCTURED_NAME: |
| encoded = PR_FALSE; |
| theTemplate = SEC_ASN1_GET(SEC_IA5StringTemplate); |
| break; |
| case SEC_OID_PKCS9_CONTENT_TYPE: |
| encoded = PR_FALSE; |
| theTemplate = SEC_ASN1_GET(SEC_ObjectIDTemplate); |
| break; |
| case SEC_OID_PKCS9_MESSAGE_DIGEST: |
| encoded = PR_FALSE; |
| theTemplate = SEC_ASN1_GET(SEC_OctetStringTemplate); |
| break; |
| case SEC_OID_PKCS9_SIGNING_TIME: |
| encoded = PR_FALSE; |
| theTemplate = SEC_ASN1_GET(CERT_TimeChoiceTemplate); |
| break; |
| /* XXX Want other types here, too */ |
| } |
| } |
| |
| if (encoding) { |
| /* |
| * If we are encoding and we think we have an already-encoded value, |
| * then the code which initialized this attribute should have set |
| * the "encoded" property to true (and we would have returned early, |
| * up above). No devastating error, but that code should be fixed. |
| * (It could indicate that the resulting encoded bytes are wrong.) |
| */ |
| PORT_Assert(!encoded); |
| } else { |
| /* |
| * We are decoding; record whether the resulting value is |
| * still encoded or not. |
| */ |
| attribute->encoded = encoded; |
| } |
| return theTemplate; |
| } |
| |
| static const SEC_ASN1TemplateChooserPtr cms_attr_chooser = cms_attr_choose_attr_value_template; |
| |
| const SEC_ASN1Template nss_cms_attribute_template[] = { |
| { SEC_ASN1_SEQUENCE, |
| 0, NULL, sizeof(NSSCMSAttribute) }, |
| { SEC_ASN1_OBJECT_ID, |
| offsetof(NSSCMSAttribute, type) }, |
| { SEC_ASN1_DYNAMIC | SEC_ASN1_SET_OF, |
| offsetof(NSSCMSAttribute, values), |
| &cms_attr_chooser }, |
| { 0 } |
| }; |
| |
| const SEC_ASN1Template nss_cms_set_of_attribute_template[] = { |
| { SEC_ASN1_SET_OF, 0, nss_cms_attribute_template }, |
| }; |
| |
| /* ============================================================================= |
| * Attribute Array methods |
| */ |
| |
| /* |
| * NSS_CMSAttributeArray_Encode - encode an Attribute array as SET OF Attributes |
| * |
| * If you are wondering why this routine does not reorder the attributes |
| * first, and might be tempted to make it do so, see the comment by the |
| * call to ReorderAttributes in cmsencode.c. (Or, see who else calls this |
| * and think long and hard about the implications of making it always |
| * do the reordering.) |
| */ |
| SECItem * |
| NSS_CMSAttributeArray_Encode(PLArenaPool *poolp, NSSCMSAttribute ***attrs, SECItem *dest) |
| { |
| return SEC_ASN1EncodeItem(poolp, dest, (void *)attrs, nss_cms_set_of_attribute_template); |
| } |
| |
| /* |
| * NSS_CMSAttributeArray_Reorder - sort attribute array by attribute's DER encoding |
| * |
| * make sure that the order of the attributes guarantees valid DER (which must be |
| * in lexigraphically ascending order for a SET OF); if reordering is necessary it |
| * will be done in place (in attrs). |
| */ |
| SECStatus |
| NSS_CMSAttributeArray_Reorder(NSSCMSAttribute **attrs) |
| { |
| return NSS_CMSArray_SortByDER((void **)attrs, nss_cms_attribute_template, NULL); |
| } |
| |
| /* |
| * NSS_CMSAttributeArray_FindAttrByOidTag - look through a set of attributes and |
| * find one that matches the specified object ID. |
| * |
| * If "only" is true, then make sure that there is not more than one attribute |
| * of the same type. Otherwise, just return the first one found. (XXX Does |
| * anybody really want that first-found behavior? It was like that when I found it...) |
| */ |
| NSSCMSAttribute * |
| NSS_CMSAttributeArray_FindAttrByOidTag(NSSCMSAttribute **attrs, SECOidTag oidtag, PRBool only) |
| { |
| SECOidData *oid; |
| NSSCMSAttribute *attr1, *attr2; |
| |
| if (attrs == NULL) |
| return NULL; |
| |
| oid = SECOID_FindOIDByTag(oidtag); |
| if (oid == NULL) |
| return NULL; |
| |
| while ((attr1 = *attrs++) != NULL) { |
| if (attr1->type.len == oid->oid.len && |
| PORT_Memcmp(attr1->type.data, oid->oid.data, oid->oid.len) == 0) |
| break; |
| } |
| |
| if (attr1 == NULL) |
| return NULL; |
| |
| if (!only) |
| return attr1; |
| |
| while ((attr2 = *attrs++) != NULL) { |
| if (attr2->type.len == oid->oid.len && |
| PORT_Memcmp(attr2->type.data, oid->oid.data, oid->oid.len) == 0) |
| break; |
| } |
| |
| if (attr2 != NULL) |
| return NULL; |
| |
| return attr1; |
| } |
| |
| /* |
| * NSS_CMSAttributeArray_AddAttr - add an attribute to an |
| * array of attributes. |
| */ |
| SECStatus |
| NSS_CMSAttributeArray_AddAttr(PLArenaPool *poolp, NSSCMSAttribute ***attrs, |
| NSSCMSAttribute *attr) |
| { |
| NSSCMSAttribute *oattr; |
| void *mark; |
| SECOidTag type; |
| |
| mark = PORT_ArenaMark(poolp); |
| |
| /* find oidtag of attr */ |
| type = NSS_CMSAttribute_GetType(attr); |
| |
| /* see if we have one already */ |
| oattr = NSS_CMSAttributeArray_FindAttrByOidTag(*attrs, type, PR_FALSE); |
| PORT_Assert(oattr == NULL); |
| if (oattr != NULL) |
| goto loser; /* XXX or would it be better to replace it? */ |
| |
| /* no, shove it in */ |
| if (NSS_CMSArray_Add(poolp, (void ***)attrs, (void *)attr) != SECSuccess) |
| goto loser; |
| |
| PORT_ArenaUnmark(poolp, mark); |
| return SECSuccess; |
| |
| loser: |
| PORT_ArenaRelease(poolp, mark); |
| return SECFailure; |
| } |
| |
| /* |
| * NSS_CMSAttributeArray_SetAttr - set an attribute's value in a set of attributes |
| */ |
| SECStatus |
| NSS_CMSAttributeArray_SetAttr(PLArenaPool *poolp, NSSCMSAttribute ***attrs, |
| SECOidTag type, SECItem *value, PRBool encoded) |
| { |
| NSSCMSAttribute *attr; |
| void *mark; |
| |
| mark = PORT_ArenaMark(poolp); |
| |
| /* see if we have one already */ |
| attr = NSS_CMSAttributeArray_FindAttrByOidTag(*attrs, type, PR_FALSE); |
| if (attr == NULL) { |
| /* not found? create one! */ |
| attr = NSS_CMSAttribute_Create(poolp, type, value, encoded); |
| if (attr == NULL) |
| goto loser; |
| /* and add it to the list */ |
| if (NSS_CMSArray_Add(poolp, (void ***)attrs, (void *)attr) != SECSuccess) |
| goto loser; |
| } else { |
| /* found, shove it in */ |
| /* XXX we need a decent memory model @#$#$!#!!! */ |
| attr->values[0] = value; |
| attr->encoded = encoded; |
| } |
| |
| PORT_ArenaUnmark(poolp, mark); |
| return SECSuccess; |
| |
| loser: |
| PORT_ArenaRelease(poolp, mark); |
| return SECFailure; |
| } |