tor-browser

p7common.c (19796B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
* PKCS7 implementation -- the exported parts that are used whether
* creating or decoding.
*/

#include "p7local.h"

#include "cert.h"
#include "secitem.h"
#include "secoid.h"
#include "pk11func.h"

/*
* Find out (saving pointer to lookup result for future reference)
* and return the inner content type.
*/
SECOidTag
SEC_PKCS7ContentType(SEC_PKCS7ContentInfo *cinfo)
{
   if (cinfo->contentTypeTag == NULL)
       cinfo->contentTypeTag = SECOID_FindOID(&(cinfo->contentType));

   if (cinfo->contentTypeTag == NULL)
       return SEC_OID_UNKNOWN;

   return cinfo->contentTypeTag->offset;
}

/*
* Destroy a PKCS7 contentInfo and all of its sub-pieces.
*/
void
SEC_PKCS7DestroyContentInfo(SEC_PKCS7ContentInfo *cinfo)
{
   SECOidTag kind;
   CERTCertificate **certs;
   CERTCertificateList **certlists;
   SEC_PKCS7SignerInfo **signerinfos;
   SEC_PKCS7RecipientInfo **recipientinfos;

   PORT_Assert(cinfo->refCount > 0);
   if (cinfo->refCount <= 0)
       return;

   cinfo->refCount--;
   if (cinfo->refCount > 0)
       return;

   certs = NULL;
   certlists = NULL;
   recipientinfos = NULL;
   signerinfos = NULL;

   kind = SEC_PKCS7ContentType(cinfo);
   switch (kind) {
       case SEC_OID_PKCS7_ENVELOPED_DATA: {
           SEC_PKCS7EnvelopedData *edp;

           edp = cinfo->content.envelopedData;
           if (edp != NULL) {
               recipientinfos = edp->recipientInfos;
           }
       } break;
       case SEC_OID_PKCS7_SIGNED_DATA: {
           SEC_PKCS7SignedData *sdp;

           sdp = cinfo->content.signedData;
           if (sdp != NULL) {
               certs = sdp->certs;
               certlists = sdp->certLists;
               signerinfos = sdp->signerInfos;
           }
       } break;
       case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA: {
           SEC_PKCS7SignedAndEnvelopedData *saedp;

           saedp = cinfo->content.signedAndEnvelopedData;
           if (saedp != NULL) {
               certs = saedp->certs;
               certlists = saedp->certLists;
               recipientinfos = saedp->recipientInfos;
               signerinfos = saedp->signerInfos;
               if (saedp->sigKey != NULL)
                   PK11_FreeSymKey(saedp->sigKey);
           }
       } break;
       default:
           /* XXX Anything else that needs to be "manually" freed/destroyed? */
           break;
   }

   if (certs != NULL) {
       CERTCertificate *cert;

       while ((cert = *certs++) != NULL) {
           CERT_DestroyCertificate(cert);
       }
   }

   if (certlists != NULL) {
       CERTCertificateList *certlist;

       while ((certlist = *certlists++) != NULL) {
           CERT_DestroyCertificateList(certlist);
       }
   }

   if (recipientinfos != NULL) {
       SEC_PKCS7RecipientInfo *ri;

       while ((ri = *recipientinfos++) != NULL) {
           if (ri->cert != NULL)
               CERT_DestroyCertificate(ri->cert);
       }
   }

   if (signerinfos != NULL) {
       SEC_PKCS7SignerInfo *si;

       while ((si = *signerinfos++) != NULL) {
           if (si->cert != NULL)
               CERT_DestroyCertificate(si->cert);
           if (si->certList != NULL)
               CERT_DestroyCertificateList(si->certList);
       }
   }

   if (cinfo->poolp != NULL) {
       PORT_FreeArena(cinfo->poolp, PR_FALSE); /* XXX clear it? */
   }
}

/*
* Return a copy of the given contentInfo.  The copy may be virtual
* or may be real -- either way, the result needs to be passed to
* SEC_PKCS7DestroyContentInfo later (as does the original).
*/
SEC_PKCS7ContentInfo *
SEC_PKCS7CopyContentInfo(SEC_PKCS7ContentInfo *cinfo)
{
   if (cinfo == NULL)
       return NULL;

   PORT_Assert(cinfo->refCount > 0);

   if (cinfo->created) {
       /*
        * Want to do a real copy of these; otherwise subsequent
        * changes made to either copy are likely to be a surprise.
        * XXX I suspect that this will not actually be called for yet,
        * which is why the assert, so to notice if it is...
        */
       PORT_Assert(0);
       /*
        * XXX Create a new pool here, and copy everything from
        * within.  For cert stuff, need to call the appropriate
        * copy functions, etc.
        */
   }

   cinfo->refCount++;
   return cinfo;
}

/*
* Return a pointer to the actual content.  In the case of those types
* which are encrypted, this returns the *plain* content.
* XXX Needs revisiting if/when we handle nested encrypted types.
*/
SECItem *
SEC_PKCS7GetContent(SEC_PKCS7ContentInfo *cinfo)
{
   SECOidTag kind;

   kind = SEC_PKCS7ContentType(cinfo);
   switch (kind) {
       case SEC_OID_PKCS7_DATA:
           return cinfo->content.data;
       case SEC_OID_PKCS7_DIGESTED_DATA: {
           SEC_PKCS7DigestedData *digd;

           digd = cinfo->content.digestedData;
           if (digd == NULL)
               break;
           return SEC_PKCS7GetContent(&(digd->contentInfo));
       }
       case SEC_OID_PKCS7_ENCRYPTED_DATA: {
           SEC_PKCS7EncryptedData *encd;

           encd = cinfo->content.encryptedData;
           if (encd == NULL)
               break;
           return &(encd->encContentInfo.plainContent);
       }
       case SEC_OID_PKCS7_ENVELOPED_DATA: {
           SEC_PKCS7EnvelopedData *envd;

           envd = cinfo->content.envelopedData;
           if (envd == NULL)
               break;
           return &(envd->encContentInfo.plainContent);
       }
       case SEC_OID_PKCS7_SIGNED_DATA: {
           SEC_PKCS7SignedData *sigd;

           sigd = cinfo->content.signedData;
           if (sigd == NULL)
               break;
           return SEC_PKCS7GetContent(&(sigd->contentInfo));
       }
       case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA: {
           SEC_PKCS7SignedAndEnvelopedData *saed;

           saed = cinfo->content.signedAndEnvelopedData;
           if (saed == NULL)
               break;
           return &(saed->encContentInfo.plainContent);
       }
       default:
           PORT_Assert(0);
           break;
   }

   return NULL;
}

/*
* XXX Fix the placement and formatting of the
* following routines (i.e. make them consistent with the rest of
* the pkcs7 code -- I think some/many belong in other files and
* they all need a formatting/style rehaul)
*/

/* retrieve the algorithm identifier for encrypted data.
* the identifier returned is a copy of the algorithm identifier
* in the content info and needs to be freed after being used.
*
*   cinfo is the content info for which to retrieve the
*     encryption algorithm.
*
* if the content info is not encrypted data or an error
* occurs NULL is returned.
*/
SECAlgorithmID *
SEC_PKCS7GetEncryptionAlgorithm(SEC_PKCS7ContentInfo *cinfo)
{
   SECAlgorithmID *alg = 0;
   switch (SEC_PKCS7ContentType(cinfo)) {
       case SEC_OID_PKCS7_ENCRYPTED_DATA:
           alg = &cinfo->content.encryptedData->encContentInfo.contentEncAlg;
           break;
       case SEC_OID_PKCS7_ENVELOPED_DATA:
           alg = &cinfo->content.envelopedData->encContentInfo.contentEncAlg;
           break;
       case SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA:
           alg = &cinfo->content.signedAndEnvelopedData
                      ->encContentInfo.contentEncAlg;
           break;
       default:
           alg = 0;
           break;
   }

   return alg;
}

/* set the content of the content info.  For data content infos,
* the data is set.  For encrytped content infos, the plainContent
* is set, and is expected to be encrypted later.
*
* cinfo is the content info where the data will be set
*
* buf is a buffer of the data to set
*
* len is the length of the data being set.
*
* in the event of an error, SECFailure is returned.  SECSuccess
* indicates the content was successfully set.
*/
SECStatus
SEC_PKCS7SetContent(SEC_PKCS7ContentInfo *cinfo,
                   const char *buf,
                   unsigned long len)
{
   SECOidTag cinfo_type;
   SECStatus rv;
   SECItem content;
   SECOidData *contentTypeTag = NULL;

   content.type = siBuffer;
   content.data = (unsigned char *)buf;
   content.len = len;

   cinfo_type = SEC_PKCS7ContentType(cinfo);

   /* set inner content */
   switch (cinfo_type) {
       case SEC_OID_PKCS7_SIGNED_DATA:
           if (content.len > 0) {
               /* we "leak" the old content here, but as it's all in the pool */
               /* it does not really matter */

               /* create content item if necessary */
               if (cinfo->content.signedData->contentInfo.content.data == NULL)
                   cinfo->content.signedData->contentInfo.content.data = SECITEM_AllocItem(cinfo->poolp, NULL, 0);
               rv = SECITEM_CopyItem(cinfo->poolp,
                                     cinfo->content.signedData->contentInfo.content.data,
                                     &content);
           } else {
               cinfo->content.signedData->contentInfo.content.data->data = NULL;
               cinfo->content.signedData->contentInfo.content.data->len = 0;
               rv = SECSuccess;
           }
           if (rv == SECFailure)
               goto loser;

           break;
       case SEC_OID_PKCS7_ENCRYPTED_DATA:
           /* XXX this forces the inner content type to be "data" */
           /* do we really want to override without asking or reason? */
           contentTypeTag = SECOID_FindOIDByTag(SEC_OID_PKCS7_DATA);
           if (contentTypeTag == NULL)
               goto loser;
           rv = SECITEM_CopyItem(cinfo->poolp,
                                 &(cinfo->content.encryptedData->encContentInfo.contentType),
                                 &(contentTypeTag->oid));
           if (rv == SECFailure)
               goto loser;
           if (content.len > 0) {
               rv = SECITEM_CopyItem(cinfo->poolp,
                                     &(cinfo->content.encryptedData->encContentInfo.plainContent),
                                     &content);
           } else {
               cinfo->content.encryptedData->encContentInfo.plainContent.data = NULL;
               cinfo->content.encryptedData->encContentInfo.encContent.data = NULL;
               cinfo->content.encryptedData->encContentInfo.plainContent.len = 0;
               cinfo->content.encryptedData->encContentInfo.encContent.len = 0;
               rv = SECSuccess;
           }
           if (rv == SECFailure)
               goto loser;
           break;
       case SEC_OID_PKCS7_DATA:
           cinfo->content.data = (SECItem *)PORT_ArenaZAlloc(cinfo->poolp,
                                                             sizeof(SECItem));
           if (cinfo->content.data == NULL)
               goto loser;
           if (content.len > 0) {
               rv = SECITEM_CopyItem(cinfo->poolp,
                                     cinfo->content.data, &content);
           } else {
               /* handle case with NULL content */
               rv = SECSuccess;
           }
           if (rv == SECFailure)
               goto loser;
           break;
       default:
           goto loser;
   }

   return SECSuccess;

loser:

   return SECFailure;
}

/* the content of an encrypted data content info is encrypted.
* it is assumed that for encrypted data, that the data has already
* been set and is in the "plainContent" field of the content info.
*
* cinfo is the content info to encrypt
*
* key is the key with which to perform the encryption.  if the
*     algorithm is a password based encryption algorithm, the
*     key is actually a password which will be processed per
*     PKCS #5.
*
* in the event of an error, SECFailure is returned.  SECSuccess
* indicates a success.
*/
SECStatus
SEC_PKCS7EncryptContents(PLArenaPool *poolp,
                        SEC_PKCS7ContentInfo *cinfo,
                        SECItem *key,
                        void *wincx)
{
   SECAlgorithmID *algid = NULL;
   SECItem *src;
   SECItem *dest;
   SECItem *blocked_data = NULL;
   void *mark;
   void *cx;
   PK11SymKey *eKey = NULL;
   PK11SlotInfo *slot = NULL;

   CK_MECHANISM_TYPE cryptoMechType;
   int bs;
   SECStatus rv = SECFailure;
   SECItem *c_param = NULL;

   if ((cinfo == NULL) || (key == NULL))
       return SECFailure;

   if (SEC_PKCS7ContentType(cinfo) != SEC_OID_PKCS7_ENCRYPTED_DATA)
       return SECFailure;

   algid = SEC_PKCS7GetEncryptionAlgorithm(cinfo);
   if (algid == NULL)
       return SECFailure;

   if (poolp == NULL)
       poolp = cinfo->poolp;

   mark = PORT_ArenaMark(poolp);

   src = &cinfo->content.encryptedData->encContentInfo.plainContent;
   dest = &cinfo->content.encryptedData->encContentInfo.encContent;
   dest->data = (unsigned char *)PORT_ArenaZAlloc(poolp, (src->len + 64));
   dest->len = (src->len + 64);
   if (dest->data == NULL) {
       rv = SECFailure;
       goto loser;
   }

   slot = PK11_GetInternalKeySlot();
   if (slot == NULL) {
       rv = SECFailure;
       goto loser;
   }

   eKey = PK11_PBEKeyGen(slot, algid, key, PR_FALSE, wincx);
   if (eKey == NULL) {
       rv = SECFailure;
       goto loser;
   }

   cryptoMechType = PK11_GetPBECryptoMechanism(algid, &c_param, key);
   if (cryptoMechType == CKM_INVALID_MECHANISM) {
       rv = SECFailure;
       goto loser;
   }

   /* block according to PKCS 8 */
   bs = PK11_GetBlockSize(cryptoMechType, c_param);
   rv = SECSuccess;
   if (bs) {
       char pad_char;
       pad_char = (char)(bs - (src->len % bs));
       if (src->len % bs) {
           rv = SECSuccess;
           blocked_data = PK11_BlockData(src, bs);
           if (blocked_data) {
               PORT_Memset((blocked_data->data + blocked_data->len - (int)pad_char),
                           pad_char, (int)pad_char);
           } else {
               rv = SECFailure;
               goto loser;
           }
       } else {
           blocked_data = SECITEM_DupItem(src);
           if (blocked_data) {
               blocked_data->data = (unsigned char *)PORT_Realloc(
                   blocked_data->data,
                   blocked_data->len + bs);
               if (blocked_data->data) {
                   blocked_data->len += bs;
                   PORT_Memset((blocked_data->data + src->len), (char)bs, bs);
               } else {
                   rv = SECFailure;
                   goto loser;
               }
           } else {
               rv = SECFailure;
               goto loser;
           }
       }
   } else {
       blocked_data = SECITEM_DupItem(src);
       if (!blocked_data) {
           rv = SECFailure;
           goto loser;
       }
   }

   cx = PK11_CreateContextBySymKey(cryptoMechType, CKA_ENCRYPT,
                                   eKey, c_param);
   if (cx == NULL) {
       rv = SECFailure;
       goto loser;
   }

   rv = PK11_CipherOp((PK11Context *)cx, dest->data, (int *)(&dest->len),
                      (int)(src->len + 64), blocked_data->data,
                      (int)blocked_data->len);
   PK11_DestroyContext((PK11Context *)cx, PR_TRUE);

loser:
   /* let success fall through */
   if (blocked_data != NULL)
       SECITEM_ZfreeItem(blocked_data, PR_TRUE);

   if (rv == SECFailure)
       PORT_ArenaRelease(poolp, mark);
   else
       PORT_ArenaUnmark(poolp, mark);

   if (eKey != NULL)
       PK11_FreeSymKey(eKey);

   if (slot != NULL)
       PK11_FreeSlot(slot);

   if (c_param != NULL)
       SECITEM_ZfreeItem(c_param, PR_TRUE);

   return rv;
}

/* the content of an encrypted data content info is decrypted.
* it is assumed that for encrypted data, that the data has already
* been set and is in the "encContent" field of the content info.
*
* cinfo is the content info to decrypt
*
* key is the key with which to perform the decryption.  if the
*     algorithm is a password based encryption algorithm, the
*     key is actually a password which will be processed per
*     PKCS #5.
*
* in the event of an error, SECFailure is returned.  SECSuccess
* indicates a success.
*/
SECStatus
SEC_PKCS7DecryptContents(PLArenaPool *poolp,
                        SEC_PKCS7ContentInfo *cinfo,
                        SECItem *key,
                        void *wincx)
{
   SECAlgorithmID *algid = NULL;
   SECStatus rv = SECFailure;
   SECItem *dest, *src;
   void *mark;

   PK11SymKey *eKey = NULL;
   PK11SlotInfo *slot = NULL;
   CK_MECHANISM_TYPE cryptoMechType;
   void *cx;
   SECItem *c_param = NULL;
   int bs;

   if ((cinfo == NULL) || (key == NULL))
       return SECFailure;

   if (SEC_PKCS7ContentType(cinfo) != SEC_OID_PKCS7_ENCRYPTED_DATA)
       return SECFailure;

   algid = SEC_PKCS7GetEncryptionAlgorithm(cinfo);
   if (algid == NULL)
       return SECFailure;

   if (poolp == NULL)
       poolp = cinfo->poolp;

   mark = PORT_ArenaMark(poolp);

   src = &cinfo->content.encryptedData->encContentInfo.encContent;
   dest = &cinfo->content.encryptedData->encContentInfo.plainContent;
   dest->data = (unsigned char *)PORT_ArenaZAlloc(poolp, (src->len + 64));
   dest->len = (src->len + 64);
   if (dest->data == NULL) {
       rv = SECFailure;
       goto loser;
   }

   slot = PK11_GetInternalKeySlot();
   if (slot == NULL) {
       rv = SECFailure;
       goto loser;
   }

   eKey = PK11_PBEKeyGen(slot, algid, key, PR_FALSE, wincx);
   if (eKey == NULL) {
       rv = SECFailure;
       goto loser;
   }

   cryptoMechType = PK11_GetPBECryptoMechanism(algid, &c_param, key);
   if (cryptoMechType == CKM_INVALID_MECHANISM) {
       rv = SECFailure;
       goto loser;
   }

   cx = PK11_CreateContextBySymKey(cryptoMechType, CKA_DECRYPT,
                                   eKey, c_param);
   if (cx == NULL) {
       rv = SECFailure;
       goto loser;
   }

   rv = PK11_CipherOp((PK11Context *)cx, dest->data, (int *)(&dest->len),
                      (int)(src->len + 64), src->data, (int)src->len);
   PK11_DestroyContext((PK11Context *)cx, PR_TRUE);

   bs = PK11_GetBlockSize(cryptoMechType, c_param);
   if (bs) {
       /* check for proper badding in block algorithms.  this assumes
        * RC2 cbc or a DES cbc variant.  and the padding is thus defined
        */
       if (((int)dest->data[dest->len - 1] <= bs) &&
           ((int)dest->data[dest->len - 1] > 0)) {
           dest->len -= (int)dest->data[dest->len - 1];
       } else {
           rv = SECFailure;
           /* set an error ? */
       }
   }

loser:
   /* let success fall through */
   if (rv == SECFailure)
       PORT_ArenaRelease(poolp, mark);
   else
       PORT_ArenaUnmark(poolp, mark);

   if (eKey != NULL)
       PK11_FreeSymKey(eKey);

   if (slot != NULL)
       PK11_FreeSlot(slot);

   if (c_param != NULL)
       SECITEM_ZfreeItem(c_param, PR_TRUE);

   return rv;
}

SECItem **
SEC_PKCS7GetCertificateList(SEC_PKCS7ContentInfo *cinfo)
{
   switch (SEC_PKCS7ContentType(cinfo)) {
       case SEC_OID_PKCS7_SIGNED_DATA:
           return cinfo->content.signedData->rawCerts;
           break;
       default:
           return NULL;
           break;
   }
}

int
SEC_PKCS7GetKeyLength(SEC_PKCS7ContentInfo *cinfo)
{
   if (cinfo->contentTypeTag->offset == SEC_OID_PKCS7_ENVELOPED_DATA)
       return cinfo->content.envelopedData->encContentInfo.keysize;
   else
       return 0;
}