1  /*
   2   * Copyright (c) 2006-2016 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   * CMSDecoder.c - Interface for decoding CMS messages.
  26   */
  27  
  28  #include <Security/CMSDecoder.h>
  29  #include <Security/CMSPrivate.h>
  30  #include "CMSUtils.h"
  31  
  32  #include <Security/SecCmsDecoder.h>
  33  #include <Security/SecCmsEnvelopedData.h>
  34  #include <Security/SecCmsMessage.h>
  35  #include <Security/SecCmsSignedData.h>
  36  #include <Security/SecCmsSignerInfo.h>
  37  #include <Security/SecCmsContentInfo.h>
  38  #include <Security/SecCmsDigestContext.h>
  39  #include <Security/SecCertificate.h>
  40  #include <Security/SecCertificatePriv.h>
  41  #include <Security/SecSMIME.h>
  42  #include <Security/oidsattr.h>
  43  #include <Security/SecTrustPriv.h>
  44  #include <utilities/SecAppleAnchorPriv.h>
  45  #include <utilities/SecCFWrappers.h>
  46  #include <CoreFoundation/CFRuntime.h>
  47  #include <pthread.h>
  48  #include <syslog.h>
  49  #include <AssertMacros.h>
  50  
  51  #pragma mark --- Private types and definitions ---
  52  
  53  /*
  54   * Decoder state.
  55   */
  56  typedef enum {
  57      DS_Init,		/* between CMSDecoderCreate and CMSDecoderUpdateMessage */
  58      DS_Updating,	/* between first CMSDecoderUpdateMessage and CMSDecoderFinalizeMessage */
  59      DS_Final		/* CMSDecoderFinalizeMessage has been called */
  60  } CMSDecoderState;
  61  
  62  /*
  63   * Caller's CMSDecoderRef points to one of these.
  64   */
  65  struct _CMSDecoder {
  66      CFRuntimeBase		base;
  67      CMSDecoderState		decState;
  68      SecCmsDecoderRef	decoder;
  69      CFDataRef			detachedContent;
  70  
  71      /*
  72       * The following are valid (and quiescent) after CMSDecoderFinalizeMessage().
  73       */
  74      SecCmsMessageRef	cmsMsg;
  75      Boolean				wasEncrypted;	/* valid after CMSDecoderFinalizeMessage() */
  76      SecCmsSignedDataRef	signedData;		/* if there is one... */
  77      /* only non-NULL if we found a signedData */
  78      size_t				numSigners;
  79      SecAsn1Oid			*eContentType;
  80      /* etc. */
  81  };
  82  
  83  static void cmsDecoderInit(CFTypeRef dec);
  84  static void cmsDecoderFinalize(CFTypeRef dec);
  85  
  86  static CFRuntimeClass cmsDecoderRuntimeClass =
  87  {
  88      0,			/* version */
  89      "CMSDecoder",
  90      cmsDecoderInit,
  91      NULL,		/* copy */
  92      cmsDecoderFinalize,
  93      NULL,		/* equal - just use pointer equality */
  94      NULL,		/* hash, ditto */
  95      NULL,		/* copyFormattingDesc */
  96      NULL		/* copyDebugDesc */
  97  };
  98  
  99  #pragma mark --- Private Routines ---
 100  
 101  static CFTypeID cmsDecoderTypeID = _kCFRuntimeNotATypeID;
 102  
 103  /* one time only class init, called via pthread_once() in CMSDecoderGetTypeID() */
 104  static void cmsDecoderClassInitialize(void)
 105  {
 106      cmsDecoderTypeID =
 107      _CFRuntimeRegisterClass((const CFRuntimeClass * const)&cmsDecoderRuntimeClass);
 108  }
 109  
 110  /* init called out from _CFRuntimeCreateInstance() */
 111  static void cmsDecoderInit(CFTypeRef dec)
 112  {
 113      char *start = ((char *)dec) + sizeof(CFRuntimeBase);
 114      memset(start, 0, sizeof(struct _CMSDecoder) - sizeof(CFRuntimeBase));
 115  }
 116  
 117  /*
 118   * Dispose of a CMSDecoder. Called out from CFRelease().
 119   */
 120  static void cmsDecoderFinalize(
 121                                 CFTypeRef		dec)
 122  {
 123      CMSDecoderRef cmsDecoder = (CMSDecoderRef)dec;
 124      if(cmsDecoder == NULL) {
 125          return;
 126      }
 127      if(cmsDecoder->decoder != NULL) {
 128          /*
 129           * Normally this gets freed in SecCmsDecoderFinish - this is
 130           * an error case. Unlike Finish, this calls SecCmsMessageDestroy.
 131           */
 132          SecCmsDecoderDestroy(cmsDecoder->decoder);
 133          cmsDecoder->cmsMsg = NULL;
 134      }
 135      CFRELEASE(cmsDecoder->detachedContent);
 136      if(cmsDecoder->cmsMsg != NULL) {
 137          SecCmsMessageDestroy(cmsDecoder->cmsMsg);
 138          cmsDecoder->cmsMsg = NULL;
 139      }
 140  }
 141  
 142  
 143  /*
 144   * Given detached content and a valid (decoded) SignedData, digest the detached
 145   * content. This occurs at the later of {CMSDecoderFinalizeMessage() finding a
 146   * SignedData when already have detachedContent, or CMSDecoderSetDetachedContent()
 147   * when we already have a SignedData).
 148   */
 149  static OSStatus cmsDigestDetachedContent(
 150                                           CMSDecoderRef cmsDecoder)
 151  {
 152      ASSERT((cmsDecoder->signedData != NULL) && (cmsDecoder->detachedContent != NULL));
 153  
 154      SECAlgorithmID **digestAlgorithms = SecCmsSignedDataGetDigestAlgs(cmsDecoder->signedData);
 155      if(digestAlgorithms == NULL) {
 156          return errSecUnknownFormat;
 157      }
 158      SecCmsDigestContextRef digcx = SecCmsDigestContextStartMultiple(digestAlgorithms);
 159      if(digcx == NULL) {
 160          return errSecAllocate;
 161      }
 162  
 163      SecCmsDigestContextUpdate(digcx, CFDataGetBytePtr(cmsDecoder->detachedContent),
 164                                CFDataGetLength(cmsDecoder->detachedContent));
 165      OSStatus ortn = SecCmsSignedDataSetDigestContext(cmsDecoder->signedData, digcx);
 166      SecCmsDigestContextDestroy(digcx);
 167  
 168      if(ortn) {
 169          ortn = cmsRtnToOSStatus(ortn);
 170          CSSM_PERROR("SecCmsSignedDataSetDigestContext", ortn);
 171          return ortn;
 172      }
 173  
 174      return ortn;
 175  }
 176  
 177  #pragma mark --- Start of Public API ---
 178  
 179  CFTypeID CMSDecoderGetTypeID(void)
 180  {
 181      static pthread_once_t once = PTHREAD_ONCE_INIT;
 182  
 183      if(cmsDecoderTypeID == _kCFRuntimeNotATypeID) {
 184          pthread_once(&once, &cmsDecoderClassInitialize);
 185      }
 186      return cmsDecoderTypeID;
 187  }
 188  
 189  /*
 190   * Create a CMSDecoder. Result must eventually be freed via CFRelease().
 191   */
 192  OSStatus CMSDecoderCreate(
 193                            CMSDecoderRef		*cmsDecoderOut)	/* RETURNED */
 194  {
 195      CMSDecoderRef cmsDecoder = NULL;
 196  
 197      uint32_t extra = sizeof(*cmsDecoder) - sizeof(cmsDecoder->base);
 198      cmsDecoder = (CMSDecoderRef)_CFRuntimeCreateInstance(NULL, CMSDecoderGetTypeID(),
 199                                                           extra, NULL);
 200      if(cmsDecoder == NULL) {
 201          return errSecAllocate;
 202      }
 203      cmsDecoder->decState = DS_Init;
 204      *cmsDecoderOut = cmsDecoder;
 205      return errSecSuccess;
 206  }
 207  
 208  /*
 209   * Feed raw bytes of the message to be decoded into the decoder. Can be called
 210   * multiple times.
 211   */
 212  OSStatus CMSDecoderUpdateMessage(
 213                                   CMSDecoderRef		cmsDecoder,
 214                                   const void			*msgBytes,
 215                                   size_t				msgBytesLen)
 216  {
 217      if(cmsDecoder == NULL) {
 218          return errSecParam;
 219      }
 220  
 221      OSStatus ortn;
 222      switch(cmsDecoder->decState) {
 223          case DS_Init:
 224              /* First time through; set up */
 225              ASSERT(cmsDecoder->decoder == NULL);
 226              ortn = SecCmsDecoderCreate(NULL, NULL, NULL, NULL, NULL, NULL, &cmsDecoder->decoder);
 227              if(ortn) {
 228                  ortn = cmsRtnToOSStatus(ortn);
 229                  CSSM_PERROR("SecCmsDecoderCreate", ortn);
 230                  return ortn;
 231              }
 232              cmsDecoder->decState = DS_Updating;
 233              break;
 234  
 235          case DS_Updating:
 236              ASSERT(cmsDecoder->decoder != NULL);
 237              break;
 238  
 239          case DS_Final:
 240              /* Too late for another update */
 241              return errSecParam;
 242  
 243          default:
 244              dprintf("CMSDecoderUpdateMessage: bad decState\n");
 245              return errSecInternalComponent;
 246      }
 247  
 248      /* FIXME - CFIndex same size as size_t on 64bit? */
 249      ortn = SecCmsDecoderUpdate(cmsDecoder->decoder, msgBytes, (CFIndex)msgBytesLen);
 250      if(ortn) {
 251          ortn = cmsRtnToOSStatusDefault(ortn, errSecUnknownFormat);
 252          CSSM_PERROR("SecCmsDecoderUpdate", ortn);
 253      }
 254      return ortn;
 255  }
 256  
 257  /*
 258   * Indicate that no more CMSDecoderUpdateMessage() calls are forthcoming;
 259   * finish decoding the message. We parse the message as best we can, up to
 260   * but not including verifying individual signerInfos.
 261   */
 262  OSStatus CMSDecoderFinalizeMessage(
 263                                     CMSDecoderRef		cmsDecoder)
 264  {
 265      if(cmsDecoder == NULL) {
 266          return errSecParam;
 267      }
 268      if(cmsDecoder->decState != DS_Updating) {
 269          return errSecParam;
 270      }
 271      ASSERT(cmsDecoder->decoder != NULL);
 272      OSStatus ortn = SecCmsDecoderFinish(cmsDecoder->decoder, &cmsDecoder->cmsMsg);
 273      cmsDecoder->decState = DS_Final;
 274  
 275      /* SecCmsDecoderFinish destroyed the decoder even on failure */
 276      cmsDecoder->decoder = NULL;
 277  
 278      if(ortn) {
 279          ortn = cmsRtnToOSStatusDefault(ortn, errSecUnknownFormat);
 280          CSSM_PERROR("SecCmsDecoderFinish", ortn);
 281          return ortn;
 282      }
 283  
 284      ASSERT(cmsDecoder->cmsMsg != NULL);
 285      cmsDecoder->wasEncrypted = SecCmsMessageIsEncrypted(cmsDecoder->cmsMsg);
 286  
 287      /* Look for a SignedData */
 288      int numContentInfos = SecCmsMessageContentLevelCount(cmsDecoder->cmsMsg);
 289      int dex;
 290      for(dex=0; dex<numContentInfos; dex++) {
 291          SecCmsContentInfoRef ci = SecCmsMessageContentLevel(cmsDecoder->cmsMsg, dex);
 292          SECOidTag tag = SecCmsContentInfoGetContentTypeTag(ci);
 293          switch(tag) {
 294              case SEC_OID_PKCS7_SIGNED_DATA:
 295                  cmsDecoder->signedData =
 296                  (SecCmsSignedDataRef)SecCmsContentInfoGetContent(ci);
 297                  /* dig down one more layer for eContentType */
 298                  ci = SecCmsSignedDataGetContentInfo(cmsDecoder->signedData);
 299                  if (ci) {
 300                      cmsDecoder->eContentType = SecCmsContentInfoGetContentTypeOID(ci);
 301                  }
 302                  break;
 303              default:
 304                  break;
 305          }
 306          if(cmsDecoder->signedData != NULL) {
 307              break;
 308          }
 309  
 310      }
 311  
 312      /* minimal processing of optional signedData... */
 313      if(cmsDecoder->signedData != NULL) {
 314          cmsDecoder->numSigners = (size_t)
 315          SecCmsSignedDataSignerInfoCount(cmsDecoder->signedData);
 316          if(cmsDecoder->detachedContent != NULL) {
 317              /* time to calculate digests from detached content */
 318              ortn = cmsDigestDetachedContent(cmsDecoder);
 319          }
 320      }
 321      return ortn;
 322  }
 323  
 324  /*
 325   * A signed CMS message optionally includes the data which was signed. If the
 326   * message does not include the signed data, caller specifies the signed data
 327   * (the "detached content") here.
 328   *
 329   * This can be called either before or after the actual decoding of the message
 330   * (via CMSDecoderUpdateMessage() and CMSDecoderFinalizeMessage()); the only
 331   * restriction is that, if detached content is required, this function must
 332   * be called befoere successfully ascertaining the signature status via
 333   * CMSDecoderCopySignerStatus().
 334   */
 335  OSStatus CMSDecoderSetDetachedContent(
 336                                        CMSDecoderRef		cmsDecoder,
 337                                        CFDataRef			detachedContent)
 338  {
 339      if((cmsDecoder == NULL) || (detachedContent == NULL)) {
 340          return errSecParam;
 341      }
 342      cmsDecoder->detachedContent = detachedContent;
 343      CFRetain(detachedContent);
 344  
 345      if(cmsDecoder->signedData != NULL) {
 346          /* time to calculate digests from detached content */
 347          ASSERT(cmsDecoder->decState == DS_Final);
 348          return cmsDigestDetachedContent(cmsDecoder);
 349      }
 350      return errSecSuccess;
 351  }
 352  
 353  /*
 354   * Obtain the detached content specified in CMSDecoderSetDetachedContent().
 355   * Returns a NULL detachedContent if no detached content has been specified.
 356   * Caller must CFRelease() the result.
 357   */
 358  OSStatus CMSDecoderCopyDetachedContent(
 359                                         CMSDecoderRef		cmsDecoder,
 360                                         CFDataRef			*detachedContent)		/* RETURNED */
 361  {
 362      if((cmsDecoder == NULL) || (detachedContent == NULL)) {
 363          return errSecParam;
 364      }
 365      if(cmsDecoder->detachedContent != NULL) {
 366          CFRetain(cmsDecoder->detachedContent);
 367      }
 368      *detachedContent = cmsDecoder->detachedContent;
 369      return errSecSuccess;
 370  }
 371  
 372  /*
 373   * Obtain the number of signers of a message. A result of zero indicates that
 374   * the message was not signed.
 375   */
 376  OSStatus CMSDecoderGetNumSigners(
 377                                   CMSDecoderRef		cmsDecoder,
 378                                   size_t				*numSigners)			/* RETURNED */
 379  {
 380      if((cmsDecoder == NULL) || (numSigners == NULL)) {
 381          return errSecParam;
 382      }
 383      if(cmsDecoder->decState != DS_Final) {
 384          return errSecParam;
 385      }
 386      *numSigners = cmsDecoder->numSigners;
 387      return errSecSuccess;
 388  }
 389  
 390  /*
 391   * Obtain the status of a CMS message's signature. A CMS message can
 392   * be signed my multiple signers; this function returns the status
 393   * associated with signer 'n' as indicated by the signerIndex parameter.
 394   */
 395  OSStatus CMSDecoderCopySignerStatus(
 396                                      CMSDecoderRef		cmsDecoder,
 397                                      size_t				signerIndex,
 398                                      CFTypeRef			policyOrArray,
 399                                      Boolean				evaluateSecTrust,
 400                                      CMSSignerStatus		*signerStatus,			/* optional; RETURNED */
 401                                      SecTrustRef			*secTrust,				/* optional; RETURNED */
 402                                      OSStatus			*certVerifyResultCode)	/* optional; RETURNED */
 403  {
 404      if((cmsDecoder == NULL) || (cmsDecoder->decState != DS_Final) || (!policyOrArray) || !signerStatus) {
 405          return errSecParam;
 406      }
 407  
 408      /* initialize return values */
 409      if(signerStatus) {
 410          *signerStatus = kCMSSignerUnsigned;
 411      }
 412      if(secTrust) {
 413          *secTrust = NULL;
 414      }
 415      if(certVerifyResultCode) {
 416          *certVerifyResultCode = 0;
 417      }
 418  
 419      if(cmsDecoder->signedData == NULL) {
 420          *signerStatus = kCMSSignerUnsigned;	/* redundant, I know, but explicit */
 421          return errSecSuccess;
 422      }
 423      ASSERT(cmsDecoder->numSigners > 0);
 424      if(signerIndex >= cmsDecoder->numSigners) {
 425          *signerStatus = kCMSSignerInvalidIndex;
 426          return errSecSuccess;
 427      }
 428      if(!SecCmsSignedDataHasDigests(cmsDecoder->signedData)) {
 429          *signerStatus = kCMSSignerNeedsDetachedContent;
 430          return errSecSuccess;
 431      }
 432  
 433      /*
 434       * OK, we should be able to verify this signerInfo.
 435       * I think we have to do the SecCmsSignedDataVerifySignerInfo first
 436       * in order get all the cert pieces into place before returning them
 437       * to the caller.
 438       */
 439      SecTrustRef theTrust = NULL;
 440      OSStatus vfyRtn = SecCmsSignedDataVerifySignerInfo(cmsDecoder->signedData,
 441                                                         (int)signerIndex,
 442                                                         NULL,
 443                                                         policyOrArray,
 444                                                         &theTrust);
 445  
 446  #if SECTRUST_VERBOSE_DEBUG
 447      syslog(LOG_ERR, "CMSDecoderCopySignerStatus: SecCmsSignedDataVerifySignerInfo returned %d", (int)vfyRtn);
 448      if (policyOrArray) CFShow(policyOrArray);
 449      if (theTrust) CFShow(theTrust);
 450  #endif
 451  
 452      /* Subsequent errors to errOut: */
 453  
 454      /*
 455       * NOTE the smime lib did NOT evaluate that SecTrust - it only does
 456       * SecTrustEvaluate() if we don't ask for a copy.
 457       *
 458       * FIXME deal with multitudes of status returns here...for now, proceed with
 459       * obtaining components the caller wants and assume that a nonzero vfyRtn
 460       * means "bad signature".
 461       */
 462      OSStatus ortn = errSecSuccess;
 463      SecTrustResultType secTrustResult;
 464      OSStatus evalRtn, verifyStatus = errSecSuccess;
 465  
 466      if(secTrust != NULL) {
 467          *secTrust = theTrust;
 468          /* we'll release our reference at the end */
 469          CFRetainSafe(theTrust);
 470      }
 471      SecCmsSignerInfoRef signerInfo =
 472      SecCmsSignedDataGetSignerInfo(cmsDecoder->signedData, (int)signerIndex);
 473      if(signerInfo == NULL) {
 474          /* should never happen */
 475          ASSERT(0);
 476          dprintf("CMSDecoderCopySignerStatus: no signerInfo\n");
 477          ortn = errSecInternalComponent;
 478          goto errOut;
 479      }
 480  
 481      /* now do the actual cert verify */
 482      if(evaluateSecTrust) {
 483          evalRtn = SecTrustEvaluate(theTrust, &secTrustResult);
 484          if(evalRtn) {
 485              /* should never happen */
 486              CSSM_PERROR("SecTrustEvaluate", evalRtn);
 487              dprintf("CMSDecoderCopySignerStatus: SecTrustEvaluate error\n");
 488              ortn = errSecInternalComponent;
 489              goto errOut;
 490          }
 491          switch(secTrustResult) {
 492              case kSecTrustResultUnspecified:
 493                  /* cert chain valid, no special UserTrust assignments */
 494              case kSecTrustResultProceed:
 495                  /* cert chain valid AND user explicitly trusts this */
 496                  break;
 497              case kSecTrustResultDeny:
 498                  verifyStatus = errSecTrustSettingDeny;
 499                  break;
 500              default:
 501              {
 502                  verifyStatus = errSecNotTrusted;
 503                  break;
 504              }
 505          } 	/* switch(secTrustResult) */
 506      }		/* evaluateSecTrust true */
 507      if(certVerifyResultCode != NULL) {
 508          *certVerifyResultCode = verifyStatus;
 509      }
 510  
 511      /* cook up global status based on vfyRtn and tpVfyStatus */
 512      if(signerStatus != NULL) {
 513          if((vfyRtn == errSecSuccess) && (verifyStatus == errSecSuccess))  {
 514              *signerStatus = kCMSSignerValid;
 515          }
 516          else if(vfyRtn != errSecSuccess) {
 517              /* this could mean other things, but for now... */
 518              *signerStatus = kCMSSignerInvalidSignature;
 519          }
 520          else {
 521              *signerStatus = kCMSSignerInvalidCert;
 522          }
 523      }
 524  errOut:
 525      CFRELEASE(theTrust);
 526      return ortn;
 527  }
 528  
 529  /*
 530   * Obtain the email address of signer 'signerIndex' of a CMS message, if
 531   * present.
 532   *
 533   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
 534   */
 535  OSStatus CMSDecoderCopySignerEmailAddress(
 536                                            CMSDecoderRef		cmsDecoder,
 537                                            size_t				signerIndex,
 538                                            CFStringRef			*signerEmailAddress)	/* RETURNED */
 539  {
 540      if((cmsDecoder == NULL) ||
 541         (signerEmailAddress == NULL) ||
 542         (cmsDecoder->signedData == NULL) ||			/* not signed */
 543         (signerIndex >= cmsDecoder->numSigners) ||	/* index out of range */
 544         (cmsDecoder->decState != DS_Final)) {
 545          return errSecParam;
 546      }
 547  
 548      SecCmsSignerInfoRef signerInfo =
 549      SecCmsSignedDataGetSignerInfo(cmsDecoder->signedData, (int)signerIndex);
 550      if(signerInfo == NULL) {
 551          /* should never happen */
 552          ASSERT(0);
 553          dprintf("CMSDecoderCopySignerEmailAddress: no signerInfo\n");
 554          return errSecInternalComponent;
 555      }
 556  
 557      /*
 558       * This is leaking memory in libsecurityKeychain per Radar 4412699.
 559       */
 560      *signerEmailAddress = SecCmsSignerInfoGetSignerEmailAddress(signerInfo);
 561      return errSecSuccess;
 562  }
 563  
 564  /*
 565   * Obtain the certificate of signer 'signerIndex' of a CMS message, if
 566   * present.
 567   *
 568   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
 569   */
 570  OSStatus CMSDecoderCopySignerCert(
 571                                    CMSDecoderRef		cmsDecoder,
 572                                    size_t				signerIndex,
 573                                    SecCertificateRef	*signerCert)			/* RETURNED */
 574  {
 575      if((cmsDecoder == NULL) ||
 576         (signerCert == NULL) ||
 577         (cmsDecoder->signedData == NULL) ||			/* not signed */
 578         (signerIndex >= cmsDecoder->numSigners) ||	/* index out of range */
 579         (cmsDecoder->decState != DS_Final)) {
 580          return errSecParam;
 581      }
 582  
 583      SecCmsSignerInfoRef signerInfo =
 584      SecCmsSignedDataGetSignerInfo(cmsDecoder->signedData, (int)signerIndex);
 585      if(signerInfo == NULL) {
 586          /* should never happen */
 587          ASSERT(0);
 588          dprintf("CMSDecoderCopySignerCertificate: no signerInfo\n");
 589          return errSecInternalComponent;
 590      }
 591      *signerCert = SecCmsSignerInfoGetSigningCertificate(signerInfo, NULL);
 592      /* libsecurity_smime does NOT retain that */
 593      if(*signerCert == NULL) {
 594          /* should never happen */
 595          ASSERT(0);
 596          dprintf("CMSDecoderCopySignerCertificate: no signerCert\n");
 597          return errSecInternalComponent;
 598      }
 599      CFRetain(*signerCert);
 600      return errSecSuccess;
 601  }
 602  
 603  /*
 604   * Determine whether a CMS message was encrypted, and if so, whether we were
 605   * able to decrypt it.
 606   */
 607  OSStatus CMSDecoderIsContentEncrypted(
 608                                        CMSDecoderRef	cmsDecoder,
 609                                        Boolean			*wasEncrypted)
 610  {
 611      if((cmsDecoder == NULL) || (wasEncrypted == NULL)) {
 612          return errSecParam;
 613      }
 614      if(cmsDecoder->decState != DS_Final) {
 615          return errSecParam;
 616      }
 617      *wasEncrypted = cmsDecoder->wasEncrypted;
 618      return errSecSuccess;
 619  }
 620  
 621  /*
 622   * Obtain the eContentType OID for a SignedData's EncapsulatedContentType, if
 623   * present.
 624   */
 625  OSStatus CMSDecoderCopyEncapsulatedContentType(
 626                                                 CMSDecoderRef		cmsDecoder,
 627                                                 CFDataRef			*eContentType)		/* RETURNED */
 628  {
 629      if((cmsDecoder == NULL) || (eContentType == NULL)) {
 630          return errSecParam;
 631      }
 632      if(cmsDecoder->decState != DS_Final) {
 633          return errSecParam;
 634      }
 635      if(cmsDecoder->signedData == NULL) {
 636          *eContentType = NULL;
 637      }
 638      else {
 639          SecAsn1Oid *ecOid = cmsDecoder->eContentType;
 640          *eContentType = CFDataCreate(NULL, ecOid->Data, ecOid->Length);
 641      }
 642      return errSecSuccess;
 643  }
 644  
 645  /*
 646   * Obtain an array of all of the certificates in a message. Elements of the
 647   * returned array are SecCertificateRefs. The caller must CFRelease the returned
 648   * array.
 649   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
 650   */
 651  OSStatus CMSDecoderCopyAllCerts(
 652                                  CMSDecoderRef		cmsDecoder,
 653                                  CFArrayRef			*certs)					/* RETURNED */
 654  {
 655      if((cmsDecoder == NULL) || (certs == NULL)) {
 656          return errSecParam;
 657      }
 658      if(cmsDecoder->decState != DS_Final) {
 659          return errSecParam;
 660      }
 661      if(cmsDecoder->signedData == NULL) {
 662          /* message wasn't signed */
 663          *certs = NULL;
 664          return errSecSuccess;
 665      }
 666  
 667      /* NULL_terminated array of CSSM_DATA ptrs */
 668      SecAsn1Item **cssmCerts = SecCmsSignedDataGetCertificateList(cmsDecoder->signedData);
 669      if((cssmCerts == NULL) || (*cssmCerts == NULL)) {
 670          *certs = NULL;
 671          return errSecSuccess;
 672      }
 673  
 674      CFMutableArrayRef allCerts = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 675      SecAsn1Item **cssmCert;
 676      for(cssmCert=cssmCerts; *cssmCert!=NULL; cssmCert++) {
 677          SecCertificateRef cfCert = SecCertificateCreateWithBytes(NULL, (*cssmCert)->Data, (*cssmCert)->Length);
 678          if(!cfCert) {
 679              CFRelease(allCerts);
 680              return errSecDecode;
 681          }
 682          CFArrayAppendValue(allCerts, cfCert);
 683          /* the array holds the only needed refcount */
 684          CFRelease(cfCert);
 685      }
 686      *certs = allCerts;
 687      return errSecSuccess;
 688  }
 689  
 690  /*
 691   * Obtain the actual message content (payload), if any. If the message was
 692   * signed with detached content this will return NULL.
 693   * Caller must CFRelease the result.
 694   */
 695  OSStatus CMSDecoderCopyContent(
 696                                 CMSDecoderRef		cmsDecoder,
 697                                 CFDataRef			*content)				/* RETURNED */
 698  {
 699      if((cmsDecoder == NULL) || (content == NULL)) {
 700          return errSecParam;
 701      }
 702      if(cmsDecoder->decState != DS_Final) {
 703          return errSecParam;
 704      }
 705      if(cmsDecoder->cmsMsg == NULL) {
 706          /* Hmmm....looks like the finalize call failed */
 707          return errSecParam;
 708      }
 709      const SecAsn1Item *odata = SecCmsMessageGetContent(cmsDecoder->cmsMsg);
 710      if((odata == NULL) || (odata->Length == 0)) {
 711          /* i.e., detached content */
 712          *content = NULL;
 713          return errSecSuccess;
 714      }
 715      *content = CFDataCreate(NULL, (const UInt8 *)odata->Data, odata->Length);
 716      return errSecSuccess;
 717  }
 718  
 719  #pragma mark --- SPI declared in CMSPrivate.h ---
 720  
 721  /*
 722   * Obtain the SecCmsMessageRef associated with a CMSDecoderRef. Intended
 723   * to be called after decoding the message (i.e., after
 724   * CMSDecoderFinalizeMessage() to gain finer access to the contents of the
 725   * SecCmsMessageRef than is otherwise available via the CMSDecoder interface.
 726   * Returns a NULL SecCmsMessageRef if CMSDecoderFinalizeMessage() has not been
 727   * called.
 728   *
 729   * The CMSDecoder retains ownership of the returned SecCmsMessageRef.
 730   */
 731  OSStatus CMSDecoderGetCmsMessage(
 732                                   CMSDecoderRef		cmsDecoder,
 733                                   SecCmsMessageRef	*cmsMessage)		/* RETURNED */
 734  {
 735      if((cmsDecoder == NULL) || (cmsMessage == NULL)) {
 736          return errSecParam;
 737      }
 738      /* any state, whether we have a msg or not is OK */
 739      *cmsMessage = cmsDecoder->cmsMsg;
 740      return errSecSuccess;
 741  }
 742  
 743  /*
 744   * Optionally specify a SecCmsDecoderRef to use with a CMSDecoderRef.
 745   * If this is called, it must be called before the first call to
 746   * CMSDecoderUpdateMessage(). The CMSDecoderRef takes ownership of the
 747   * incoming SecCmsDecoderRef.
 748   */
 749  OSStatus CMSDecoderSetDecoder(
 750                                CMSDecoderRef		cmsDecoder,
 751                                SecCmsDecoderRef	decoder)
 752  {
 753      if((cmsDecoder == NULL) || (decoder == NULL)) {
 754          return errSecParam;
 755      }
 756      switch(cmsDecoder->decState) {
 757          case DS_Init:
 758              ASSERT(cmsDecoder->decoder == NULL);
 759              cmsDecoder->decoder = decoder;
 760              cmsDecoder->decState = DS_Updating;
 761              return errSecSuccess;
 762          case DS_Updating:
 763          case DS_Final:
 764              return errSecParam;
 765      }
 766      return errSecSuccess;
 767  }
 768  
 769  /*
 770   * Obtain the SecCmsDecoderRef associated with a CMSDecoderRef.
 771   * Returns a NULL SecCmsDecoderRef if neither CMSDecoderSetDecoder() nor
 772   * CMSDecoderUpdateMessage() has been called.
 773   * The CMSDecoderRef retains ownership of the SecCmsDecoderRef.
 774   */
 775  OSStatus CMSDecoderGetDecoder(
 776                                CMSDecoderRef		cmsDecoder,
 777                                SecCmsDecoderRef	*decoder)			/* RETURNED */
 778  {
 779      if((cmsDecoder == NULL) || (decoder == NULL)) {
 780          return errSecParam;
 781      }
 782      /* any state, whether we have a decoder or not is OK */
 783      *decoder = cmsDecoder->decoder;
 784      return errSecSuccess;
 785  }
 786  
 787  /*
 788   * Obtain the signing time of signer 'signerIndex' of a CMS message, if
 789   * present. This is an unauthenticate time, although it is part of the
 790   * signed attributes of the message.
 791   *
 792   * Returns errSecParam if the CMS message was not signed or if signerIndex
 793   * is greater than the number of signers of the message minus one.
 794   *
 795   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
 796   */
 797  OSStatus CMSDecoderCopySignerSigningTime(
 798                                           CMSDecoderRef		cmsDecoder,
 799                                           size_t				signerIndex,            /* usually 0 */
 800                                           CFAbsoluteTime      *signingTime)			/* RETURNED */
 801  {
 802      OSStatus status = errSecParam;
 803      SecCmsMessageRef cmsg;
 804      SecCmsSignedDataRef signedData = NULL;
 805      int numContentInfos = 0;
 806  
 807      require(cmsDecoder && signingTime, xit);
 808      require_noerr(CMSDecoderGetCmsMessage(cmsDecoder, &cmsg), xit);
 809      numContentInfos = SecCmsMessageContentLevelCount(cmsg);
 810      for (int dex = 0; !signedData && dex < numContentInfos; dex++)
 811      {
 812          SecCmsContentInfoRef ci = SecCmsMessageContentLevel(cmsg, dex);
 813          SECOidTag tag = SecCmsContentInfoGetContentTypeTag(ci);
 814          if (tag == SEC_OID_PKCS7_SIGNED_DATA)
 815              if ((signedData = (SecCmsSignedDataRef)SecCmsContentInfoGetContent(ci))) {
 816                  SecCmsSignerInfoRef signerInfo = SecCmsSignedDataGetSignerInfo(signedData, (int)signerIndex);
 817                  if (signerInfo)
 818                  {
 819                      status = SecCmsSignerInfoGetSigningTime(signerInfo, signingTime);
 820                      break;
 821                  }
 822              }
 823      }
 824  xit:
 825      return status;
 826  }
 827  
 828  #if TIMESTAMPING_SUPPORTED
 829  /*
 830   * Obtain the timestamp of signer 'signerIndex' of a CMS message, if
 831   * present. This timestamp is an authenticated timestamp provided by
 832   * a timestamping authority.
 833   *
 834   * Returns errSecParam if the CMS message was not signed or if signerIndex
 835   * is greater than the number of signers of the message minus one.
 836   *
 837   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
 838   */
 839  
 840  OSStatus CMSDecoderCopySignerTimestamp(
 841                                         CMSDecoderRef		cmsDecoder,
 842                                         size_t				signerIndex,        /* usually 0 */
 843                                         CFAbsoluteTime      *timestamp)			/* RETURNED */
 844  {
 845      return CMSDecoderCopySignerTimestampWithPolicy(cmsDecoder, NULL, signerIndex, timestamp);
 846  }
 847  
 848  OSStatus CMSDecoderCopySignerTimestampWithPolicy(
 849                                                   CMSDecoderRef		cmsDecoder,
 850                                                   CFTypeRef            timeStampPolicy,
 851                                                   size_t				signerIndex,        /* usually 0 */
 852                                                   CFAbsoluteTime      *timestamp)			/* RETURNED */
 853  {
 854      OSStatus status = errSecParam;
 855      SecCmsMessageRef cmsg;
 856      SecCmsSignedDataRef signedData = NULL;
 857      int numContentInfos = 0;
 858  
 859      require(cmsDecoder && timestamp, xit);
 860      require_noerr(CMSDecoderGetCmsMessage(cmsDecoder, &cmsg), xit);
 861      numContentInfos = SecCmsMessageContentLevelCount(cmsg);
 862      for (int dex = 0; !signedData && dex < numContentInfos; dex++)
 863      {
 864          SecCmsContentInfoRef ci = SecCmsMessageContentLevel(cmsg, dex);
 865          SECOidTag tag = SecCmsContentInfoGetContentTypeTag(ci);
 866          if (tag == SEC_OID_PKCS7_SIGNED_DATA)
 867              if ((signedData = (SecCmsSignedDataRef)SecCmsContentInfoGetContent(ci))) {
 868                  SecCmsSignerInfoRef signerInfo = SecCmsSignedDataGetSignerInfo(signedData, (int)signerIndex);
 869                  if (signerInfo)
 870                  {
 871                      status = SecCmsSignerInfoGetTimestampTimeWithPolicy(signerInfo, timeStampPolicy, timestamp);
 872                      break;
 873                  }
 874              }
 875      }
 876  
 877  xit:
 878      return status;
 879  }
 880  
 881  /*
 882   * Obtain an array of the certificates in a timestamp response. Elements of the
 883   * returned array are SecCertificateRefs. The caller must CFRelease the returned
 884   * array. This timestamp is an authenticated timestamp provided by
 885   * a timestamping authority.
 886   *
 887   * Returns errSecParam if the CMS message was not signed or if signerIndex
 888   * is greater than the number of signers of the message minus one. It returns
 889   * errSecItemNotFound if no certificates were found.
 890   *
 891   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
 892   */
 893  OSStatus CMSDecoderCopySignerTimestampCertificates(
 894                                                     CMSDecoderRef		cmsDecoder,
 895                                                     size_t				signerIndex,            /* usually 0 */
 896                                                     CFArrayRef          *certificateRefs)       /* RETURNED */
 897  {
 898      OSStatus status = errSecParam;
 899      SecCmsMessageRef cmsg = NULL;
 900      SecCmsSignedDataRef signedData = NULL;
 901      int numContentInfos = 0;
 902      CFIndex tsn = 0;
 903      bool good = false;
 904  
 905      require(cmsDecoder && certificateRefs, xit);
 906      require_noerr(CMSDecoderGetCmsMessage(cmsDecoder, &cmsg), xit);
 907      numContentInfos = SecCmsMessageContentLevelCount(cmsg);
 908      for (int dex = 0; !signedData && dex < numContentInfos; dex++)
 909      {
 910          SecCmsContentInfoRef ci = SecCmsMessageContentLevel(cmsg, dex);
 911          SECOidTag tag = SecCmsContentInfoGetContentTypeTag(ci);
 912          if (tag == SEC_OID_PKCS7_SIGNED_DATA)
 913              if ((signedData = (SecCmsSignedDataRef)SecCmsContentInfoGetContent(ci))) {
 914                  SecCmsSignerInfoRef signerInfo = SecCmsSignedDataGetSignerInfo(signedData, (int)signerIndex);
 915                  if (signerInfo)
 916                  {
 917                      CFArrayRef certList = SecCmsSignerInfoGetTimestampCertList(signerInfo);
 918                      require_action(certList, xit, status = errSecItemNotFound);
 919                      CFMutableArrayRef certs = CFArrayCreateMutableCopy(kCFAllocatorDefault, CFArrayGetCount(certList), certList);
 920  
 921                      if(certs){
 922                          //reorder certificates:
 923                          tsn = CFArrayGetCount(certs);
 924                          good = tsn > 0 && SecIsAppleTrustAnchor((SecCertificateRef)CFArrayGetValueAtIndex(certs, tsn-1), 0);
 925  
 926                          if ( good == false )
 927                          {
 928                              //change TS certificate ordering.
 929                              for (CFIndex n = 0; n < tsn; n++)
 930                              {
 931                                  SecCertificateRef tsRoot = (SecCertificateRef)CFArrayGetValueAtIndex(certs, n);
 932                                  if (tsRoot)
 933                                      if ((good = SecIsAppleTrustAnchor(tsRoot, 0))) {
 934                                          CFArrayExchangeValuesAtIndices(certs, n, tsn-1);
 935                                          break;
 936                                      }
 937                              }
 938                          }
 939                          
 940                          *certificateRefs = CFArrayCreateCopy(kCFAllocatorDefault, certs);
 941                          CFRelease(certs);
 942                          status = errSecSuccess;
 943                      }
 944                      break;
 945                  }
 946              }
 947      }
 948      
 949      
 950  xit:
 951      return status;
 952  }
 953  #endif
 954  
 955  /*
 956   * Obtain the Hash Agility attribute value of signer 'signerIndex'
 957   * of a CMS message, if present.
 958   *
 959   * Returns errSecParam if the CMS message was not signed or if signerIndex
 960   * is greater than the number of signers of the message minus one.
 961   *
 962   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
 963   */
 964  OSStatus CMSDecoderCopySignerAppleCodesigningHashAgility(
 965                                                           CMSDecoderRef		cmsDecoder,
 966                                                           size_t				signerIndex,            /* usually 0 */
 967                                                           CFDataRef  CF_RETURNS_RETAINED *hashAgilityAttrValue)			/* RETURNED */
 968  {
 969      OSStatus status = errSecParam;
 970      SecCmsMessageRef cmsg;
 971      SecCmsSignedDataRef signedData = NULL;
 972      int numContentInfos = 0;
 973      CFDataRef returnedValue = NULL;
 974      
 975      require(cmsDecoder && hashAgilityAttrValue, exit);
 976      require_noerr(CMSDecoderGetCmsMessage(cmsDecoder, &cmsg), exit);
 977      numContentInfos = SecCmsMessageContentLevelCount(cmsg);
 978      for (int dex = 0; !signedData && dex < numContentInfos; dex++)
 979      {
 980          SecCmsContentInfoRef ci = SecCmsMessageContentLevel(cmsg, dex);
 981          SECOidTag tag = SecCmsContentInfoGetContentTypeTag(ci);
 982          if (tag == SEC_OID_PKCS7_SIGNED_DATA)
 983              if ((signedData = (SecCmsSignedDataRef)SecCmsContentInfoGetContent(ci))) {
 984                  SecCmsSignerInfoRef signerInfo = SecCmsSignedDataGetSignerInfo(signedData, (int)signerIndex);
 985                  if (signerInfo)
 986                  {
 987                      status = SecCmsSignerInfoGetAppleCodesigningHashAgility(signerInfo, &returnedValue);
 988                      break;
 989                  }
 990              }
 991      }
 992  exit:
 993      if (status == errSecSuccess && returnedValue) {
 994          *hashAgilityAttrValue = (CFDataRef) CFRetain(returnedValue);
 995      } else {
 996          *hashAgilityAttrValue = NULL;
 997      }
 998      return status;
 999  }
