Update NSPR to 4.12 and NSS to 3.23 on iOS

nss/lib/softoken/lowpbe.c

 /* 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/. */
 
 #include "plarena.h"
 
 #include "seccomon.h"
 #include "secitem.h"
 #include "secport.h"
 #include "hasht.h"
@@ skipping 35 matching lines @@
 
 
 /* PKCS5 v2 */
 
 struct nsspkcs5V2PBEParameterStr {
     SECAlgorithmID keyParams;  /* parameters of the key generation */
     SECAlgorithmID algParams;  /* parameters for the encryption or mac op */
 };
 
 typedef struct nsspkcs5V2PBEParameterStr nsspkcs5V2PBEParameter;
-#define PBKDF2
 
-#ifdef PBKDF2
 static const SEC_ASN1Template NSSPKCS5V2PBES2ParameterTemplate[] =
 {   
     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(nsspkcs5V2PBEParameter) },
     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
         offsetof(nsspkcs5V2PBEParameter, keyParams), 
         SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
         offsetof(nsspkcs5V2PBEParameter, algParams),
         SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
     { 0 }
 };
 
 static const SEC_ASN1Template NSSPKCS5V2PBEParameterTemplate[] =
 {   
     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(NSSPKCS5PBEParameter) },
     /* this is really a choice, but since we don't understand any other
      *choice, just inline it. */
     { SEC_ASN1_OCTET_STRING, offsetof(NSSPKCS5PBEParameter, salt) },
     { SEC_ASN1_INTEGER, offsetof(NSSPKCS5PBEParameter, iteration) },
     { SEC_ASN1_INTEGER, offsetof(NSSPKCS5PBEParameter, keyLength) },
     { SEC_ASN1_INLINE | SEC_ASN1_XTRN,
         offsetof(NSSPKCS5PBEParameter, prfAlg),
         SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
     { 0 }
 };
