Update to NSS 3.15.5 and NSPR 4.10.3.

nss/lib/softoken/pkcs11c.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/. */
 /*
  * This file implements PKCS 11 on top of our existing security modules
  *
  * For more information about PKCS 11 See PKCS 11 Token Inteface Standard.
  *   This implementation has two slots:
  *      slot 1 is our generic crypto support. It does not require login.
  *   It supports Public Key ops, and all they bulk ciphers and hashes. 
@@ skipping 5764 matching lines @@
         return 16;
     case CKK_DES3:
         return 24;
     /* IDEA and CAST need to be added */
     default:
         break;
     }
     return 0;
 }
 
+#ifdef NSS_ENABLE_ECC
 /* Inputs:
  *  key_len: Length of derived key to be generated.
  *  SharedSecret: a shared secret that is the output of a key agreement primitive.
  *  SharedInfo: (Optional) some data shared by the entities computing the secret key.
  *  SharedInfoLen: the length in octets of SharedInfo
  *  Hash: The hash function to be used in the KDF
  *  HashLen: the length in octets of the output of Hash
  * Output:
  *  key: Pointer to a buffer containing derived key, if return value is SECSuccess.
  */
 static CK_RV sftk_compute_ANSI_X9_63_kdf(CK_BYTE **key, CK_ULONG key_len, SECItem *SharedSecret,
                 CK_BYTE_PTR SharedInfo, CK_ULONG SharedInfoLen,
                 SECStatus Hash(unsigned char *, const unsigned char *, PRUint32),
                 CK_ULONG HashLen)
 {
     unsigned char *buffer = NULL, *output_buffer = NULL;
     PRUint32 buffer_len, max_counter, i;
     SECStatus rv;
+    CK_RV crv;
 
     /* Check that key_len isn't too long.  The maximum key length could be
      * greatly increased if the code below did not limit the 4-byte counter
      * to a maximum value of 255. */
     if (key_len > 254 * HashLen)
-        return SEC_ERROR_INVALID_ARGS;
+        return CKR_ARGUMENTS_BAD;
 
     if (SharedInfo == NULL)
         SharedInfoLen = 0;
 
     buffer_len = SharedSecret->len + 4 + SharedInfoLen;
     buffer = (CK_BYTE *)PORT_Alloc(buffer_len);
     if (buffer == NULL) {
-        rv = SEC_ERROR_NO_MEMORY;
+        crv = CKR_HOST_MEMORY;
         goto loser;
     }
 
     max_counter = key_len/HashLen;
     if (key_len > max_counter * HashLen)
         max_counter++;
 
     output_buffer = (CK_BYTE *)PORT_Alloc(max_counter * HashLen);
     if (output_buffer == NULL) {
-        rv = SEC_ERROR_NO_MEMORY;
+        crv = CKR_HOST_MEMORY;
         goto loser;
     }
 
     /* Populate buffer with SharedSecret || Counter || [SharedInfo]
      * where Counter is 0x00000001 */
     PORT_Memcpy(buffer, SharedSecret->data, SharedSecret->len);
     buffer[SharedSecret->len] = 0;
     buffer[SharedSecret->len + 1] = 0;
     buffer[SharedSecret->len + 2] = 0;
     buffer[SharedSecret->len + 3] = 1;
     if (SharedInfo) {
         PORT_Memcpy(&buffer[SharedSecret->len + 4], SharedInfo, SharedInfoLen);
     }
 
     for(i=0; i < max_counter; i++) {
         rv = Hash(&output_buffer[i * HashLen], buffer, buffer_len);
-        if (rv != SECSuccess)
+        if (rv != SECSuccess) {
+            /* 'Hash' should not fail. */
+            crv = CKR_FUNCTION_FAILED;
             goto loser;
+        }
 
         /* Increment counter (assumes max_counter < 255) */
         buffer[SharedSecret->len + 3]++;
     }
 
     PORT_ZFree(buffer, buffer_len);
     if (key_len < max_counter * HashLen) {
         PORT_Memset(output_buffer + key_len, 0, max_counter * HashLen - key_len);
     }
     *key = output_buffer;
 
-    return SECSuccess;
+    return CKR_OK;
 
     loser:
         if (buffer) {
             PORT_ZFree(buffer, buffer_len);
         }
         if (output_buffer) {
             PORT_ZFree(output_buffer, max_counter * HashLen);
         }
-        return rv;
+        return crv;
 }
 
 static CK_RV sftk_ANSI_X9_63_kdf(CK_BYTE **key, CK_ULONG key_len,
                 SECItem *SharedSecret,
                 CK_BYTE_PTR SharedInfo, CK_ULONG SharedInfoLen,
                 CK_EC_KDF_TYPE kdf)
 {
     if (kdf == CKD_SHA1_KDF)
         return sftk_compute_ANSI_X9_63_kdf(key, key_len, SharedSecret, SharedInfo,
                                  SharedInfoLen, SHA1_HashBuf, SHA1_LENGTH);
     else if (kdf == CKD_SHA224_KDF)
         return sftk_compute_ANSI_X9_63_kdf(key, key_len, SharedSecret, SharedInfo,
                                  SharedInfoLen, SHA224_HashBuf, SHA224_LENGTH);
     else if (kdf == CKD_SHA256_KDF)
         return sftk_compute_ANSI_X9_63_kdf(key, key_len, SharedSecret, SharedInfo,
                                  SharedInfoLen, SHA256_HashBuf, SHA256_LENGTH);
     else if (kdf == CKD_SHA384_KDF)
         return sftk_compute_ANSI_X9_63_kdf(key, key_len, SharedSecret, SharedInfo,
                                  SharedInfoLen, SHA384_HashBuf, SHA384_LENGTH);
     else if (kdf == CKD_SHA512_KDF)
         return sftk_compute_ANSI_X9_63_kdf(key, key_len, SharedSecret, SharedInfo,
                                  SharedInfoLen, SHA512_HashBuf, SHA512_LENGTH);
     else
-        return SEC_ERROR_INVALID_ALGORITHM;
+        return CKR_MECHANISM_INVALID;
 }
