1  /*
   2   * Copyright (c) 2006-2013 Apple Inc. All Rights Reserved.
   3   * 
   4   * @APPLE_LICENSE_HEADER_START@
   5   * 
   6   * This file contains Original Code and/or Modifications of Original Code
   7   * as defined in and that are subject to the Apple Public Source License
   8   * Version 2.0 (the 'License'). You may not use this file except in
   9   * compliance with the License. Please obtain a copy of the License at
  10   * http://www.opensource.apple.com/apsl/ and read it before using this
  11   * file.
  12   * 
  13   * The Original Code and all software distributed under the License are
  14   * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15   * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16   * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17   * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18   * Please see the License for the specific language governing rights and
  19   * limitations under the License.
  20   * 
  21   * @APPLE_LICENSE_HEADER_END@
  22   */
  23  
  24  /*
  25   * CMSEncoder.cpp - encode, sign, and/or encrypt CMS messages. 
  26   */
  27   
  28  #include <Security/CMSEncoder.h>
  29  #include <Security/CMSPrivate.h>
  30  #include "CMSUtils.h"
  31  #include <Security/SecBase.h>
  32  #include <Security/SecCmsEncoder.h>
  33  #include <Security/SecCmsEnvelopedData.h>
  34  #include <Security/SecCmsMessage.h>
  35  #include <Security/SecCmsRecipientInfo.h>
  36  #include <Security/SecCmsSignedData.h>
  37  #include <Security/SecCmsSignerInfo.h>
  38  #include <Security/SecCmsContentInfo.h>
  39  #include <Security/SecCertificate.h>
  40  #include <Security/SecIdentity.h>
  41  #include <Security/SecKeychain.h>
  42  #include <Security/SecKeychainItem.h>
  43  #include <Security/SecSMIME.h>
  44  #include <Security/oidsattr.h>
  45  #include <Security/SecAsn1Coder.h>
  46  #include <Security/SecAsn1Types.h>
  47  #include <Security/SecAsn1Templates.h>
  48  #include <CoreFoundation/CFRuntime.h>
  49  #include <pthread.h>
  50  #include <utilities/SecCFRelease.h>
  51  
  52  #include <security_smime/tsaSupport.h>
  53  #include <security_smime/cmspriv.h>
  54  
  55  #pragma mark --- Private types and definitions ---
  56  
  57  /*
  58   * Encoder state.
  59   */
  60  typedef enum {
  61  	ES_Init,		/* between CMSEncoderCreate and earlier of CMSEncoderUpdateContent
  62  					 *   and CMSEncodeGetCmsMessage */
  63  	ES_Msg,			/* created cmsMsg in CMSEncodeGetCmsMessage, but no encoder yet */
  64  	ES_Updating,	/* between first CMSEncoderUpdateContent and CMSEncoderCopyEncodedContent */
  65  	ES_Final		/* CMSEncoderCopyEncodedContent has been called */
  66  } CMSEncoderState;
  67  
  68  /* 
  69   * High-level operation: what are we doing? 
  70   */
  71  typedef enum {
  72  	EO_Sign,
  73  	EO_Encrypt,
  74  	EO_SignEncrypt
  75  } CMSEncoderOp;
  76  
  77  /*
  78   * Caller's CMSEncoderRef points to one of these.
  79   */
  80  struct _CMSEncoder {
  81  	CFRuntimeBase		base;
  82  	CMSEncoderState		encState;
  83  	CMSEncoderOp		op;
  84  	Boolean				detachedContent;
  85  	CSSM_OID			eContentType;
  86  	CFMutableArrayRef	signers;
  87  	CFMutableArrayRef	recipients;
  88  	CFMutableArrayRef	otherCerts;
  89  	CMSSignedAttributes	signedAttributes;
  90  	CFAbsoluteTime		signingTime;
  91  	SecCmsMessageRef	cmsMsg;
  92  	SecArenaPoolRef		arena;					/* the encoder's arena */
  93  	SecCmsEncoderRef	encoder;
  94  	CSSM_DATA			encoderOut;				/* output goes here... */
  95  	bool				customCoder;			/* unless this is set by 
  96  												 *    CMSEncoderSetEncoder */
  97  	SECOidTag		digestalgtag;
  98  
  99  	CMSCertificateChainMode chainMode;
 100      CFDataRef           hashAgilityAttrValue;
 101      CFDictionaryRef     hashAgilityV2AttrValues;
 102      CFAbsoluteTime      expirationTime;
 103  };
 104  
 105  static void cmsEncoderInit(CFTypeRef enc);
 106  static void cmsEncoderFinalize(CFTypeRef enc);
 107      
 108  static CFRuntimeClass cmsEncoderRuntimeClass = 
 109  {
 110  	0,			/* version */
 111  	"CMSEncoder",
 112  	cmsEncoderInit,
 113  	NULL,		/* copy */
 114  	cmsEncoderFinalize,
 115  	NULL,		/* equal - just use pointer equality */
 116  	NULL,		/* hash, ditto */
 117  	NULL,		/* copyFormattingDesc */
 118  	NULL		/* copyDebugDesc */
 119  };
 120  
 121  void
 122  CmsMessageSetTSACallback(CMSEncoderRef cmsEncoder, SecCmsTSACallback tsaCallback);
 123  
 124  #pragma mark --- Private routines ---
 125  
 126  /*
 127   * Decode a CFStringRef representation of an integer
 128   */
 129  static int cfStringToNumber(
 130  	CFStringRef inStr)
 131  {
 132  	int max = 32;
 133  	char buf[max];
 134  	if (!inStr || !CFStringGetCString(inStr, buf, max-1, kCFStringEncodingASCII))
 135  		return -1;
 136  	return atoi(buf);
 137  }
 138  	
 139  /*
 140   * Encode an integer component of an OID, return resulting number of bytes;
 141   * actual bytes are mallocd and returned in *encodeArray.
 142   */
 143  static unsigned encodeNumber(
 144  	int num,
 145  	unsigned char **encodeArray)		// mallocd and RETURNED 
 146  {
 147  	unsigned char *result;
 148  	unsigned dex;
 149  	unsigned numDigits = 0;
 150  	unsigned scratch;
 151  	
 152  	/* trival case - 0 maps to 0 */
 153  	if(num == 0) {
 154  		*encodeArray = (unsigned char *)malloc(1);
 155  		**encodeArray = 0;
 156  		return 1;
 157  	}
 158  	
 159  	/* first calculate the number of digits in num, base 128 */
 160  	scratch = (unsigned)num;
 161  	while(scratch != 0) {
 162  		numDigits++;
 163  		scratch >>= 7;
 164  	}
 165  	
 166  	result = (unsigned char *)malloc(numDigits);
 167  	scratch = (unsigned)num;
 168  	for(dex=0; dex<numDigits; dex++) { 
 169  		result[numDigits - dex - 1] = scratch & 0x7f;
 170  		scratch >>= 7;
 171  	}
 172  	
 173  	/* all digits except the last one have m.s. bit set */
 174  	for(dex=0; dex<(numDigits - 1); dex++) {
 175  		result[dex] |= 0x80;
 176  	}
 177  	
 178  	*encodeArray = result;
 179  	return numDigits;
 180  }
 181  
 182  /*
 183   * Given an OID in dotted-decimal string representation, convert to binary
 184   * DER format. Returns a pointer in outOid which the caller must free(),
 185   * as well as the length of the data in outLen.
 186   * Function returns 0 if successful, non-zero otherwise.
 187   */
 188  static int encodeOid(
 189  	const unsigned char *inStr,
 190  	unsigned char **outOid,
 191  	unsigned int *outLen)
 192  {
 193  	unsigned char **digits = NULL;		/* array of char * from encodeNumber */
 194  	unsigned *numDigits = NULL;			/* array of unsigned from encodeNumber */
 195  	CFIndex digit;
 196  	unsigned numDigitBytes;				/* total #of output chars */
 197  	unsigned char firstByte;
 198  	unsigned char *outP;
 199  	CFIndex numsToProcess;
 200  	CFStringRef oidStr = NULL;
 201  	CFArrayRef argvRef = NULL;
 202  	int num, result = 1;
 203          CFIndex argc;
 204  	
 205  	/* parse input string into array of substrings */
 206  	if (!inStr || !outOid || !outLen) goto cleanExit;
 207  	oidStr = CFStringCreateWithCString(NULL, (const char *)inStr, kCFStringEncodingASCII);
 208  	if (!oidStr) goto cleanExit;
 209  	argvRef = CFStringCreateArrayBySeparatingStrings(NULL, oidStr, CFSTR("."));
 210  	if (!argvRef) goto cleanExit;
 211  	argc = CFArrayGetCount(argvRef);
 212  	if (argc < 3) goto cleanExit;
 213  	
 214  	/* first two numbers in OID munge together */
 215  	num = cfStringToNumber((CFStringRef)CFArrayGetValueAtIndex(argvRef, 0));
 216  	if (num < 0) goto cleanExit;
 217  	firstByte = (40 * num);
 218  	num = cfStringToNumber((CFStringRef)CFArrayGetValueAtIndex(argvRef, 1));
 219  	if (num < 0) goto cleanExit;
 220  	firstByte += num;
 221  	numDigitBytes = 1;
 222  
 223  	numsToProcess = argc - 2;
 224  	if(numsToProcess > 0) {
 225  		/* skip this loop in the unlikely event that input is only two numbers */
 226  		digits = (unsigned char **) malloc(numsToProcess * sizeof(unsigned char *));
 227  		numDigits = (unsigned *) malloc(numsToProcess * sizeof(unsigned));
 228  		for(digit=0; digit<numsToProcess; digit++) {
 229  			num = cfStringToNumber((CFStringRef)CFArrayGetValueAtIndex(argvRef, digit+2));
 230  			if (num < 0) goto cleanExit;
 231  			numDigits[digit] = encodeNumber(num, &digits[digit]);
 232  			numDigitBytes += numDigits[digit];
 233  		}
 234  	}
 235  	*outLen = (2 + numDigitBytes);
 236  	*outOid = outP = (unsigned char *) malloc(*outLen);
 237  	*outP++ = 0x06;
 238  	*outP++ = numDigitBytes;
 239  	*outP++ = firstByte;
 240  	for(digit=0; digit<numsToProcess; digit++) {
 241  		unsigned int byteDex;
 242  		for(byteDex=0; byteDex<numDigits[digit]; byteDex++) {
 243  			*outP++ = digits[digit][byteDex];
 244  		}
 245  	}	
 246  	if(digits) {
 247  		for(digit=0; digit<numsToProcess; digit++) {
 248  			free(digits[digit]);
 249  		}
 250  	}
 251  	result = 0;
 252  
 253  cleanExit:
 254      if (digits) free(digits);
 255      if (numDigits) free(numDigits);
 256  	if (oidStr) CFRelease(oidStr);
 257  	if (argvRef) CFRelease(argvRef);
 258  
 259  	return result;
 260  }
 261  
 262  /*
 263   * Given a CF object reference describing an OID, convert to binary DER format
 264   * and fill out the CSSM_OID structure provided by the caller. Caller is
 265   * responsible for freeing the data pointer in outOid->Data.
 266   *
 267   * Function returns 0 if successful, non-zero otherwise.
 268   */
 269  
 270  static int convertOid(
 271  	CFTypeRef inRef,
 272  	CSSM_OID *outOid)
 273  {
 274  	if (!inRef || !outOid)
 275  		return errSecParam;
 276  	
 277  	unsigned char *oidData = NULL;
 278  	unsigned int oidLen = 0;
 279  
 280  	if (CFGetTypeID(inRef) == CFStringGetTypeID()) {
 281  		// CFStringRef: OID representation is a dotted-decimal string
 282  		CFStringRef inStr = (CFStringRef)inRef;
 283  		CFIndex max = CFStringGetLength(inStr) * 3;
 284  		char *buf = (char *)malloc(max);
 285  		if (!buf) {
 286  			return errSecMemoryError;
 287  		}
 288  		if (!CFStringGetCString(inStr, buf, max-1, kCFStringEncodingASCII)) {
 289  			free(buf);
 290  			return errSecParam;
 291  		}
 292  
 293  		if (encodeOid((unsigned char *)buf, &oidData, &oidLen) != 0) {
 294  			free(buf);
 295  			return errSecParam;
 296  		}
 297  		free(buf);
 298  	}
 299  	else if (CFGetTypeID(inRef) == CFDataGetTypeID()) {
 300  		// CFDataRef: OID representation is in binary DER format
 301  		CFDataRef inData = (CFDataRef)inRef;
 302  		oidLen = (unsigned int) CFDataGetLength(inData);
 303  		oidData = (unsigned char *) malloc(oidLen);
 304  		memcpy(oidData, CFDataGetBytePtr(inData), oidLen);
 305  	}
 306  	else {
 307  		// Not in a format we understand
 308  		return errSecParam;
 309  	}
 310  	outOid->Length = oidLen;
 311  	outOid->Data = (uint8 *)oidData;
 312  	return 0;
 313  }
 314  
 315  static CFTypeID cmsEncoderTypeID = _kCFRuntimeNotATypeID;
 316  
 317  /* one time only class init, called via pthread_once() in CMSEncoderGetTypeID() */
 318  static void cmsEncoderClassInitialize(void)
 319  {
 320  	cmsEncoderTypeID = 
 321  		_CFRuntimeRegisterClass((const CFRuntimeClass * const)&cmsEncoderRuntimeClass);
 322  }
 323  
 324  /* init called out from _CFRuntimeCreateInstance() */
 325  static void cmsEncoderInit(CFTypeRef enc)
 326  {
 327  	char *start = ((char *)enc) + sizeof(CFRuntimeBase);
 328  	memset(start, 0, sizeof(struct _CMSEncoder) - sizeof(CFRuntimeBase));
 329  }
 330  
 331  /*
 332   * Dispose of a CMSEncoder. Called out from CFRelease().
 333   */
 334  static void cmsEncoderFinalize(
 335  	CFTypeRef		enc)
 336  {
 337  	CMSEncoderRef cmsEncoder = (CMSEncoderRef)enc;
 338  	if(cmsEncoder == NULL) {
 339  		return;
 340  	}
 341  	if(cmsEncoder->eContentType.Data != NULL) {
 342  		free(cmsEncoder->eContentType.Data);
 343  	}
 344  	CFRELEASE(cmsEncoder->signers);
 345  	CFRELEASE(cmsEncoder->recipients);
 346  	CFRELEASE(cmsEncoder->otherCerts);
 347  	if(cmsEncoder->cmsMsg != NULL) {
 348  		SecCmsMessageDestroy(cmsEncoder->cmsMsg);
 349  		cmsEncoder->cmsMsg = NULL;
 350  	}
 351  	if(cmsEncoder->arena != NULL) {
 352  		SecArenaPoolFree(cmsEncoder->arena, false);
 353  	}
 354  	if(cmsEncoder->encoder != NULL) {
 355  		/* 
 356  		 * Normally this gets freed in SecCmsEncoderFinish - this is 
 357  		 * an error case.
 358  		 */
 359  		SecCmsEncoderDestroy(cmsEncoder->encoder);
 360  	}
 361  }
 362  
 363  static OSStatus cmsSetupEncoder(
 364  	CMSEncoderRef		cmsEncoder)
 365  {
 366  	OSStatus ortn;
 367  	
 368  	ASSERT(cmsEncoder->arena == NULL);
 369  	ASSERT(cmsEncoder->encoder == NULL);
 370  	
 371  	ortn = SecArenaPoolCreate(1024, &cmsEncoder->arena);
 372  	if(ortn) {
 373  		return cmsRtnToOSStatus(ortn);
 374  	}
 375  	ortn = SecCmsEncoderCreate(cmsEncoder->cmsMsg, 
 376  		NULL, NULL,					// no callback 
 377  		&cmsEncoder->encoderOut,	// data goes here
 378  		cmsEncoder->arena,	
 379  		NULL, NULL,					// no password callback (right?) 
 380  		NULL, NULL,					// decrypt key callback
 381  		NULL, NULL,					// detached digests
 382  		&cmsEncoder->encoder);
 383  	if(ortn) {
 384  		return cmsRtnToOSStatus(ortn);
 385  	}
 386  	return errSecSuccess;
 387  }
 388  
 389  /* 
 390   * Set up a SecCmsMessageRef for a SignedData creation.
 391   */
 392  static OSStatus cmsSetupForSignedData(
 393  	CMSEncoderRef		cmsEncoder)
 394  {
 395  	ASSERT((cmsEncoder->signers != NULL) || (cmsEncoder->otherCerts != NULL));
 396  	
 397      SecCmsContentInfoRef contentInfo = NULL;
 398      SecCmsSignedDataRef signedData = NULL;
 399  	OSStatus ortn;
 400  
 401      /* build chain of objects: message->signedData->data */
 402  	if(cmsEncoder->cmsMsg != NULL) {
 403  		SecCmsMessageDestroy(cmsEncoder->cmsMsg);
 404  	}
 405  	cmsEncoder->cmsMsg = SecCmsMessageCreate(NULL);
 406  	if(cmsEncoder->cmsMsg == NULL) {
 407  		return errSecInternalComponent;
 408  	}
 409  
 410  	signedData = SecCmsSignedDataCreate(cmsEncoder->cmsMsg);
 411  	if(signedData == NULL) {
 412  		return errSecInternalComponent;
 413  	}
 414  	contentInfo = SecCmsMessageGetContentInfo(cmsEncoder->cmsMsg);
 415  	ortn = SecCmsContentInfoSetContentSignedData(cmsEncoder->cmsMsg, contentInfo, 
 416  			signedData);
 417  	if(ortn) {
 418  		return cmsRtnToOSStatus(ortn);
 419  	}
 420      contentInfo = SecCmsSignedDataGetContentInfo(signedData);
 421  	if(cmsEncoder->eContentType.Data != NULL) {
 422  		/* Override the default eContentType of id-data */
 423  		ortn = SecCmsContentInfoSetContentOther(cmsEncoder->cmsMsg, 
 424  			contentInfo, 
 425  			NULL,		/* data - provided to encoder, not here */
 426  			cmsEncoder->detachedContent,
 427  			&cmsEncoder->eContentType);
 428  	}
 429  	else {
 430  		ortn = SecCmsContentInfoSetContentData(cmsEncoder->cmsMsg, 
 431  			contentInfo, 
 432  			NULL, /* data - provided to encoder, not here */
 433  			cmsEncoder->detachedContent);
 434  	}
 435  	if(ortn) {
 436  		ortn = cmsRtnToOSStatus(ortn);
 437  		CSSM_PERROR("SecCmsContentInfoSetContent*", ortn);
 438  		return ortn;
 439  	}
 440  
 441  	/* optional 'global' (per-SignedData) certs */
 442  	if(cmsEncoder->otherCerts != NULL) {
 443  		ortn = SecCmsSignedDataAddCertList(signedData, cmsEncoder->otherCerts);
 444  		if(ortn) {
 445  			ortn = cmsRtnToOSStatus(ortn);
 446  			CSSM_PERROR("SecCmsSignedDataAddCertList", ortn);
 447  			return ortn;
 448  		}
 449  	}
 450  	
 451  	/* SignerInfos, one per signer */
 452  	CFIndex numSigners = 0;
 453  	if(cmsEncoder->signers != NULL) {
 454  		/* this is optional...in case we're just creating a cert bundle */
 455  		numSigners = CFArrayGetCount(cmsEncoder->signers);
 456  	}
 457  	CFIndex dex;
 458  	SecCertificateRef ourCert = NULL;
 459  	SecCmsCertChainMode chainMode = SecCmsCMCertChain;
 460  
 461  	switch(cmsEncoder->chainMode) {
 462  		case kCMSCertificateNone:
 463  			chainMode = SecCmsCMNone;
 464  			break;
 465  		case kCMSCertificateSignerOnly:
 466  			chainMode = SecCmsCMCertOnly;
 467  			break;
 468  		case kCMSCertificateChainWithRoot:
 469  			chainMode = SecCmsCMCertChainWithRoot;
 470  			break;
 471  		case kCMSCertificateChainWithRootOrFail:
 472  			chainMode = SecCmsCMCertChainWithRootOrFail;
 473  			break;
 474  		default:
 475  			break;
 476  	}
 477  	for(dex=0; dex<numSigners; dex++) {
 478  		SecCmsSignerInfoRef signerInfo;
 479  		
 480  		SecIdentityRef ourId = 
 481  			(SecIdentityRef)CFArrayGetValueAtIndex(cmsEncoder->signers, dex);
 482  		ortn = SecIdentityCopyCertificate(ourId, &ourCert);
 483  		if(ortn) {
 484  			CSSM_PERROR("SecIdentityCopyCertificate", ortn);
 485  			break;
 486  		}
 487  		signerInfo = SecCmsSignerInfoCreate(cmsEncoder->cmsMsg, ourId, cmsEncoder->digestalgtag);
 488  		if (signerInfo == NULL) {
 489  			ortn = errSecInternalComponent;
 490  			break;
 491  		}
 492  
 493  		/* we want the cert chain included for this one */
 494  		/* NOTE the usage parameter is currently unused by the SMIME lib */
 495  		ortn = SecCmsSignerInfoIncludeCerts(signerInfo, chainMode, 
 496  			certUsageEmailSigner);
 497  		if(ortn) {
 498  			ortn = cmsRtnToOSStatus(ortn);
 499  			CSSM_PERROR("SecCmsSignerInfoIncludeCerts", ortn);
 500  			break;
 501  		}
 502  		
 503  		/* other options */
 504  		if(cmsEncoder->signedAttributes & kCMSAttrSmimeCapabilities) {
 505  			ortn = SecCmsSignerInfoAddSMIMECaps(signerInfo);
 506  			if(ortn) {
 507  				ortn = cmsRtnToOSStatus(ortn);
 508  				CSSM_PERROR("SecCmsSignerInfoAddSMIMEEncKeyPrefs", ortn);
 509  				break;
 510  			}
 511  		}
 512  		if(cmsEncoder->signedAttributes & kCMSAttrSmimeEncryptionKeyPrefs) {
 513  			ortn = SecCmsSignerInfoAddSMIMEEncKeyPrefs(signerInfo, ourCert, NULL);
 514  			if(ortn) {
 515  				ortn = cmsRtnToOSStatus(ortn);
 516  				CSSM_PERROR("SecCmsSignerInfoAddSMIMEEncKeyPrefs", ortn);
 517  				break;
 518  			}
 519  		}
 520  		if(cmsEncoder->signedAttributes & kCMSAttrSmimeMSEncryptionKeyPrefs) {
 521  			ortn = SecCmsSignerInfoAddMSSMIMEEncKeyPrefs(signerInfo, ourCert, NULL);
 522  			if(ortn) {
 523  				ortn = cmsRtnToOSStatus(ortn);
 524  				CSSM_PERROR("SecCmsSignerInfoAddMSSMIMEEncKeyPrefs", ortn);
 525  				break;
 526  			}
 527  		}
 528  		if(cmsEncoder->signedAttributes & kCMSAttrSigningTime) {
 529  			if (cmsEncoder->signingTime == 0)
 530  				cmsEncoder->signingTime = CFAbsoluteTimeGetCurrent();
 531  			ortn = SecCmsSignerInfoAddSigningTime(signerInfo, cmsEncoder->signingTime);
 532  			if(ortn) {
 533  				ortn = cmsRtnToOSStatus(ortn);
 534  				CSSM_PERROR("SecCmsSignerInfoAddSigningTime", ortn);
 535  				break;
 536  			}
 537  		}
 538          if(cmsEncoder->signedAttributes & kCMSAttrAppleCodesigningHashAgility) {
 539              ortn = SecCmsSignerInfoAddAppleCodesigningHashAgility(signerInfo, cmsEncoder->hashAgilityAttrValue);
 540              /* libsecurity_smime made a copy of the attribute value. We don't need it anymore. */
 541              CFReleaseNull(cmsEncoder->hashAgilityAttrValue);
 542              if(ortn) {
 543                  ortn = cmsRtnToOSStatus(ortn);
 544                  CSSM_PERROR("SecCmsSignerInfoAddAppleCodesigningHashAgility", ortn);
 545                  break;
 546              }
 547          }
 548          if(cmsEncoder->signedAttributes & kCMSAttrAppleCodesigningHashAgilityV2) {
 549              ortn = SecCmsSignerInfoAddAppleCodesigningHashAgilityV2(signerInfo, cmsEncoder->hashAgilityV2AttrValues);
 550              /* libsecurity_smime made a copy of the attribute value. We don't need it anymore. */
 551              CFReleaseNull(cmsEncoder->hashAgilityV2AttrValues);
 552              if(ortn) {
 553                  ortn = cmsRtnToOSStatus(ortn);
 554                  CSSM_PERROR("SecCmsSignerInfoAddAppleCodesigningHashAgilityV2", ortn);
 555                  break;
 556              }
 557          }
 558          if (cmsEncoder->signedAttributes & kCMSAttrAppleExpirationTime) {
 559              ortn = SecCmsSignerInfoAddAppleExpirationTime(signerInfo, cmsEncoder->expirationTime);
 560              if(ortn) {
 561                  ortn = cmsRtnToOSStatus(ortn);
 562                  CSSM_PERROR("SecCmsSignerInfoAddAppleExpirationTime", ortn);
 563                  break;
 564              }
 565          }
 566  		
 567  		ortn = SecCmsSignedDataAddSignerInfo(signedData, signerInfo);
 568  		if(ortn) {
 569  			ortn = cmsRtnToOSStatus(ortn);
 570  			CSSM_PERROR("SecCmsSignedDataAddSignerInfo", ortn);
 571  			break;
 572  		}
 573  
 574  		CFRELEASE(ourCert);
 575  		ourCert = NULL;
 576  	}
 577  	if(ortn) {
 578  		CFRELEASE(ourCert);
 579  	}
 580  	return ortn;
 581  }
 582  
 583  /* 
 584   * Set up a SecCmsMessageRef for a EnvelopedData creation.
 585   */
 586  static OSStatus cmsSetupForEnvelopedData(
 587  	CMSEncoderRef		cmsEncoder)
 588  {
 589  	ASSERT(cmsEncoder->op == EO_Encrypt);
 590  	ASSERT(cmsEncoder->recipients != NULL);
 591  	
 592      SecCmsContentInfoRef contentInfo = NULL;
 593      SecCmsEnvelopedDataRef envelopedData = NULL;
 594  	SECOidTag algorithmTag;
 595      int keySize;
 596  	OSStatus ortn;
 597  
 598  	/*
 599  	 * Find encryption algorithm...unfortunately we need a NULL-terminated array
 600  	 * of SecCertificateRefs for this.
 601  	 */
 602  	CFIndex numCerts = CFArrayGetCount(cmsEncoder->recipients);
 603  	CFIndex dex;
 604  	SecCertificateRef *certArray = (SecCertificateRef *)malloc(
 605  		(numCerts+1) * sizeof(SecCertificateRef));
 606  
 607  	for(dex=0; dex<numCerts; dex++) {
 608  		certArray[dex] = (SecCertificateRef)CFArrayGetValueAtIndex(
 609  			cmsEncoder->recipients, dex);
 610  	}
 611  	certArray[numCerts] = NULL;
 612  	ortn = SecSMIMEFindBulkAlgForRecipients(certArray, &algorithmTag, &keySize);
 613  	free(certArray);
 614  	if(ortn) {
 615  		CSSM_PERROR("SecSMIMEFindBulkAlgForRecipients", ortn);
 616  		return ortn;
 617  	}
 618  	
 619      /* build chain of objects: message->envelopedData->data */
 620  	if(cmsEncoder->cmsMsg != NULL) {
 621  		SecCmsMessageDestroy(cmsEncoder->cmsMsg);
 622  	}
 623  	cmsEncoder->cmsMsg = SecCmsMessageCreate(NULL);
 624  	if(cmsEncoder->cmsMsg == NULL) {
 625  		return errSecInternalComponent;
 626  	}
 627  	envelopedData = SecCmsEnvelopedDataCreate(cmsEncoder->cmsMsg, 
 628  		algorithmTag, keySize);
 629  	if(envelopedData == NULL) {
 630  		return errSecInternalComponent;
 631  	}
 632  	contentInfo = SecCmsMessageGetContentInfo(cmsEncoder->cmsMsg);
 633  	ortn = SecCmsContentInfoSetContentEnvelopedData(cmsEncoder->cmsMsg, 
 634  		contentInfo, envelopedData);
 635  	if(ortn) {
 636  		ortn = cmsRtnToOSStatus(ortn);
 637  		CSSM_PERROR("SecCmsContentInfoSetContentEnvelopedData", ortn);
 638  		return ortn;
 639  	}
 640      contentInfo = SecCmsEnvelopedDataGetContentInfo(envelopedData);
 641  	if(cmsEncoder->eContentType.Data != NULL) {
 642  		/* Override the default ContentType of id-data */
 643  		ortn = SecCmsContentInfoSetContentOther(cmsEncoder->cmsMsg, 
 644  			contentInfo, 
 645  			NULL,		/* data - provided to encoder, not here */
 646  			FALSE,		/* detachedContent */
 647  			&cmsEncoder->eContentType);
 648  	}
 649  	else {
 650  		ortn = SecCmsContentInfoSetContentData(cmsEncoder->cmsMsg, 
 651  			contentInfo, 
 652  			NULL /* data - provided to encoder, not here */, 
 653  			cmsEncoder->detachedContent);
 654  	}
 655  	if(ortn) {
 656  		ortn = cmsRtnToOSStatus(ortn);
 657  		CSSM_PERROR("SecCmsContentInfoSetContentData*", ortn);
 658  		return ortn;
 659  	}
 660  
 661      /* 
 662       * create & attach recipient information, one for each recipient
 663       */
 664  	for(dex=0; dex<numCerts; dex++) {
 665  		SecCmsRecipientInfoRef recipientInfo = NULL;
 666  		
 667  		SecCertificateRef thisRecip = (SecCertificateRef)CFArrayGetValueAtIndex(
 668  			cmsEncoder->recipients, dex);
 669  		recipientInfo = SecCmsRecipientInfoCreate(cmsEncoder->cmsMsg, thisRecip);
 670  		ortn = SecCmsEnvelopedDataAddRecipient(envelopedData, recipientInfo);
 671  		if(ortn) {
 672  			ortn = cmsRtnToOSStatus(ortn);
 673  			CSSM_PERROR("SecCmsEnvelopedDataAddRecipient", ortn);
 674  			return ortn;
 675  		}
 676  	}
 677  	return errSecSuccess;
 678  }
 679  
 680  /* 
 681   * Set up cmsMsg. Called from either the first call to CMSEncoderUpdateContent, or
 682   * from CMSEncodeGetCmsMessage().
 683   */
 684  static OSStatus cmsSetupCmsMsg(
 685  	CMSEncoderRef		cmsEncoder)
 686  {
 687  	ASSERT(cmsEncoder != NULL);
 688  	ASSERT(cmsEncoder->encState == ES_Init);
 689  	
 690  	/* figure out what high-level operation we're doing */
 691  	if((cmsEncoder->signers != NULL) || (cmsEncoder->otherCerts != NULL)) {
 692  		if(cmsEncoder->recipients != NULL) {
 693  			cmsEncoder->op = EO_SignEncrypt;
 694  		}
 695  		else {
 696  			cmsEncoder->op = EO_Sign;
 697  		}
 698  	}
 699  	else if(cmsEncoder->recipients != NULL) {
 700  		cmsEncoder->op = EO_Encrypt;
 701  	}
 702  	else {
 703  		dprintf("CMSEncoderUpdateContent: nothing to do\n");
 704  		return errSecParam;
 705  	}
 706  	
 707  	OSStatus ortn = errSecSuccess;
 708  	
 709  	switch(cmsEncoder->op) {
 710  		case EO_Sign:
 711  		case EO_SignEncrypt:
 712  			/* If we're signing & encrypting, do the signing first */
 713  			ortn = cmsSetupForSignedData(cmsEncoder);
 714  			break;
 715  		case EO_Encrypt:
 716  			ortn = cmsSetupForEnvelopedData(cmsEncoder);
 717  			break;
 718  	}
 719  	cmsEncoder->encState = ES_Msg;
 720  	return ortn;
 721  }
 722  
 723  /* 
 724   * ASN.1 template for decoding a ContentInfo.
 725   */
 726  typedef struct {
 727      CSSM_OID	contentType;
 728      CSSM_DATA	content;    
 729  } SimpleContentInfo;
 730  
 731  static const SecAsn1Template cmsSimpleContentInfoTemplate[] = {
 732      { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(SimpleContentInfo) },
 733      { SEC_ASN1_OBJECT_ID, offsetof(SimpleContentInfo, contentType) },
 734      { SEC_ASN1_EXPLICIT | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 0, 
 735  	  offsetof(SimpleContentInfo, content),
 736  	  kSecAsn1AnyTemplate },
 737      { 0, }
 738  };
 739  
 740  /*
 741   * Obtain the content of a contentInfo, This basically strips off the contentType OID
 742   * and returns its ASN_ANY content, allocated the provided coder's memory space. 
 743   */
 744  static OSStatus cmsContentInfoContent(
 745  	SecAsn1CoderRef asn1Coder,
 746  	const CSSM_DATA *contentInfo,
 747  	CSSM_DATA *content)				/* RETURNED */
 748  {
 749      OSStatus ortn;
 750      SimpleContentInfo decodedInfo;
 751      
 752      memset(&decodedInfo, 0, sizeof(decodedInfo));
 753      ortn = SecAsn1DecodeData(asn1Coder, contentInfo, 
 754  		cmsSimpleContentInfoTemplate, &decodedInfo);
 755      if(ortn) {
 756  		return ortn;
 757      }
 758      if(decodedInfo.content.Data == NULL) {
 759  		dprintf("***Error decoding contentInfo: no content\n");
 760  		return errSecInternalComponent;
 761      }
 762      *content = decodedInfo.content;
 763  	return errSecSuccess;
 764  }
 765  
 766  #pragma mark --- Start of Public API ---
 767  
 768  CFTypeID CMSEncoderGetTypeID(void)
 769  {
 770  	static pthread_once_t once = PTHREAD_ONCE_INIT;
 771  	
 772  	if(cmsEncoderTypeID == _kCFRuntimeNotATypeID) {
 773  		pthread_once(&once, &cmsEncoderClassInitialize);
 774  	}
 775  	return cmsEncoderTypeID;
 776  }
 777  
 778  /*
 779   * Create a CMSEncoder. Result must eventually be freed via CFRelease().
 780   */
 781  OSStatus CMSEncoderCreate(
 782  	CMSEncoderRef		*cmsEncoderOut)	/* RETURNED */
 783  {
 784  	CMSEncoderRef cmsEncoder = NULL;
 785  	
 786  	uint32_t extra = sizeof(*cmsEncoder) - sizeof(cmsEncoder->base);
 787  	cmsEncoder = (CMSEncoderRef)_CFRuntimeCreateInstance(NULL, CMSEncoderGetTypeID(),
 788  		extra, NULL);
 789  	if(cmsEncoder == NULL) {
 790  		return errSecAllocate;
 791  	}
 792  	cmsEncoder->encState = ES_Init;
 793  	cmsEncoder->chainMode = kCMSCertificateChain;
 794  	cmsEncoder->digestalgtag = SEC_OID_SHA1;
 795  	*cmsEncoderOut = cmsEncoder;
 796  	return errSecSuccess;
 797  }
 798  	
 799  #pragma mark --- Getters & Setters ---
 800  
 801  const CFStringRef __nonnull kCMSEncoderDigestAlgorithmSHA1 = CFSTR("sha1");
 802  const CFStringRef __nonnull kCMSEncoderDigestAlgorithmSHA256 = CFSTR("sha256");
 803  
 804  
 805  OSStatus CMSEncoderSetSignerAlgorithm(
 806  	CMSEncoderRef		cmsEncoder,
 807  	CFStringRef		digestAlgorithm)
 808  {
 809      if (CFEqual(digestAlgorithm, kCMSEncoderDigestAlgorithmSHA1)) {
 810  	cmsEncoder->digestalgtag = SEC_OID_SHA1;
 811      } else if (CFEqual(digestAlgorithm, kCMSEncoderDigestAlgorithmSHA256)) {
 812  	cmsEncoder->digestalgtag = SEC_OID_SHA256;
 813      } else {
 814  	return errSecParam;
 815      }
 816  
 817      return errSecSuccess;
 818  }
 819  
 820  /* 
 821   * Specify signers of the CMS message; implies that the message will be signed. 
 822   */
 823  OSStatus CMSEncoderAddSigners(
 824  	CMSEncoderRef		cmsEncoder,
 825  	CFTypeRef			signerOrArray)
 826  {
 827  	if(cmsEncoder == NULL) {
 828  		return errSecParam;
 829  	}
 830  	if(cmsEncoder->encState != ES_Init) {
 831  		return errSecParam;
 832  	}
 833  	return cmsAppendToArray(signerOrArray, &cmsEncoder->signers, SecIdentityGetTypeID());
 834  }
 835  
 836  /*
 837   * Obtain an array of signers as specified in CMSEncoderSetSigners(). 
 838   */
 839  OSStatus CMSEncoderCopySigners(
 840  	CMSEncoderRef		cmsEncoder,
 841  	CFArrayRef			*signers)
 842  {
 843  	if((cmsEncoder == NULL) || (signers == NULL)) {
 844  		return errSecParam;
 845  	}
 846  	if(cmsEncoder->signers != NULL) {
 847  		CFRetain(cmsEncoder->signers);
 848  	}
 849  	*signers = cmsEncoder->signers;
 850  	return errSecSuccess;
 851  }
 852  
 853  /*
 854   * Specify recipients of the message. Implies that the message will be encrypted. 
 855   */
 856  OSStatus CMSEncoderAddRecipients(
 857  	CMSEncoderRef		cmsEncoder,
 858  	CFTypeRef			recipientOrArray)
 859  {
 860  	if(cmsEncoder == NULL) {
 861  		return errSecParam;
 862  	}
 863  	if(cmsEncoder->encState != ES_Init) {
 864  		return errSecParam;
 865  	}
 866  	return cmsAppendToArray(recipientOrArray, &cmsEncoder->recipients, 
 867  			SecCertificateGetTypeID());
 868  }
 869  
 870  /*
 871   * Obtain an array of recipients as specified in CMSEncoderSetRecipients(). 
 872   */
 873  OSStatus CMSEncoderCopyRecipients(
 874  	CMSEncoderRef		cmsEncoder,
 875  	CFArrayRef			*recipients)
 876  {
 877  	if((cmsEncoder == NULL) || (recipients == NULL)) {
 878  		return errSecParam;
 879  	}
 880  	if(cmsEncoder->recipients != NULL) {
 881  		CFRetain(cmsEncoder->recipients);
 882  	}
 883  	*recipients = cmsEncoder->recipients;
 884  	return errSecSuccess;
 885  }
 886  
 887  /* 
 888   * Specify additional certs to include in a signed message. 
 889   */
 890  OSStatus CMSEncoderAddSupportingCerts(
 891  	CMSEncoderRef		cmsEncoder,
 892  	CFTypeRef			certOrArray)
 893  {
 894  	if(cmsEncoder == NULL) {
 895  		return errSecParam;
 896  	}
 897  	if(cmsEncoder->encState != ES_Init) {
 898  		return errSecParam;
 899  	}
 900  	return cmsAppendToArray(certOrArray, &cmsEncoder->otherCerts, 
 901  			SecCertificateGetTypeID());
 902  }
 903  	
 904  /*
 905   * Obtain the SecCertificates provided in CMSEncoderAddSupportingCerts(). 
 906   */
 907  OSStatus CMSEncoderCopySupportingCerts(
 908  	CMSEncoderRef		cmsEncoder,
 909  	CFArrayRef			*certs)			/* RETURNED */
 910  {
 911  	if((cmsEncoder == NULL) || (certs == NULL)) {
 912  		return errSecParam;
 913  	}
 914  	if(cmsEncoder->otherCerts != NULL) {
 915  		CFRetain(cmsEncoder->otherCerts);
 916  	}
 917  	*certs = cmsEncoder->otherCerts;
 918  	return errSecSuccess;
 919  }
 920  
 921  OSStatus CMSEncoderSetHasDetachedContent(
 922  	CMSEncoderRef		cmsEncoder,
 923  	Boolean				detachedContent)
 924  {
 925  	if(cmsEncoder == NULL) {
 926  		return errSecParam;
 927  	}
 928  	if(cmsEncoder->encState != ES_Init) {
 929  		return errSecParam;
 930  	}
 931  	cmsEncoder->detachedContent = detachedContent;
 932  	return errSecSuccess;
 933  }
 934  
 935  OSStatus CMSEncoderGetHasDetachedContent(
 936  	CMSEncoderRef		cmsEncoder,
 937  	Boolean				*detachedContent)	/* RETURNED */
 938  {
 939  	if((cmsEncoder == NULL) || (detachedContent == NULL)) {
 940  		return errSecParam;
 941  	}
 942  	*detachedContent = cmsEncoder->detachedContent;
 943  	return errSecSuccess;
 944  }
 945  
 946  /*
 947   * Optionally specify an eContentType OID for the inner EncapsulatedData for
 948   * a signed message. The default eContentType, used of this function is not
 949   * called, is id-data. 
 950   */
 951  OSStatus CMSEncoderSetEncapsulatedContentType(
 952  	CMSEncoderRef		cmsEncoder,
 953  	const CSSM_OID	*eContentType)
 954  {
 955  	if((cmsEncoder == NULL) || (eContentType == NULL)) {
 956  		return errSecParam;
 957  	}
 958  	if(cmsEncoder->encState != ES_Init) {
 959  		return errSecParam;
 960  	}
 961  	
 962  	CSSM_OID *ecOid = &cmsEncoder->eContentType;
 963  	if(ecOid->Data != NULL) {
 964  		free(ecOid->Data);
 965  	}
 966  	cmsCopyCmsData(eContentType, ecOid);
 967  	return errSecSuccess;
 968  }
 969  
 970  OSStatus CMSEncoderSetEncapsulatedContentTypeOID(
 971  	CMSEncoderRef		cmsEncoder,
 972  	CFTypeRef			eContentTypeOID)
 973  {
 974  	// convert eContentTypeOID to a CSSM_OID
 975  	CSSM_OID contentType = { 0, NULL };
 976  	if (!eContentTypeOID || convertOid(eContentTypeOID, &contentType) != 0)
 977  		return errSecParam;
 978  	OSStatus result = CMSEncoderSetEncapsulatedContentType(cmsEncoder, &contentType);
 979  	if (contentType.Data)
 980  		free(contentType.Data);
 981  	return result;
 982  }
 983  
 984  /*
 985   * Obtain the eContentType OID specified in CMSEncoderSetEncapsulatedContentType().
 986   */
 987  OSStatus CMSEncoderCopyEncapsulatedContentType(
 988  	CMSEncoderRef		cmsEncoder,
 989  	CFDataRef			*eContentType)
 990  {
 991  	if((cmsEncoder == NULL) || (eContentType == NULL)) {
 992  		return errSecParam;
 993  	}
 994  	
 995  	CSSM_OID *ecOid = &cmsEncoder->eContentType;
 996  	if(ecOid->Data == NULL) {
 997  		*eContentType = NULL;
 998  	}
 999  	else {
1000  		*eContentType = CFDataCreate(NULL, ecOid->Data, ecOid->Length);
1001  	}
1002  	return errSecSuccess;
1003  }
1004  
1005  /*
1006   * Optionally specify signed attributes. Only meaningful when creating a 
1007   * signed message. If this is called, it must be called before
1008   * CMSEncoderUpdateContent().
1009   */
1010  OSStatus CMSEncoderAddSignedAttributes(
1011  	CMSEncoderRef		cmsEncoder,
1012  	CMSSignedAttributes	signedAttributes)
1013  {
1014  	if(cmsEncoder == NULL) {
1015  		return errSecParam;
1016  	}
1017  	if(cmsEncoder->encState != ES_Init) {
1018  		return errSecParam;
1019  	}
1020  	cmsEncoder->signedAttributes |= signedAttributes;
1021  	return errSecSuccess;
1022  }
1023  
1024  /*
1025   * Set the signing time for a CMSEncoder.
1026   * This is only used if the kCMSAttrSigningTime attribute is included.
1027   */
1028  OSStatus CMSEncoderSetSigningTime(
1029  	CMSEncoderRef		cmsEncoder,
1030  	CFAbsoluteTime		time)
1031  {
1032  	if(cmsEncoder == NULL) {
1033  		return errSecParam;
1034  	}
1035  	if(cmsEncoder->encState != ES_Init) {
1036  		return errSecParam;
1037  	}
1038  	cmsEncoder->signingTime = time;
1039  	return errSecSuccess;
1040  }
1041  
1042  /*
1043   * Set the hash agility attribute for a CMSEncoder.
1044   * This is only used if the kCMSAttrAppleCodesigningHashAgility attribute
1045   * is included.
1046   */
1047  OSStatus CMSEncoderSetAppleCodesigningHashAgility(
1048      CMSEncoderRef   cmsEncoder,
1049      CFDataRef       hashAgilityAttrValue)
1050  {
1051      if (cmsEncoder == NULL || cmsEncoder->encState != ES_Init) {
1052          return errSecParam;
1053      }
1054      cmsEncoder->hashAgilityAttrValue = CFRetainSafe(hashAgilityAttrValue);
1055      return errSecSuccess;
1056  }
1057  
1058  /*
1059   * Set the hash agility attribute for a CMSEncoder.
1060   * This is only used if the kCMSAttrAppleCodesigningHashAgilityV2 attribute
1061   * is included.
1062   */
1063  OSStatus CMSEncoderSetAppleCodesigningHashAgilityV2(
1064      CMSEncoderRef   cmsEncoder,
1065      CFDictionaryRef       hashAgilityV2AttrValues)
1066  {
1067      if (cmsEncoder == NULL || cmsEncoder->encState != ES_Init) {
1068          return errSecParam;
1069      }
1070      cmsEncoder->hashAgilityV2AttrValues = CFRetainSafe(hashAgilityV2AttrValues);
1071      return errSecSuccess;
1072  }
1073  
1074  /*
1075   * Set the expiration time for a CMSEncoder.
1076   * This is only used if the kCMSAttrAppleExpirationTime attribute is included.
1077   */
1078  OSStatus CMSEncoderSetAppleExpirationTime(
1079      CMSEncoderRef        cmsEncoder,
1080      CFAbsoluteTime        time)
1081  {
1082      if(cmsEncoder == NULL) {
1083          return errSecParam;
1084      }
1085      if(cmsEncoder->encState != ES_Init) {
1086          return errSecParam;
1087      }
1088      cmsEncoder->expirationTime = time;
1089      return errSecSuccess;
1090  }
1091  
1092  OSStatus CMSEncoderSetCertificateChainMode(
1093  	CMSEncoderRef			cmsEncoder,
1094  	CMSCertificateChainMode	chainMode)
1095  {
1096  	if(cmsEncoder == NULL) {
1097  		return errSecParam;
1098  	}
1099  	if(cmsEncoder->encState != ES_Init) {
1100  		return errSecParam;
1101  	}
1102  	switch(chainMode) {
1103  		case kCMSCertificateNone:
1104  		case kCMSCertificateSignerOnly:
1105  		case kCMSCertificateChain:
1106  		case kCMSCertificateChainWithRoot:
1107  		case kCMSCertificateChainWithRootOrFail:
1108  			break;
1109  		default:
1110  			return errSecParam;
1111  	}
1112  	cmsEncoder->chainMode = chainMode;
1113  	return errSecSuccess;
1114  }
1115  
1116  OSStatus CMSEncoderGetCertificateChainMode(
1117  	CMSEncoderRef			cmsEncoder,
1118  	CMSCertificateChainMode	*chainModeOut)
1119  {
1120  	if(cmsEncoder == NULL) {
1121  		return errSecParam;
1122  	}
1123  	*chainModeOut = cmsEncoder->chainMode;
1124  	return errSecSuccess;
1125  }
1126  
1127  void
1128  CmsMessageSetTSACallback(CMSEncoderRef cmsEncoder, SecCmsTSACallback tsaCallback)
1129  {
1130      if (cmsEncoder->cmsMsg)
1131          SecCmsMessageSetTSACallback(cmsEncoder->cmsMsg, tsaCallback);
1132  }
1133  
1134  void
1135  CmsMessageSetTSAContext(CMSEncoderRef cmsEncoder, CFTypeRef tsaContext)
1136  {
1137      if (cmsEncoder->cmsMsg)
1138          SecCmsMessageSetTSAContext(cmsEncoder->cmsMsg, tsaContext);
1139  }
1140  
1141  #pragma mark --- Action ---
1142  
1143  /*
1144   * Feed content bytes into the encoder. 
1145   * Can be called multiple times. 
1146   * No 'setter' routines can be called after this function has been called. 
1147   */ 
1148  OSStatus CMSEncoderUpdateContent(
1149  	CMSEncoderRef		cmsEncoder,
1150  	const void			*content,
1151  	size_t				contentLen)
1152  {
1153  	if(cmsEncoder == NULL) {
1154  		return errSecParam;
1155  	}
1156  	
1157  	OSStatus ortn = errSecSuccess;
1158  	switch(cmsEncoder->encState) {
1159  		case ES_Init:
1160  			/* 
1161  			 * First time thru: do the CmsMsg setup.
1162  			 */
1163  			ortn = cmsSetupCmsMsg(cmsEncoder);
1164  			if(ortn) {
1165  				return ortn;
1166  			}
1167  			/* fall thru to set up the encoder */
1168  			
1169  		case ES_Msg:
1170  			/* We have a cmsMsg but no encoder; create one */
1171  			ASSERT(cmsEncoder->cmsMsg != NULL);
1172  			ASSERT(cmsEncoder->encoder == NULL);
1173  			ortn = cmsSetupEncoder(cmsEncoder);
1174  			if(ortn) {
1175  				return ortn;
1176  			}
1177  			/* only legal calls now are update and finalize */
1178  			cmsEncoder->encState = ES_Updating;
1179  			break;
1180  			
1181  		case ES_Updating:
1182  			ASSERT(cmsEncoder->encoder != NULL);
1183  			break;
1184  
1185  		case ES_Final:
1186  			/* Too late for another update */
1187  			return errSecParam;
1188  			
1189  		default:
1190  			return errSecInternalComponent;
1191  	}
1192  	
1193  	/* FIXME - CFIndex same size as size_t on 64bit? */
1194  	ortn = SecCmsEncoderUpdate(cmsEncoder->encoder, content, (CFIndex)contentLen);
1195  	if(ortn) {
1196  		ortn = cmsRtnToOSStatus(ortn);
1197  		CSSM_PERROR("SecCmsEncoderUpdate", ortn);
1198  	}
1199  	return ortn;
1200  }
1201  	
1202  /*
1203   * Finish encoding the message and obtain the encoded result.
1204   * Caller must CFRelease the result. 
1205   */
1206  OSStatus CMSEncoderCopyEncodedContent(
1207  	CMSEncoderRef		cmsEncoder,
1208  	CFDataRef			*encodedContent)
1209  {
1210  	if((cmsEncoder == NULL) || (encodedContent == NULL)) {
1211  		return errSecParam;
1212  	}
1213  
1214  	OSStatus ortn;
1215  
1216  	switch(cmsEncoder->encState) {
1217  		case ES_Updating:
1218  			/* normal termination */
1219  			break;
1220  		case ES_Final:
1221  			/* already been called */
1222  			return errSecParam;
1223  		case ES_Msg:
1224  		case ES_Init:
1225  			/*
1226  			 * The only time these are legal is when we're doing a SignedData
1227  			 * with certificates only (no signers, no content).
1228  			 */
1229  			if((cmsEncoder->signers != NULL) ||
1230  			   (cmsEncoder->recipients != NULL) ||
1231  			   (cmsEncoder->otherCerts == NULL)) {
1232  				return errSecParam;
1233  			}
1234  			
1235  			/* Set up for certs only */
1236  			ortn = cmsSetupForSignedData(cmsEncoder);
1237  			if(ortn) {
1238  				return ortn;
1239  			}
1240  			/* and an encoder */
1241  			ortn = cmsSetupEncoder(cmsEncoder);
1242  			if(ortn) {
1243  				return ortn;
1244  			}
1245  			break;
1246  	}
1247  	
1248  	
1249  	ASSERT(cmsEncoder->encoder != NULL);
1250  	ortn = SecCmsEncoderFinish(cmsEncoder->encoder);
1251  	/* regardless of the outcome, the encoder itself has been freed */
1252  	cmsEncoder->encoder = NULL;
1253  	if(ortn) {
1254  		return cmsRtnToOSStatus(ortn);
1255  	}
1256  	cmsEncoder->encState = ES_Final;
1257  
1258  	if((cmsEncoder->encoderOut.Data == NULL) && !cmsEncoder->customCoder) {
1259  		/* not sure how this could happen... */
1260  		dprintf("Successful encode, but no data\n");
1261  		return errSecInternalComponent;
1262  	}
1263  	if(cmsEncoder->customCoder) {
1264  		/* we're done */
1265  		*encodedContent = NULL;
1266  		return errSecSuccess;
1267  	}
1268  	
1269  	/* in two out of three cases, we're done */
1270  	switch(cmsEncoder->op) {
1271  		case EO_Sign:
1272  		case EO_Encrypt:
1273  			*encodedContent = CFDataCreate(NULL, (const UInt8 *)cmsEncoder->encoderOut.Data,	
1274  				cmsEncoder->encoderOut.Length);
1275  			return errSecSuccess;
1276  		case EO_SignEncrypt:
1277  			/* proceed, more work to do */
1278  			break;
1279  	}
1280  	
1281  	/* 
1282  	 * Signing & encrypting.
1283  	 * Due to bugs in the libsecurity_smime encoder, it can't encode nested 
1284  	 * ContentInfos in one shot. So we do another pass, specifying the SignedData
1285  	 * inside of the ContentInfo we just created as the data to encrypt.
1286  	 */
1287  	SecAsn1CoderRef asn1Coder = NULL;
1288  	CSSM_DATA signedData = {0, NULL};
1289  
1290  	ortn = SecAsn1CoderCreate(&asn1Coder);
1291  	if(ortn) {
1292  		return ortn;
1293  	}
1294  	ortn = cmsContentInfoContent(asn1Coder, &cmsEncoder->encoderOut, &signedData);
1295  	if(ortn) {
1296  		goto errOut;
1297  	}
1298  	
1299  	/* now just encrypt that, one-shot */
1300  	ortn = CMSEncode(NULL,			/* no signers this time */
1301  		cmsEncoder->recipients,
1302  		&CSSMOID_PKCS7_SignedData,	/* fake out encoder so it doesn't try to actually
1303  									 *   encode the signedData - this asserts the
1304  									 *   SEC_OID_OTHER OID tag in the EnvelopedData's
1305  									 *   ContentInfo */
1306  		FALSE,						/* detachedContent */
1307  		kCMSAttrNone,				/* signedAttributes - none this time */
1308  		signedData.Data, signedData.Length,
1309  		encodedContent);
1310  
1311  errOut:
1312  	if(asn1Coder) {
1313  		SecAsn1CoderRelease(asn1Coder);
1314  	}
1315  	return ortn;
1316  }
1317  	
1318  #pragma mark --- High-level API ---
1319  
1320  /*
1321   * High-level, one-shot encoder function.
1322   */
1323  OSStatus CMSEncode(
1324  	CFTypeRef			signers,
1325  	CFTypeRef			recipients,
1326  	const CSSM_OID		*eContentType,
1327  	Boolean				detachedContent,
1328  	CMSSignedAttributes	signedAttributes,
1329  	const void			*content,
1330  	size_t				contentLen,
1331  	CFDataRef			*encodedContent)	/* RETURNED */
1332  {
1333  	if((signers == NULL) && (recipients == NULL)) {
1334  		return errSecParam;
1335  	}
1336  	if(encodedContent == NULL) {
1337  		return errSecParam;
1338  	}
1339  	
1340  	CMSEncoderRef cmsEncoder;
1341  	OSStatus ortn;
1342  	
1343  	/* set up the encoder */
1344  	ortn = CMSEncoderCreate(&cmsEncoder);
1345  	if(ortn) {
1346  		return ortn;
1347  	}
1348  	
1349  	/* subsequent errors to errOut: */
1350  	if(signers) {
1351  		ortn = CMSEncoderAddSigners(cmsEncoder, signers);
1352  		if(ortn) {
1353  			goto errOut;
1354  		}
1355  	}
1356  	if(recipients) {
1357  		ortn = CMSEncoderAddRecipients(cmsEncoder, recipients);
1358  		if(ortn) {
1359  			goto errOut;
1360  		}
1361  	}
1362  	if(eContentType) {
1363  		ortn = CMSEncoderSetEncapsulatedContentType(cmsEncoder, eContentType);
1364  		if(ortn) {
1365  			goto errOut;
1366  		}
1367  	}
1368  	if(detachedContent) {
1369  		ortn = CMSEncoderSetHasDetachedContent(cmsEncoder, detachedContent);
1370  		if(ortn) {
1371  			goto errOut;
1372  		}
1373  	}
1374  	if(signedAttributes) {
1375  		ortn = CMSEncoderAddSignedAttributes(cmsEncoder, signedAttributes);
1376  		if(ortn) {
1377  			goto errOut;
1378  		}
1379  	}
1380  	/* GO */
1381  	ortn = CMSEncoderUpdateContent(cmsEncoder, content, contentLen);
1382  	if(ortn) {
1383  		goto errOut;
1384  	}
1385  	ortn = CMSEncoderCopyEncodedContent(cmsEncoder, encodedContent);
1386  	
1387  errOut:
1388  	CFRelease(cmsEncoder);
1389  	return ortn;
1390  }
1391  
1392  OSStatus CMSEncodeContent(
1393  	CFTypeRef			signers,
1394  	CFTypeRef			recipients,
1395  	CFTypeRef			eContentTypeOID,
1396  	Boolean				detachedContent,
1397  	CMSSignedAttributes	signedAttributes,
1398  	const void			*content,
1399  	size_t				contentLen,
1400  	CFDataRef			*encodedContentOut)	/* RETURNED */
1401  {
1402  	// convert eContentTypeOID to a CSSM_OID
1403  	CSSM_OID contentType = { 0, NULL };
1404  	if (eContentTypeOID && convertOid(eContentTypeOID, &contentType) != 0)
1405  		return errSecParam;
1406  	const CSSM_OID *contentTypePtr = (eContentTypeOID) ? &contentType : NULL;
1407  	OSStatus result = CMSEncode(signers, recipients, contentTypePtr,
1408  									detachedContent, signedAttributes,
1409  									content, contentLen, encodedContentOut);
1410  	if (contentType.Data)
1411  		free(contentType.Data);
1412  	return result;
1413  }
1414  
1415  #pragma mark --- SPI routines declared in CMSPrivate.h ---
1416  
1417  /*
1418   * Obtain the SecCmsMessageRef associated with a CMSEncoderRef. 
1419   * If we don't have a SecCmsMessageRef yet, we create one now.
1420   * This is the only place where we go to state ES_Msg. 
1421   */
1422  OSStatus CMSEncoderGetCmsMessage(
1423  	CMSEncoderRef		cmsEncoder,
1424  	SecCmsMessageRef	*cmsMessage)		/* RETURNED */
1425  {
1426  	if((cmsEncoder == NULL) || (cmsMessage == NULL)) {
1427  		return errSecParam;
1428  	}
1429  	if(cmsEncoder->cmsMsg != NULL) {
1430  		ASSERT(cmsEncoder->encState != ES_Init);
1431  		*cmsMessage = cmsEncoder->cmsMsg;
1432  		return errSecSuccess;
1433  	}
1434  
1435  	OSStatus ortn = cmsSetupCmsMsg(cmsEncoder);
1436  	if(ortn) {
1437  		return ortn;
1438  	}
1439  	*cmsMessage = cmsEncoder->cmsMsg;
1440  	
1441  	/* Don't set up encoder yet; caller might do that via CMSEncoderSetEncoder */
1442  	cmsEncoder->encState = ES_Msg;
1443  	return errSecSuccess;
1444  }
1445  
1446  /* 
1447   * Optionally specify a SecCmsEncoderRef to use with a CMSEncoderRef.
1448   * If this is called, it must be called before the first call to 
1449   * CMSEncoderUpdateContent(). The CMSEncoderRef takes ownership of the
1450   * incoming SecCmsEncoderRef.
1451   */
1452  OSStatus CMSEncoderSetEncoder(
1453  	CMSEncoderRef		cmsEncoder,
1454  	SecCmsEncoderRef	encoder)
1455  {
1456  	if((cmsEncoder == NULL) || (encoder == NULL)) {
1457  		return errSecParam;
1458  	}
1459  	
1460  	OSStatus ortn;
1461  	
1462  	switch(cmsEncoder->encState) {
1463  		case ES_Init:
1464  			/* No message, no encoder */
1465  			ASSERT(cmsEncoder->cmsMsg == NULL);
1466  			ASSERT(cmsEncoder->encoder == NULL);
1467  			ortn = cmsSetupCmsMsg(cmsEncoder);
1468  			if(ortn) {
1469  				return ortn;
1470  			}
1471  			/* drop thru to set encoder */
1472  		case ES_Msg:
1473  			/* cmsMsg but no encoder */
1474  			ASSERT(cmsEncoder->cmsMsg != NULL);
1475  			ASSERT(cmsEncoder->encoder == NULL);
1476  			cmsEncoder->encoder = encoder;
1477  			cmsEncoder->encState = ES_Updating;
1478  			cmsEncoder->customCoder = true;			/* we won't see data */
1479  			return errSecSuccess;
1480  		default:
1481  			/* no can do, too late */
1482  			return errSecParam;
1483  	}
1484  }
1485  	
1486  /* 
1487   * Obtain the SecCmsEncoderRef associated with a CMSEncoderRef. 
1488   * Returns a NULL SecCmsEncoderRef if neither CMSEncoderSetEncoder nor
1489   * CMSEncoderUpdateContent() has been called. 
1490   * The CMSEncoderRef retains ownership of the SecCmsEncoderRef.
1491   */
1492  OSStatus CMSEncoderGetEncoder(
1493  	CMSEncoderRef		cmsEncoder,
1494  	SecCmsEncoderRef	*encoder)			/* RETURNED */
1495  {
1496  	if((cmsEncoder == NULL) || (encoder == NULL)) {
1497  		return errSecParam;
1498  	}
1499  	
1500  	/* any state, whether we have an encoder or not is OK */
1501  	*encoder = cmsEncoder->encoder;
1502  	return errSecSuccess;
1503  }
1504  
1505  #include <AssertMacros.h>
1506  
1507  /*
1508   * Obtain the timestamp of signer 'signerIndex' of a CMS message, if
1509   * present. This timestamp is an authenticated timestamp provided by
1510   * a timestamping authority.
1511   *
1512   * Returns errSecParam if the CMS message was not signed or if signerIndex
1513   * is greater than the number of signers of the message minus one. 
1514   *
1515   * This cannot be called until after CMSEncoderCopyEncodedContent() is called. 
1516   */
1517  OSStatus CMSEncoderCopySignerTimestamp(
1518                                         CMSEncoderRef		cmsEncoder,
1519                                         size_t				signerIndex,        /* usually 0 */
1520                                         CFAbsoluteTime      *timestamp)			/* RETURNED */
1521  {
1522      return CMSEncoderCopySignerTimestampWithPolicy(
1523                                         cmsEncoder,
1524                                         NULL,
1525                                         signerIndex,
1526                                         timestamp);
1527  }
1528  
1529  OSStatus CMSEncoderCopySignerTimestampWithPolicy(
1530  	CMSEncoderRef		cmsEncoder,
1531      CFTypeRef            timeStampPolicy,
1532  	size_t				signerIndex,        /* usually 0 */
1533  	CFAbsoluteTime      *timestamp)			/* RETURNED */
1534  {
1535      OSStatus status = errSecParam;
1536  	SecCmsMessageRef cmsg;
1537  	SecCmsSignedDataRef signedData = NULL;
1538      int numContentInfos = 0;
1539  
1540      require(cmsEncoder && timestamp, xit);
1541  	require_noerr(CMSEncoderGetCmsMessage(cmsEncoder, &cmsg), xit);
1542      numContentInfos = SecCmsMessageContentLevelCount(cmsg);
1543      for (int dex = 0; !signedData && dex < numContentInfos; dex++)
1544      {
1545          SecCmsContentInfoRef ci = SecCmsMessageContentLevel(cmsg, dex);
1546          SECOidTag tag = SecCmsContentInfoGetContentTypeTag(ci);
1547          if (tag == SEC_OID_PKCS7_SIGNED_DATA)
1548              if ((signedData = SecCmsSignedDataRef(SecCmsContentInfoGetContent(ci))))
1549                  if (SecCmsSignerInfoRef signerInfo = SecCmsSignedDataGetSignerInfo(signedData, (int)signerIndex))
1550                  {
1551                      status = SecCmsSignerInfoGetTimestampTimeWithPolicy(signerInfo, timeStampPolicy, timestamp);
1552                      break;
1553                  }
1554      }
1555  
1556  xit:
1557      return status;
1558  }