OSX/libsecurity_smime/lib/cmsdigest.c

   1 /*
   2  * The contents of this file are subject to the Mozilla Public
   3  * License Version 1.1 (the "License"); you may not use this file
   4  * except in compliance with the License. You may obtain a copy of
   5  * the License at http://www.mozilla.org/MPL/
   6  *
   7  * Software distributed under the License is distributed on an "AS
   8  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
   9  * implied. See the License for the specific language governing
  10  * rights and limitations under the License.
  11  *
  12  * The Original Code is the Netscape security libraries.
  13  *
  14  * The Initial Developer of the Original Code is Netscape
  15  * Communications Corporation.  Portions created by Netscape are
  16  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17  * Rights Reserved.
  18  *
  19  * Contributor(s):
  20  *
  21  * Alternatively, the contents of this file may be used under the
  22  * terms of the GNU General Public License Version 2 or later (the
  23  * "GPL"), in which case the provisions of the GPL are applicable
  24  * instead of those above.  If you wish to allow use of your
  25  * version of this file only under the terms of the GPL and not to
  26  * allow others to use your version of this file under the MPL,
  27  * indicate your decision by deleting the provisions above and
  28  * replace them with the notice and other provisions required by
  29  * the GPL.  If you do not delete the provisions above, a recipient
  30  * may use your version of this file under either the MPL or the
  31  * GPL.
  32  */
  33
  34 /*
  35  * CMS digesting.
  36  */
  37
  38 #include "cmslocal.h"
  39
  40 #include "secitem.h"
  41 #include "secoid.h"
  42
  43 #include <security_asn1/secerr.h>
  44 #include <Security/cssmapi.h>
  45
  46 #include <Security/SecCmsDigestContext.h>
  47
  48 /* Return the maximum value between S and T */
  49 #define MAX(S, T) ({__typeof__(S) _max_s = S; __typeof__(T) _max_t = T; _max_s > _max_t ? _max_s : _max_t;})
  50
  51 struct SecCmsDigestContextStr {
  52     Boolean             saw_contents;
  53     int                 digcnt;
  54     CSSM_CC_HANDLE *    digobjs;
  55 };
  56
  57 /*
  58  * SecCmsDigestContextStartMultiple - start digest calculation using all the
  59  *  digest algorithms in "digestalgs" in parallel.
  60  */
  61 SecCmsDigestContextRef
  62 SecCmsDigestContextStartMultiple(SECAlgorithmID **digestalgs)
  63 {
  64     SecCmsDigestContextRef cmsdigcx;
  65     CSSM_CC_HANDLE digobj;
  66     int digcnt;
  67     int i;
  68
  69     digcnt = (digestalgs == NULL) ? 0 : SecCmsArrayCount((void **)digestalgs);
  70
  71     cmsdigcx = (SecCmsDigestContextRef)PORT_Alloc(sizeof(struct SecCmsDigestContextStr));
  72     if (cmsdigcx == NULL)
  73         return NULL;
  74
  75     if (digcnt > 0) {
  76         /* Security check to prevent under-allocation */
  77         if (digcnt >= (int)(INT_MAX/sizeof(CSSM_CC_HANDLE))) {
  78             goto loser;
  79         }
  80         cmsdigcx->digobjs = (CSSM_CC_HANDLE *)PORT_Alloc(digcnt * sizeof(CSSM_CC_HANDLE));
  81         if (cmsdigcx->digobjs == NULL)
  82             goto loser;
  83     }
  84
  85     cmsdigcx->digcnt = 0;
  86
  87     /*
  88      * Create a digest object context for each algorithm.
  89      */
  90     for (i = 0; i < digcnt; i++) {
  91         digobj = SecCmsUtilGetHashObjByAlgID(digestalgs[i]);
  92         /*
  93          * Skip any algorithm we do not even recognize; obviously,
  94          * this could be a problem, but if it is critical then the
  95          * result will just be that the signature does not verify.
  96          * We do not necessarily want to error out here, because
  97          * the particular algorithm may not actually be important,
  98          * but we cannot know that until later.
  99          */
 100         if (digobj)
 101         {
 102             CSSM_RETURN result;
 103             result = CSSM_DigestDataInit(digobj);
 104             if (result != CSSM_OK)
 105             {
 106                 goto loser;
 107             }
 108         }
 109
 110         cmsdigcx->digobjs[cmsdigcx->digcnt] = digobj;
 111         cmsdigcx->digcnt++;
 112     }
 113
 114     cmsdigcx->saw_contents = PR_FALSE;
 115
 116     return cmsdigcx;
 117
 118 loser:
 119     if (cmsdigcx) {
 120         if (cmsdigcx->digobjs)
 121             PORT_Free(cmsdigcx->digobjs);
 122     }
 123     return NULL;
 124 }
 125
 126 /*
 127  * SecCmsDigestContextStartSingle - same as SecCmsDigestContextStartMultiple, but
 128  *  only one algorithm.
 129  */
 130 SecCmsDigestContextRef
 131 SecCmsDigestContextStartSingle(SECAlgorithmID *digestalg)
 132 {
 133     SECAlgorithmID *digestalgs[] = { NULL, NULL };              /* fake array */
 134
 135     digestalgs[0] = digestalg;
 136     return SecCmsDigestContextStartMultiple(digestalgs);
 137 }
 138
 139 /*
 140  * SecCmsDigestContextUpdate - feed more data into the digest machine
 141  */
 142 void
 143 SecCmsDigestContextUpdate(SecCmsDigestContextRef cmsdigcx, const unsigned char *data, size_t len)
 144 {
 145     CSSM_DATA dataBuf;
 146     int i;
 147
 148     dataBuf.Length = len;
 149     dataBuf.Data = (uint8 *)data;
 150     cmsdigcx->saw_contents = PR_TRUE;
 151     for (i = 0; i < cmsdigcx->digcnt; i++)
 152         if (cmsdigcx->digobjs[i])
 153             CSSM_DigestDataUpdate(cmsdigcx->digobjs[i], &dataBuf, 1);
 154 }
 155
 156 /*
 157  * SecCmsDigestContextCancel - cancel digesting operation
 158  */
 159 void
 160 SecCmsDigestContextCancel(SecCmsDigestContextRef cmsdigcx)
 161 {
 162     int i;
 163
 164     for (i = 0; i < cmsdigcx->digcnt; i++)
 165         if (cmsdigcx->digobjs[i])
 166             CSSM_DeleteContext(cmsdigcx->digobjs[i]);
 167 }
 168
 169 /*
 170  * SecCmsDigestContextFinishMultiple - finish the digests and put them
 171  *  into an array of CSSM_DATAs (allocated on poolp)
 172  */
 173 OSStatus
 174 SecCmsDigestContextFinishMultiple(SecCmsDigestContextRef cmsdigcx, SecArenaPoolRef poolp,
 175                             CSSM_DATA_PTR **digestsp)
 176 {
 177     CSSM_CC_HANDLE digobj;
 178     CSSM_DATA_PTR *digests, digest;
 179     int i;
 180     void *mark;
 181     OSStatus rv = SECFailure;
 182
 183     /* no contents? do not update digests */
 184     if (digestsp == NULL || !cmsdigcx->saw_contents) {
 185         for (i = 0; i < cmsdigcx->digcnt; i++)
 186             if (cmsdigcx->digobjs[i])
 187                 CSSM_DeleteContext(cmsdigcx->digobjs[i]);
 188         rv = SECSuccess;
 189         if (digestsp)
 190             *digestsp = NULL;
 191         goto cleanup;
 192     }
 193
 194     mark = PORT_ArenaMark ((PLArenaPool *)poolp);
 195
 196     /* Security check to prevent under-allocation */
 197     if (cmsdigcx->digcnt >= (int)((INT_MAX/(MAX(sizeof(CSSM_DATA_PTR),sizeof(CSSM_DATA))))-1)) {
 198         goto loser;
 199     }
 200     /* allocate digest array & CSSM_DATAs on arena */
 201     digests = (CSSM_DATA_PTR *)PORT_ArenaAlloc((PLArenaPool *)poolp, (cmsdigcx->digcnt+1) * sizeof(CSSM_DATA_PTR));
 202     digest = (CSSM_DATA_PTR)PORT_ArenaZAlloc((PLArenaPool *)poolp, cmsdigcx->digcnt * sizeof(CSSM_DATA));
 203     if (digests == NULL || digest == NULL) {
 204         goto loser;
 205     }
 206
 207     for (i = 0; i < cmsdigcx->digcnt; i++, digest++) {
 208         digobj = cmsdigcx->digobjs[i];
 209         CSSM_QUERY_SIZE_DATA dataSize;
 210         rv = CSSM_QuerySize(digobj, CSSM_FALSE, 1, &dataSize);
 211         if (rv != CSSM_OK)
 212         {
 213             goto loser;
 214         }
 215
 216         int diglength = dataSize.SizeOutputBlock;
 217
 218         if (digobj)
 219         {
 220             digest->Data = (unsigned char*)PORT_ArenaAlloc((PLArenaPool *)poolp, diglength);
 221             if (digest->Data == NULL)
 222                 goto loser;
 223             digest->Length = diglength;
 224             rv = CSSM_DigestDataFinal(digobj, digest);
 225             if (rv != CSSM_OK)
 226             {
 227                 goto loser;
 228             }
 229
 230             CSSM_DeleteContext(digobj);
 231         }
 232         else
 233         {
 234             digest->Data = NULL;
 235             digest->Length = 0;
 236         }
 237
 238         digests[i] = digest;
 239    }
 240     digests[i] = NULL;
 241     *digestsp = digests;
 242
 243     rv = SECSuccess;
 244
 245 loser:
 246     if (rv == SECSuccess)
 247         PORT_ArenaUnmark((PLArenaPool *)poolp, mark);
 248     else
 249         PORT_ArenaRelease((PLArenaPool *)poolp, mark);
 250
 251 cleanup:
 252     if (cmsdigcx->digcnt > 0) {
 253         PORT_Free(cmsdigcx->digobjs);
 254     }
 255     PORT_Free(cmsdigcx);
 256
 257     return rv;
 258 }
 259
 260 /*
 261  * SecCmsDigestContextFinishSingle - same as SecCmsDigestContextFinishMultiple,
 262  *  but for one digest.
 263  */
 264 OSStatus
 265 SecCmsDigestContextFinishSingle(SecCmsDigestContextRef cmsdigcx, SecArenaPoolRef poolp,
 266                             CSSM_DATA_PTR digest)
 267 {
 268     OSStatus rv = SECFailure;
 269     CSSM_DATA_PTR *dp;
 270     PLArenaPool *arena = NULL;
 271
 272     if ((arena = PORT_NewArena(1024)) == NULL)
 273         goto loser;
 274
 275     /* get the digests into arena, then copy the first digest into poolp */
 276     if (SecCmsDigestContextFinishMultiple(cmsdigcx, (SecArenaPoolRef)arena, &dp) != SECSuccess)
 277         goto loser;
 278
 279     /* now copy it into poolp */
 280     if (SECITEM_CopyItem((PLArenaPool *)poolp, digest, dp[0]) != SECSuccess)
 281         goto loser;
 282
 283     rv = SECSuccess;
 284
 285 loser:
 286     if (arena)
 287         PORT_FreeArena(arena, PR_FALSE);
 288
 289     return rv;
 290 }