libsecurity_smime/security_smime/cmsasn1.c

   1 /*
   2  * The contents of this file are subject to the Mozilla Public
   3  * License Version 1.1 (the "License"); you may not use this file
   4  * except in compliance with the License. You may obtain a copy of
   5  * the License at http://www.mozilla.org/MPL/
   6  *
   7  * Software distributed under the License is distributed on an "AS
   8  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
   9  * implied. See the License for the specific language governing
  10  * rights and limitations under the License.
  11  *
  12  * The Original Code is the Netscape security libraries.
  13  *
  14  * The Initial Developer of the Original Code is Netscape
  15  * Communications Corporation.  Portions created by Netscape are
  16  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17  * Rights Reserved.
  18  *
  19  * Contributor(s):
  20  *
  21  * Alternatively, the contents of this file may be used under the
  22  * terms of the GNU General Public License Version 2 or later (the
  23  * "GPL"), in which case the provisions of the GPL are applicable
  24  * instead of those above.  If you wish to allow use of your
  25  * version of this file only under the terms of the GPL and not to
  26  * allow others to use your version of this file under the MPL,
  27  * indicate your decision by deleting the provisions above and
  28  * replace them with the notice and other provisions required by
  29  * the GPL.  If you do not delete the provisions above, a recipient
  30  * may use your version of this file under either the MPL or the
  31  * GPL.
  32  */
  33
  34 /*
  35  * CMS ASN.1 templates
  36  */
  37
  38 #include <Security/SecCmsContentInfo.h>
  39
  40 #include "cmslocal.h"
  41
  42 #include "secoid.h"
  43 #include <security_asn1/secasn1.h>
  44 #include <security_asn1/secerr.h>
  45 #include <security_asn1/secport.h>
  46
  47 extern const SecAsn1Template nss_cms_set_of_attribute_template[];
  48
  49 //SEC_ASN1_MKSUB(CERT_IssuerAndSNTemplate)
  50 //SEC_ASN1_MKSUB(CERT_SetOfSignedCrlTemplate)
  51 SEC_ASN1_MKSUB(SECOID_AlgorithmIDTemplate)
  52 SEC_ASN1_MKSUB(kSecAsn1BitStringTemplate)
  53 SEC_ASN1_MKSUB(kSecAsn1OctetStringTemplate)
  54 SEC_ASN1_MKSUB(kSecAsn1PointerToOctetStringTemplate)
  55 SEC_ASN1_MKSUB(kSecAsn1SetOfAnyTemplate)
  56
  57 /* -----------------------------------------------------------------------------
  58  * MESSAGE
  59  * (uses SecCmsContentInfo)
  60  */
  61
  62 /* forward declaration */
  63 static const SecAsn1Template *
  64 nss_cms_choose_content_template(void *src_or_dest, Boolean encoding, const char *buf, void *dest);
  65
  66 static const SecAsn1TemplateChooserPtr nss_cms_chooser
  67         = nss_cms_choose_content_template;
  68
  69 const SecAsn1Template SecCmsMessageTemplate[] = {
  70     { SEC_ASN1_SEQUENCE | SEC_ASN1_MAY_STREAM,
  71           0, NULL, sizeof(SecCmsMessage) },
  72     { SEC_ASN1_OBJECT_ID,
  73           offsetof(SecCmsMessage,contentInfo.contentType) },
  74     { SEC_ASN1_OPTIONAL | SEC_ASN1_DYNAMIC | SEC_ASN1_MAY_STREAM
  75      | SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 0,
  76           offsetof(SecCmsMessage,contentInfo.content),
  77           &nss_cms_chooser },
  78     { 0 }
  79 };
  80
  81 #if 0
  82 static const SecAsn1Template NSS_PointerToCMSMessageTemplate[] = {
  83     { SEC_ASN1_POINTER, 0, SecCmsMessageTemplate }
  84 };
  85 #endif
  86
  87 /* -----------------------------------------------------------------------------
  88  * ENCAPSULATED & ENCRYPTED CONTENTINFO
  89  * (both use a SecCmsContentInfo)
  90  */
  91 static const SecAsn1Template SecCmsEncapsulatedContentInfoTemplate[] = {
  92     { SEC_ASN1_SEQUENCE | SEC_ASN1_MAY_STREAM,
  93           0, NULL, sizeof(SecCmsContentInfo) },
  94     { SEC_ASN1_OBJECT_ID,
  95           offsetof(SecCmsContentInfo,contentType) },
  96     { SEC_ASN1_OPTIONAL | SEC_ASN1_EXPLICIT | SEC_ASN1_MAY_STREAM |
  97         SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 0,
  98           offsetof(SecCmsContentInfo,rawContent),
  99           SEC_ASN1_SUB(kSecAsn1PointerToOctetStringTemplate) },
 100     { 0 }
 101 };
 102
 103 static const SecAsn1Template SecCmsEncryptedContentInfoTemplate[] = {
 104     { SEC_ASN1_SEQUENCE | SEC_ASN1_MAY_STREAM,
 105           0, NULL, sizeof(SecCmsContentInfo) },
 106     { SEC_ASN1_OBJECT_ID,
 107           offsetof(SecCmsContentInfo,contentType) },
 108     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 109           offsetof(SecCmsContentInfo,contentEncAlg),
 110           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 111     { SEC_ASN1_OPTIONAL | SEC_ASN1_POINTER | SEC_ASN1_MAY_STREAM |
 112       SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 0,
 113           offsetof(SecCmsContentInfo,rawContent),
 114           SEC_ASN1_SUB(kSecAsn1OctetStringTemplate) },
 115     { 0 }
 116 };
 117
 118 /* -----------------------------------------------------------------------------
 119  * SIGNED DATA
 120  */
 121
 122 const SecAsn1Template SecCmsSignerInfoTemplate[];
 123
 124
 125 const SecAsn1Template SecCmsSignedDataTemplate[] = {
 126     { SEC_ASN1_SEQUENCE | SEC_ASN1_MAY_STREAM,
 127           0, NULL, sizeof(SecCmsSignedData) },
 128     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 129           offsetof(SecCmsSignedData,version) },
 130     { SEC_ASN1_SET_OF | SEC_ASN1_XTRN,
 131           offsetof(SecCmsSignedData,digestAlgorithms),
 132           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 133     { SEC_ASN1_INLINE,
 134           offsetof(SecCmsSignedData,contentInfo),
 135           SecCmsEncapsulatedContentInfoTemplate },
 136     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC |
 137       SEC_ASN1_XTRN | 0,
 138           offsetof(SecCmsSignedData,rawCerts),
 139           SEC_ASN1_SUB(kSecAsn1SetOfAnyTemplate) },
 140     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC |
 141       SEC_ASN1_XTRN | 1,
 142           offsetof(SecCmsSignedData,rawCrls),
 143           SEC_ASN1_SUB(kSecAsn1SetOfAnyTemplate) },
 144     { SEC_ASN1_SET_OF,
 145           offsetof(SecCmsSignedData,signerInfos),
 146           SecCmsSignerInfoTemplate },
 147     { 0 }
 148 };
 149
 150 const SecAsn1Template NSS_PointerToCMSSignedDataTemplate[] = {
 151     { SEC_ASN1_POINTER, 0, SecCmsSignedDataTemplate }
 152 };
 153
 154 /* -----------------------------------------------------------------------------
 155  * signeridentifier
 156  */
 157
 158 static const SecAsn1Template SecCmsSignerIdentifierTemplate[] = {
 159     { SEC_ASN1_CHOICE,
 160           offsetof(SecCmsSignerIdentifier,identifierType), NULL,
 161           sizeof(SecCmsSignerIdentifier) },
 162     { SEC_ASN1_POINTER | SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 0,
 163           offsetof(SecCmsSignerIdentifier,id.subjectKeyID),
 164           SEC_ASN1_SUB(kSecAsn1OctetStringTemplate) ,
 165           SecCmsRecipientIDSubjectKeyID },
 166     { SEC_ASN1_POINTER | SEC_ASN1_XTRN,
 167           offsetof(SecCmsSignerIdentifier,id.issuerAndSN),
 168           SEC_ASN1_SUB(SecCmsIssuerAndSNTemplate),
 169           SecCmsRecipientIDIssuerSN },
 170     { 0 }
 171 };
 172
 173 /* -----------------------------------------------------------------------------
 174  * signerinfo
 175  */
 176
 177 const SecAsn1Template SecCmsSignerInfoTemplate[] = {
 178     { SEC_ASN1_SEQUENCE,
 179           0, NULL, sizeof(SecCmsSignerInfo) },
 180     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 181           offsetof(SecCmsSignerInfo,version) },
 182     { SEC_ASN1_INLINE,
 183           offsetof(SecCmsSignerInfo,signerIdentifier),
 184           SecCmsSignerIdentifierTemplate },
 185     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 186           offsetof(SecCmsSignerInfo,digestAlg),
 187           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 188     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 0,
 189           offsetof(SecCmsSignerInfo,authAttr),
 190           nss_cms_set_of_attribute_template },
 191     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 192           offsetof(SecCmsSignerInfo,digestEncAlg),
 193           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 194     { SEC_ASN1_OCTET_STRING,
 195           offsetof(SecCmsSignerInfo,encDigest) },
 196     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 1,
 197           offsetof(SecCmsSignerInfo,unAuthAttr),
 198           nss_cms_set_of_attribute_template },
 199     { 0 }
 200 };
 201
 202 /* -----------------------------------------------------------------------------
 203  * ENVELOPED DATA
 204  */
 205
 206 static const SecAsn1Template SecCmsOriginatorInfoTemplate[] = {
 207     { SEC_ASN1_SEQUENCE,
 208           0, NULL, sizeof(SecCmsOriginatorInfo) },
 209     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC |
 210       SEC_ASN1_XTRN | 0,
 211           offsetof(SecCmsOriginatorInfo,rawCerts),
 212           SEC_ASN1_SUB(kSecAsn1SetOfAnyTemplate) },
 213     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC |
 214       SEC_ASN1_XTRN | 1,
 215           offsetof(SecCmsOriginatorInfo,rawCrls),
 216           SEC_ASN1_SUB(kSecAsn1SetOfAnyTemplate) },
 217     { 0 }
 218 };
 219
 220 const SecAsn1Template SecCmsRecipientInfoTemplate[];
 221
 222 const SecAsn1Template SecCmsEnvelopedDataTemplate[] = {
 223     { SEC_ASN1_SEQUENCE | SEC_ASN1_MAY_STREAM,
 224           0, NULL, sizeof(SecCmsEnvelopedData) },
 225     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 226           offsetof(SecCmsEnvelopedData,version) },
 227     { SEC_ASN1_OPTIONAL | SEC_ASN1_POINTER | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 0,
 228           offsetof(SecCmsEnvelopedData,originatorInfo),
 229           SecCmsOriginatorInfoTemplate },
 230     { SEC_ASN1_SET_OF,
 231           offsetof(SecCmsEnvelopedData,recipientInfos),
 232           SecCmsRecipientInfoTemplate },
 233     { SEC_ASN1_INLINE,
 234           offsetof(SecCmsEnvelopedData,contentInfo),
 235           SecCmsEncryptedContentInfoTemplate },
 236     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 1,
 237           offsetof(SecCmsEnvelopedData,unprotectedAttr),
 238           nss_cms_set_of_attribute_template },
 239     { 0 }
 240 };
 241
 242 const SecAsn1Template NSS_PointerToCMSEnvelopedDataTemplate[] = {
 243     { SEC_ASN1_POINTER, 0, SecCmsEnvelopedDataTemplate }
 244 };
 245
 246 /* here come the 15 gazillion templates for all the v3 varieties of RecipientInfo */
 247
 248 /* -----------------------------------------------------------------------------
 249  * key transport recipient info
 250  */
 251
 252 static const SecAsn1Template SecCmsRecipientIdentifierTemplate[] = {
 253     { SEC_ASN1_CHOICE,
 254           offsetof(SecCmsRecipientIdentifier,identifierType), NULL,
 255           sizeof(SecCmsRecipientIdentifier) },
 256     { SEC_ASN1_POINTER | SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 0,
 257           offsetof(SecCmsRecipientIdentifier,id.subjectKeyID),
 258           SEC_ASN1_SUB(kSecAsn1OctetStringTemplate) ,
 259           SecCmsRecipientIDSubjectKeyID },
 260     { SEC_ASN1_POINTER | SEC_ASN1_XTRN,
 261           offsetof(SecCmsRecipientIdentifier,id.issuerAndSN),
 262           SEC_ASN1_SUB(SecCmsIssuerAndSNTemplate),
 263           SecCmsRecipientIDIssuerSN },
 264     { 0 }
 265 };
 266
 267
 268 static const SecAsn1Template SecCmsKeyTransRecipientInfoTemplate[] = {
 269     { SEC_ASN1_SEQUENCE,
 270           0, NULL, sizeof(SecCmsKeyTransRecipientInfo) },
 271     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 272           offsetof(SecCmsKeyTransRecipientInfo,version) },
 273     { SEC_ASN1_INLINE,
 274           offsetof(SecCmsKeyTransRecipientInfo,recipientIdentifier),
 275           SecCmsRecipientIdentifierTemplate },
 276     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 277           offsetof(SecCmsKeyTransRecipientInfo,keyEncAlg),
 278           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 279     { SEC_ASN1_OCTET_STRING,
 280           offsetof(SecCmsKeyTransRecipientInfo,encKey) },
 281     { 0 }
 282 };
 283
 284 /* -----------------------------------------------------------------------------
 285  * key agreement recipient info
 286  */
 287
 288 static const SecAsn1Template SecCmsOriginatorPublicKeyTemplate[] = {
 289     { SEC_ASN1_SEQUENCE,
 290           0, NULL, sizeof(SecCmsOriginatorPublicKey) },
 291     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 292           offsetof(SecCmsOriginatorPublicKey,algorithmIdentifier),
 293           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 294     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 295           offsetof(SecCmsOriginatorPublicKey,publicKey),
 296           SEC_ASN1_SUB(kSecAsn1BitStringTemplate) },
 297     { 0 }
 298 };
 299
 300
 301 static const SecAsn1Template SecCmsOriginatorIdentifierOrKeyTemplate[] = {
 302     { SEC_ASN1_CHOICE,
 303           offsetof(SecCmsOriginatorIdentifierOrKey,identifierType), NULL,
 304           sizeof(SecCmsOriginatorIdentifierOrKey) },
 305     { SEC_ASN1_POINTER | SEC_ASN1_XTRN,
 306           offsetof(SecCmsOriginatorIdentifierOrKey,id.issuerAndSN),
 307           SEC_ASN1_SUB(SecCmsIssuerAndSNTemplate),
 308           SecCmsOriginatorIDOrKeyIssuerSN },
 309     { SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC |
 310       SEC_ASN1_XTRN | 1,
 311           offsetof(SecCmsOriginatorIdentifierOrKey,id.subjectKeyID),
 312           SEC_ASN1_SUB(kSecAsn1PointerToOctetStringTemplate) ,
 313           SecCmsOriginatorIDOrKeySubjectKeyID },
 314     { SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 2,
 315           offsetof(SecCmsOriginatorIdentifierOrKey,id.originatorPublicKey),
 316           SecCmsOriginatorPublicKeyTemplate,
 317           SecCmsOriginatorIDOrKeyOriginatorPublicKey },
 318     { 0 }
 319 };
 320
 321 const SecAsn1Template SecCmsRecipientKeyIdentifierTemplate[] = {
 322     { SEC_ASN1_SEQUENCE,
 323           0, NULL, sizeof(SecCmsRecipientKeyIdentifier) },
 324     { SEC_ASN1_OCTET_STRING,
 325           offsetof(SecCmsRecipientKeyIdentifier,subjectKeyIdentifier) },
 326     { SEC_ASN1_OPTIONAL | SEC_ASN1_OCTET_STRING,
 327           offsetof(SecCmsRecipientKeyIdentifier,date) },
 328     { SEC_ASN1_OPTIONAL | SEC_ASN1_OCTET_STRING,
 329           offsetof(SecCmsRecipientKeyIdentifier,other) },
 330     { 0 }
 331 };
 332
 333
 334 static const SecAsn1Template SecCmsKeyAgreeRecipientIdentifierTemplate[] = {
 335     { SEC_ASN1_CHOICE,
 336           offsetof(SecCmsKeyAgreeRecipientIdentifier,identifierType), NULL,
 337           sizeof(SecCmsKeyAgreeRecipientIdentifier) },
 338     { SEC_ASN1_POINTER | SEC_ASN1_XTRN,
 339           offsetof(SecCmsKeyAgreeRecipientIdentifier,id.issuerAndSN),
 340           SEC_ASN1_SUB(SecCmsIssuerAndSNTemplate),
 341           SecCmsKeyAgreeRecipientIDIssuerSN },
 342     { SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 0,
 343           offsetof(SecCmsKeyAgreeRecipientIdentifier,id.recipientKeyIdentifier),
 344           SecCmsRecipientKeyIdentifierTemplate,
 345           SecCmsKeyAgreeRecipientIDRKeyID },
 346     { 0 }
 347 };
 348
 349 static const SecAsn1Template SecCmsRecipientEncryptedKeyTemplate[] = {
 350     { SEC_ASN1_SEQUENCE,
 351           0, NULL, sizeof(SecCmsRecipientEncryptedKey) },
 352     { SEC_ASN1_INLINE,
 353           offsetof(SecCmsRecipientEncryptedKey,recipientIdentifier),
 354           SecCmsKeyAgreeRecipientIdentifierTemplate },
 355     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 356           offsetof(SecCmsRecipientEncryptedKey,encKey),
 357           SEC_ASN1_SUB(kSecAsn1BitStringTemplate) },
 358     { 0 }
 359 };
 360
 361 static const SecAsn1Template SecCmsKeyAgreeRecipientInfoTemplate[] = {
 362     { SEC_ASN1_SEQUENCE,
 363           0, NULL, sizeof(SecCmsKeyAgreeRecipientInfo) },
 364     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 365           offsetof(SecCmsKeyAgreeRecipientInfo,version) },
 366     { SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 0,
 367           offsetof(SecCmsKeyAgreeRecipientInfo,originatorIdentifierOrKey),
 368           SecCmsOriginatorIdentifierOrKeyTemplate },
 369     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_EXPLICIT |
 370       SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 1,
 371           offsetof(SecCmsKeyAgreeRecipientInfo,ukm),
 372           SEC_ASN1_SUB(kSecAsn1OctetStringTemplate) },
 373     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 374           offsetof(SecCmsKeyAgreeRecipientInfo,keyEncAlg),
 375           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 376     { SEC_ASN1_SEQUENCE_OF,
 377           offsetof(SecCmsKeyAgreeRecipientInfo,recipientEncryptedKeys),
 378           SecCmsRecipientEncryptedKeyTemplate },
 379     { 0 }
 380 };
 381
 382 /* -----------------------------------------------------------------------------
 383  * KEK recipient info
 384  */
 385
 386 static const SecAsn1Template SecCmsKEKIdentifierTemplate[] = {
 387     { SEC_ASN1_SEQUENCE,
 388           0, NULL, sizeof(SecCmsKEKIdentifier) },
 389     { SEC_ASN1_OCTET_STRING,
 390           offsetof(SecCmsKEKIdentifier,keyIdentifier) },
 391     { SEC_ASN1_OPTIONAL | SEC_ASN1_OCTET_STRING,
 392           offsetof(SecCmsKEKIdentifier,date) },
 393     { SEC_ASN1_OPTIONAL | SEC_ASN1_OCTET_STRING,
 394           offsetof(SecCmsKEKIdentifier,other) },
 395     { 0 }
 396 };
 397
 398 static const SecAsn1Template SecCmsKEKRecipientInfoTemplate[] = {
 399     { SEC_ASN1_SEQUENCE,
 400           0, NULL, sizeof(SecCmsKEKRecipientInfo) },
 401     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 402           offsetof(SecCmsKEKRecipientInfo,version) },
 403     { SEC_ASN1_INLINE,
 404           offsetof(SecCmsKEKRecipientInfo,kekIdentifier),
 405           SecCmsKEKIdentifierTemplate },
 406     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 407           offsetof(SecCmsKEKRecipientInfo,keyEncAlg),
 408           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 409     { SEC_ASN1_OCTET_STRING,
 410           offsetof(SecCmsKEKRecipientInfo,encKey) },
 411     { 0 }
 412 };
 413
 414 /* -----------------------------------------------------------------------------
 415  * recipient info
 416  */
 417 const SecAsn1Template SecCmsRecipientInfoTemplate[] = {
 418     { SEC_ASN1_CHOICE,
 419           offsetof(SecCmsRecipientInfo,recipientInfoType), NULL,
 420           sizeof(SecCmsRecipientInfo) },
 421     { SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 1,
 422           offsetof(SecCmsRecipientInfo,ri.keyAgreeRecipientInfo),
 423           SecCmsKeyAgreeRecipientInfoTemplate,
 424           SecCmsRecipientInfoIDKeyAgree },
 425     { SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 2,
 426           offsetof(SecCmsRecipientInfo,ri.kekRecipientInfo),
 427           SecCmsKEKRecipientInfoTemplate,
 428           SecCmsRecipientInfoIDKEK },
 429     { SEC_ASN1_INLINE,
 430           offsetof(SecCmsRecipientInfo,ri.keyTransRecipientInfo),
 431           SecCmsKeyTransRecipientInfoTemplate,
 432           SecCmsRecipientInfoIDKeyTrans },
 433     { 0 }
 434 };
 435
 436 /* -----------------------------------------------------------------------------
 437  *
 438  */
 439
 440 const SecAsn1Template SecCmsDigestedDataTemplate[] = {
 441     { SEC_ASN1_SEQUENCE | SEC_ASN1_MAY_STREAM,
 442           0, NULL, sizeof(SecCmsDigestedData) },
 443     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 444           offsetof(SecCmsDigestedData,version) },
 445     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
 446           offsetof(SecCmsDigestedData,digestAlg),
 447           SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
 448     { SEC_ASN1_INLINE,
 449           offsetof(SecCmsDigestedData,contentInfo),
 450           SecCmsEncapsulatedContentInfoTemplate },
 451     { SEC_ASN1_OCTET_STRING,
 452           offsetof(SecCmsDigestedData,digest) },
 453     { 0 }
 454 };
 455
 456 const SecAsn1Template NSS_PointerToCMSDigestedDataTemplate[] = {
 457     { SEC_ASN1_POINTER, 0, SecCmsDigestedDataTemplate }
 458 };
 459
 460 const SecAsn1Template SecCmsEncryptedDataTemplate[] = {
 461     { SEC_ASN1_SEQUENCE | SEC_ASN1_MAY_STREAM,
 462           0, NULL, sizeof(SecCmsEncryptedData) },
 463     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 464           offsetof(SecCmsEncryptedData,version) },
 465     { SEC_ASN1_INLINE,
 466           offsetof(SecCmsEncryptedData,contentInfo),
 467           SecCmsEncryptedContentInfoTemplate },
 468     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 1,
 469           offsetof(SecCmsEncryptedData,unprotectedAttr),
 470           nss_cms_set_of_attribute_template },
 471     { 0 }
 472 };
 473
 474 const SecAsn1Template NSS_PointerToCMSEncryptedDataTemplate[] = {
 475     { SEC_ASN1_POINTER, 0, SecCmsEncryptedDataTemplate }
 476 };
 477
 478 /* -----------------------------------------------------------------------------
 479  * SetOfSignedCrlTemplate
 480  */
 481 const SecAsn1Template SecCmsIssuerAndSNTemplate[] = {
 482     { SEC_ASN1_SEQUENCE,
 483           0, NULL, sizeof(SecCmsIssuerAndSN) },
 484 #if 1 // @@@ Switch to using NSS_NameTemplate
 485     { SEC_ASN1_ANY,
 486           offsetof(SecCmsIssuerAndSN,derIssuer) },
 487 #else
 488     { SEC_ASN1_INLINE,
 489           offsetof(SecCmsIssuerAndSN,issuer),
 490           NSS_NameTemplate },
 491 #endif
 492     { SEC_ASN1_INTEGER | SEC_ASN1_SIGNED_INT,
 493           offsetof(SecCmsIssuerAndSN,serialNumber) },
 494     { 0 }
 495 };
 496
 497
 498 /* -----------------------------------------------------------------------------
 499  * FORTEZZA KEA
 500  */
 501 const SecAsn1Template NSS_SMIMEKEAParamTemplateSkipjack[] = {
 502         { SEC_ASN1_SEQUENCE,
 503           0, NULL, sizeof(SecCmsSMIMEKEAParameters) },
 504         { SEC_ASN1_OCTET_STRING /* | SEC_ASN1_OPTIONAL */,
 505           offsetof(SecCmsSMIMEKEAParameters,originatorKEAKey) },
 506         { SEC_ASN1_OCTET_STRING,
 507           offsetof(SecCmsSMIMEKEAParameters,originatorRA) },
 508         { 0 }
 509 };
 510
 511 const SecAsn1Template NSS_SMIMEKEAParamTemplateNoSkipjack[] = {
 512         { SEC_ASN1_SEQUENCE,
 513           0, NULL, sizeof(SecCmsSMIMEKEAParameters) },
 514         { SEC_ASN1_OCTET_STRING /* | SEC_ASN1_OPTIONAL */,
 515           offsetof(SecCmsSMIMEKEAParameters,originatorKEAKey) },
 516         { SEC_ASN1_OCTET_STRING,
 517           offsetof(SecCmsSMIMEKEAParameters,originatorRA) },
 518         { SEC_ASN1_OCTET_STRING  | SEC_ASN1_OPTIONAL ,
 519           offsetof(SecCmsSMIMEKEAParameters,nonSkipjackIV) },
 520         { 0 }
 521 };
 522
 523 const SecAsn1Template NSS_SMIMEKEAParamTemplateAllParams[] = {
 524         { SEC_ASN1_SEQUENCE,
 525           0, NULL, sizeof(SecCmsSMIMEKEAParameters) },
 526         { SEC_ASN1_OCTET_STRING /* | SEC_ASN1_OPTIONAL */,
 527           offsetof(SecCmsSMIMEKEAParameters,originatorKEAKey) },
 528         { SEC_ASN1_OCTET_STRING,
 529           offsetof(SecCmsSMIMEKEAParameters,originatorRA) },
 530         { SEC_ASN1_OCTET_STRING  | SEC_ASN1_OPTIONAL ,
 531           offsetof(SecCmsSMIMEKEAParameters,nonSkipjackIV) },
 532         { SEC_ASN1_OCTET_STRING  | SEC_ASN1_OPTIONAL ,
 533           offsetof(SecCmsSMIMEKEAParameters,bulkKeySize) },
 534         { 0 }
 535 };
 536
 537 const SecAsn1Template *
 538 nss_cms_get_kea_template(SecCmsKEATemplateSelector whichTemplate)
 539 {
 540         const SecAsn1Template *returnVal = NULL;
 541
 542         switch(whichTemplate)
 543         {
 544         case SecCmsKEAUsesNonSkipjack:
 545                 returnVal = NSS_SMIMEKEAParamTemplateNoSkipjack;
 546                 break;
 547         case SecCmsKEAUsesSkipjack:
 548                 returnVal = NSS_SMIMEKEAParamTemplateSkipjack;
 549                 break;
 550         case SecCmsKEAUsesNonSkipjackWithPaddedEncKey:
 551         default:
 552                 returnVal = NSS_SMIMEKEAParamTemplateAllParams;
 553                 break;
 554         }
 555         return returnVal;
 556 }
 557
 558 /* -----------------------------------------------------------------------------
 559  *
 560  */
 561 static const SecAsn1Template *
 562 nss_cms_choose_content_template(void *src_or_dest, Boolean encoding, const char *buf, void *dest)
 563 {
 564     const SecAsn1Template *theTemplate;
 565     SecCmsContentInfoRef cinfo;
 566
 567     PORT_Assert (src_or_dest != NULL);
 568     if (src_or_dest == NULL)
 569         return NULL;
 570
 571     cinfo = (SecCmsContentInfoRef)src_or_dest;
 572     switch (SecCmsContentInfoGetContentTypeTag(cinfo)) {
 573     default:
 574         theTemplate = SEC_ASN1_GET(kSecAsn1PointerToAnyTemplate);
 575         break;
 576     case SEC_OID_PKCS7_DATA:
 577         theTemplate = SEC_ASN1_GET(kSecAsn1PointerToOctetStringTemplate);
 578         break;
 579     case SEC_OID_PKCS7_SIGNED_DATA:
 580         theTemplate = NSS_PointerToCMSSignedDataTemplate;
 581         break;
 582     case SEC_OID_PKCS7_ENVELOPED_DATA:
 583         theTemplate = NSS_PointerToCMSEnvelopedDataTemplate;
 584         break;
 585     case SEC_OID_PKCS7_DIGESTED_DATA:
 586         theTemplate = NSS_PointerToCMSDigestedDataTemplate;
 587         break;
 588     case SEC_OID_PKCS7_ENCRYPTED_DATA:
 589         theTemplate = NSS_PointerToCMSEncryptedDataTemplate;
 590         break;
 591     }
 592     return theTemplate;
 593 }