-#endif
 
 SECStatus
 nsspkcs5_HashBuf(const SECHashObject *hashObj, unsigned char *dest,
                                          unsigned char *src, int len)
 {
     void *ctx;
     unsigned int retLen;
 
     ctx = hashObj->create();
     if(ctx == NULL) {
@@ skipping 199 matching lines @@
     if(bytes_needed <= bytes_available) {
         return hash;
     } 
 
     newHash = nsspkcs5_PFXPBE(hashObj, pbe_param, hash, bytes_needed);
     if (hash != newHash)
         SECITEM_FreeItem(hash, PR_TRUE);
     return newHash;
 }
 
-#ifdef PBKDF2
-
 /*
  * PBDKDF2 is PKCS #5 v2.0 it's currently not used by NSS
  */
 static void
 do_xor(unsigned char *dest, unsigned char *src, int len)
 {
    /* use byt xor, not all platforms are happy about inaligned 
     * integer fetches */
     while (len--) {
         *dest = *dest ^ *src;
@@ skipping 90 matching lines @@
     }
     if (rv != SECSuccess) {
         SECITEM_FreeItem(result,PR_TRUE);
         result = NULL;
     } else {
         result->len = dkLen;
     }
 
     return result;
 }
-#endif
 
 #define HMAC_BUFFER 64
 #define NSSPBE_ROUNDUP(x,y) ((((x)+((y)-1))/(y))*(y))
 #define NSSPBE_MIN(x,y) ((x) < (y) ? (x) : (y))
 /*
  * This is the extended PBE function defined by the final PKCS #12 spec.
  */
 static SECItem *
 nsspkcs5_PKCS12PBE(const SECHashObject *hashObject, 
                    NSSPKCS5PBEParameter *pbe_param, SECItem *pwitem, 
@@ skipping 166 matching lines @@
         hash = nsspkcs5_PBKDF1Extended(hashObj,pbe_param,pwitem,faulty3DES);
         if (hash == NULL) {
             goto loser;
         }
         PORT_Assert(hash->len >= key->len+(getIV ? iv->len : 0));
         if (getIV) {
             PORT_Memcpy(iv->data, hash->data+(hash->len - iv->len),iv->len);
         } 
         
         break;
-#ifdef PBKDF2
     case NSSPKCS5_PBKDF2:
         hash = nsspkcs5_PBKDF2(hashObj,pbe_param,pwitem);
         if (getIV) {
             PORT_Memcpy(iv->data, pbe_param->ivData, iv->len);
         }
         break;
-#endif
     case NSSPKCS5_PKCS12_V2:
         if (getIV) {
             hash = nsspkcs5_PKCS12PBE(hashObj,pbe_param,pwitem,
                                                 pbeBitGenCipherIV,iv->len);
             if (hash == NULL) {
                 goto loser;
             }
             PORT_Memcpy(iv->data,hash->data,iv->len);
             SECITEM_ZfreeItem(hash,PR_TRUE);
             hash = NULL;
@@ skipping 23 matching lines @@
     if (getIV && iv->data) {
         PORT_ZFree(iv->data,iv->len);
         iv->data = NULL;
     }
 
     SECITEM_ZfreeItem(key, PR_TRUE);
     return NULL;
 }
 
 static SECStatus
-nsspkcs5_FillInParam(SECOidTag algorithm, NSSPKCS5PBEParameter *pbe_param)
+nsspkcs5_FillInParam(SECOidTag algorithm, HASH_HashType hashType,
+                     NSSPKCS5PBEParameter *pbe_param)
 {
     PRBool skipType = PR_FALSE;
 
     pbe_param->keyLen = 5;
     pbe_param->ivLen = 8;
-    pbe_param->hashType = HASH_AlgSHA1;
+    pbe_param->hashType = hashType;
     pbe_param->pbeType = NSSPKCS5_PBKDF1;
     pbe_param->encAlg = SEC_OID_RC2_CBC;
     pbe_param->is2KeyDES = PR_FALSE;
     switch(algorithm) {
     /* DES3 Algorithms */
     case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC:
         pbe_param->is2KeyDES = PR_TRUE;
         /* fall through */
     case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC:
         pbe_param->pbeType = NSSPKCS5_PKCS12_V2;
@@ skipping 39 matching lines @@
     case SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4:
         if (!skipType) {
             pbe_param->pbeType = NSSPKCS5_PKCS12_V2;
         }
         /* fall through */
     case SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC4:
         pbe_param->ivLen = 0;
         pbe_param->encAlg =  SEC_OID_RC4;
         break;
 
-#ifdef PBKDF2
     case SEC_OID_PKCS5_PBKDF2:
     case SEC_OID_PKCS5_PBES2:
     case SEC_OID_PKCS5_PBMAC1:
         /* everything else will be filled in by the template */
         pbe_param->ivLen = 0;
         pbe_param->pbeType = NSSPKCS5_PBKDF2;
         pbe_param->encAlg =  SEC_OID_PKCS5_PBKDF2;
         pbe_param->keyLen = 0; /* needs to be set by caller after return */
         break;
-#endif
 
     default:
         return SECFailure;
     }
 
     return SECSuccess;
 }
 
 /* decode the algid and generate a PKCS 5 parameter from it
  */
 NSSPKCS5PBEParameter *
-nsspkcs5_NewParam(SECOidTag alg, SECItem *salt, int iterator)
+nsspkcs5_NewParam(SECOidTag alg, HASH_HashType hashType, SECItem *salt,
+                  int iterationCount)
 {
     PLArenaPool *arena = NULL;
     NSSPKCS5PBEParameter *pbe_param = NULL;
     SECStatus rv = SECFailure;
 
     arena = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
     if (arena == NULL)
         return NULL;
 
     /* allocate memory for the parameter */
     pbe_param = (NSSPKCS5PBEParameter *)PORT_ArenaZAlloc(arena, 
         sizeof(NSSPKCS5PBEParameter));
 
     if (pbe_param == NULL) {
         goto loser;
     }
 
     pbe_param->poolp = arena;
 
-    rv = nsspkcs5_FillInParam(alg, pbe_param);
+    rv = nsspkcs5_FillInParam(alg, hashType, pbe_param);
     if (rv != SECSuccess) {
         goto loser;
     }
 
-    pbe_param->iter = iterator;
+    pbe_param->iter = iterationCount;
     if (salt) {
         rv = SECITEM_CopyItem(arena,&pbe_param->salt,salt);
     }
 
     /* default key gen */
     pbe_param->keyID = pbeBitGenCipherKey;
 
 loser:
     if (rv != SECSuccess) {
         PORT_FreeArena(arena, PR_TRUE);
@@ skipping 38 matching lines @@
 
     if (algid == NULL) {
         return NULL;
     }
 
     algorithm = SECOID_GetAlgorithmTag(algid);
     if (algorithm == SEC_OID_UNKNOWN) {
         goto loser;
     }
 
-    pbe_param = nsspkcs5_NewParam(algorithm, NULL, 1);
+    pbe_param = nsspkcs5_NewParam(algorithm, HASH_AlgSHA1, NULL, 1);
     if (pbe_param == NULL) {
         goto loser;
     }
 
     /* decode parameter */
     rv = SECFailure;
     switch (pbe_param->pbeType) {
     case NSSPKCS5_PBKDF1:
         rv = SEC_ASN1DecodeItem(pbe_param->poolp, pbe_param, 
             NSSPKCS5PBEParameterTemplate, &algid->parameters);
         break;
     case NSSPKCS5_PKCS12_V2:
         rv = SEC_ASN1DecodeItem(pbe_param->poolp, pbe_param, 
                 NSSPKCS5PKCS12V2PBEParameterTemplate, &algid->parameters);
         break;
-#ifdef PBKDF2
     case NSSPKCS5_PBKDF2:
         PORT_Memset(&pbev2_param,0, sizeof(pbev2_param));
         /* just the PBE */
         if (algorithm == SEC_OID_PKCS5_PBKDF2) {
             rv = SEC_ASN1DecodeItem(pbe_param->poolp, pbe_param,
                 NSSPKCS5V2PBEParameterTemplate, &algid->parameters);
         } else {
             /* PBE data an others */
             rv = SEC_ASN1DecodeItem(pbe_param->poolp, &pbev2_param, 
                 NSSPKCS5V2PBES2ParameterTemplate, &algid->parameters);
@@ skipping 14 matching lines @@
             pbe_param->ivLen = pbev2_param.algParams.parameters.len;
             pbe_param->ivData = pbev2_param.algParams.parameters.data;
         }
         pbe_param->hashType = 
             HASH_FromHMACOid(SECOID_GetAlgorithmTag(&pbe_param->prfAlg));
         if (pbe_param->hashType == HASH_AlgNULL) {
             PORT_SetError(SEC_ERROR_INVALID_ALGORITHM);
             rv = SECFailure;
         }
         break;
-#endif
     }
 
 loser:
     if (rv == SECSuccess) {
         pbe_param->iter = DER_GetInteger(&pbe_param->iteration);
     } else {
         nsspkcs5_DestroyPBEParameter(pbe_param);
         pbe_param = NULL;
     }
 
@@ skipping 421 matching lines @@
     }
     switch (pbe_param->pbeType) {
     case NSSPKCS5_PBKDF1:
         dummy = SEC_ASN1EncodeItem(arena, &der_param, pbe_param,
                                         NSSPKCS5PBEParameterTemplate);
         break;
     case NSSPKCS5_PKCS12_V2:
         dummy = SEC_ASN1EncodeItem(arena, &der_param, pbe_param,
                                         NSSPKCS5PKCS12V2PBEParameterTemplate);
         break;
-#ifdef PBKDF2
     case NSSPKCS5_PBKDF2:
         if (pbe_param->keyLength.data == NULL) {
             dummy = SEC_ASN1EncodeInteger(pbe_param->poolp,
                                 &pbe_param->keyLength, pbe_param->keyLen);
             if (dummy == NULL) {
                 goto loser;
             }
         }
         PORT_Memset(&pkcs5v2_param, 0, sizeof(pkcs5v2_param));
         dummy = SEC_ASN1EncodeItem(arena, &der_param, pbe_param,
@@ skipping 10 matching lines @@
         der_param.data = pbe_param->ivData;
         der_param.len = pbe_param->ivLen;
         rv = SECOID_SetAlgorithmID(arena, &pkcs5v2_param.algParams, 
                 pbe_param->encAlg, pbe_param->ivLen ? &der_param : NULL);
         if (rv != SECSuccess) {
             break;
         }
         dummy = SEC_ASN1EncodeItem(arena,  &der_param, &pkcs5v2_param,
                                         NSSPKCS5V2PBES2ParameterTemplate);
         break;
-#endif
     default:
         break;
     }
 
     if (dummy == NULL) {
         goto loser;
     }
         
     rv = SECOID_SetAlgorithmID(arena, algid, algorithm, &der_param);
     if (rv != SECSuccess) {
         goto loser;
     }
 
     ret_algid = (SECAlgorithmID *)PORT_ZAlloc(sizeof(SECAlgorithmID));
     if (ret_algid == NULL) {
         goto loser;
     }
 
     rv = SECOID_CopyAlgorithmID(NULL, ret_algid, algid);
     if (rv != SECSuccess) {
         SECOID_DestroyAlgorithmID(ret_algid, PR_TRUE);
         ret_algid = NULL;
     }
 
 loser:  
 
     return ret_algid;
 }