+#endif
 
 /*
  * SSL Key generation given pre master secret
  */
 #define NUM_MIXERS 9
 static const char * const mixers[NUM_MIXERS] = { 
     "A", 
     "BB", 
     "CCC", 
     "DDDD", 
@@ skipping 1031 matching lines @@
         if (mechParams->kdf == CKD_NULL) {
             /*
              * tmp is the raw data created by ECDH_Derive,
              * secret and secretlen are the values we will
              * eventually pass as our generated key.
              */
             secret = tmp.data;
             secretlen = tmp.len;
         } else {
             secretlen = keySize;
-            rv = sftk_ANSI_X9_63_kdf(&secret, keySize,
+            crv = sftk_ANSI_X9_63_kdf(&secret, keySize,
                         &tmp, mechParams->pSharedData,
                         mechParams->ulSharedDataLen, mechParams->kdf);
             PORT_ZFree(tmp.data, tmp.len);
-            if (rv != SECSuccess) {
-                crv = CKR_HOST_MEMORY;
+            if (crv != CKR_OK) {
                 break;
             }
             tmp.data = secret;
             tmp.len = secretlen;
         }
 
         /*
          * if keySize is supplied, then we are generating a key of a specific 
          * length. This is done by taking the least significant 'keySize' 
          * bytes from the unsigned value calculated by ECDH. Note: this may 
@@ skipping 446 matching lines @@
     att = sftk_FindAttribute(key,CKA_VALUE);
     sftk_FreeObject(key);
     if (!att) {
         return CKR_KEY_HANDLE_INVALID;        
     }
     crv = NSC_DigestUpdate(hSession,(CK_BYTE_PTR)att->attrib.pValue,
                            att->attrib.ulValueLen);
     sftk_FreeAttribute(att);
     return crv;
 }