1000  
1001  /*
1002   * Obtain the Hash Agility V2 attribute value of signer 'signerIndex'
1003   * of a CMS message, if present.
1004   *
1005   * Returns errSecParam if the CMS message was not signed or if signerIndex
1006   * is greater than the number of signers of the message minus one.
1007   *
1008   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
1009   */
1010  OSStatus CMSDecoderCopySignerAppleCodesigningHashAgilityV2(
1011       CMSDecoderRef        cmsDecoder,
1012       size_t                signerIndex,            /* usually 0 */
1013       CFDictionaryRef  CF_RETURNS_RETAINED *hashAgilityV2AttrValues)            /* RETURNED */
1014  {
1015      OSStatus status = errSecParam;
1016      SecCmsMessageRef cmsg;
1017      SecCmsSignedDataRef signedData = NULL;
1018      int numContentInfos = 0;
1019      CFDictionaryRef returnedValue = NULL;
1020  
1021      require(cmsDecoder && hashAgilityV2AttrValues, exit);
1022      require_noerr(CMSDecoderGetCmsMessage(cmsDecoder, &cmsg), exit);
1023      numContentInfos = SecCmsMessageContentLevelCount(cmsg);
1024      for (int dex = 0; !signedData && dex < numContentInfos; dex++)
1025      {
1026          SecCmsContentInfoRef ci = SecCmsMessageContentLevel(cmsg, dex);
1027          SECOidTag tag = SecCmsContentInfoGetContentTypeTag(ci);
1028          if (tag == SEC_OID_PKCS7_SIGNED_DATA)
1029              if ((signedData = (SecCmsSignedDataRef)SecCmsContentInfoGetContent(ci))) {
1030                  SecCmsSignerInfoRef signerInfo = SecCmsSignedDataGetSignerInfo(signedData, (int)signerIndex);
1031                  if (signerInfo)
1032                  {
1033                      status = SecCmsSignerInfoGetAppleCodesigningHashAgilityV2(signerInfo, &returnedValue);
1034                      break;
1035                  }
1036              }
1037      }
1038  exit:
1039      if (status == errSecSuccess && returnedValue) {
1040          *hashAgilityV2AttrValues = (CFDictionaryRef) CFRetain(returnedValue);
1041      } else {
1042          *hashAgilityV2AttrValues = NULL;
1043      }
1044      return status;
1045  }
1046  
1047  /*
1048   * Obtain the expiration time of signer 'signerIndex' of a CMS message, if
1049   * present. This is part of the signed attributes of the message.
1050   *
1051   * Returns errSecParam if the CMS message was not signed or if signerIndex
1052   * is greater than the number of signers of the message minus one.
1053   *
1054   * This cannot be called until after CMSDecoderFinalizeMessage() is called.
1055   */
1056  OSStatus CMSDecoderCopySignerAppleExpirationTime(
1057      CMSDecoderRef      cmsDecoder,
1058      size_t             signerIndex,
1059      CFAbsoluteTime     *expirationTime)            /* RETURNED */
1060  {
1061      OSStatus status = errSecParam;
1062      SecCmsMessageRef cmsg = NULL;
1063      int numContentInfos = 0;
1064      SecCmsSignedDataRef signedData = NULL;
1065  
1066      require(cmsDecoder && expirationTime, xit);
1067      require_noerr(CMSDecoderGetCmsMessage(cmsDecoder, &cmsg), xit);
1068      numContentInfos = SecCmsMessageContentLevelCount(cmsg);
1069      for (int dex = 0; !signedData && dex < numContentInfos; dex++) {
1070          SecCmsContentInfoRef ci = SecCmsMessageContentLevel(cmsg, dex);
1071          SECOidTag tag = SecCmsContentInfoGetContentTypeTag(ci);
1072          if (tag == SEC_OID_PKCS7_SIGNED_DATA) {
1073              if ((signedData = (SecCmsSignedDataRef)SecCmsContentInfoGetContent(ci))) {
1074                  SecCmsSignerInfoRef signerInfo = SecCmsSignedDataGetSignerInfo(signedData, (int)signerIndex);
1075                  if (signerInfo) {
1076                      status = SecCmsSignerInfoGetAppleExpirationTime(signerInfo, expirationTime);
1077                      break;
1078                  }
1079              }
1080          }
1081      }
1082  xit:
1083      return status;
1084  }