Update NSS to 3.21 RTM and NSPR to 4.11 RTM

nss/lib/pk11wrap/pk11akey.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 contains functions to manage asymetric keys, (public and
  * private keys).
  */
 #include "seccomon.h"
 #include "secmod.h"
 #include "secmodi.h"
 #include "secmodti.h"
 #include "pkcs11.h"
 #include "pkcs11t.h"
 #include "pk11func.h"
 #include "cert.h"
 #include "key.h"
 #include "secitem.h"
 #include "secasn1.h" 
 #include "secoid.h" 
 #include "secerr.h"
-#include "sslerr.h"
 #include "sechash.h"
 
 #include "secpkcs5.h"  
 #include "blapit.h"
 
 static SECItem *
 pk11_MakeIDFromPublicKey(SECKEYPublicKey *pubKey)
 {
     /* set the ID to the public key so we can find it again */
     SECItem *pubKeyIndex =  NULL;
@@ skipping 35 matching lines @@
     CK_BBOOL ckfalse = CK_FALSE;
     CK_OBJECT_CLASS keyClass = CKO_PUBLIC_KEY;
     CK_KEY_TYPE keyType = CKK_GENERIC_SECRET;
     CK_OBJECT_HANDLE objectID;
     CK_ATTRIBUTE theTemplate[11];
     CK_ATTRIBUTE *signedattr = NULL;
     CK_ATTRIBUTE *attrs = theTemplate;
     SECItem *ckaId = NULL;
     SECItem *pubValue = NULL;
     int signedcount = 0;
-    int templateCount = 0;
+    unsigned int templateCount = 0;
     SECStatus rv;
 
     /* if we already have an object in the desired slot, use it */
     if (!isToken && pubKey->pkcs11Slot == slot) {
         return pubKey->pkcs11ID;
     }
 
     /* free the existing key */
     if (pubKey->pkcs11Slot != NULL) {
         PK11SlotInfo *oSlot = pubKey->pkcs11Slot;
@@ skipping 298 matching lines @@
      */
     keyLen = pk11_get_EC_PointLenInBytes(arena, ecParams);
     if (keyLen < 0) {
         return CKR_ATTRIBUTE_VALUE_INVALID;
     }
 
 
     /* If the point is uncompressed and the lengths match, it
      * must be an unencoded point */
     if ((*((char *)ecPoint->pValue) == EC_POINT_FORM_UNCOMPRESSED) 
-        && (ecPoint->ulValueLen == keyLen)) {
+        && (ecPoint->ulValueLen == (unsigned int)keyLen)) {
             return pk11_Attr2SecItem(arena, ecPoint, publicKeyValue);
     }
 
     /* now assume the key passed to us was encoded and decode it */
     if (*((char *)ecPoint->pValue) == SEC_ASN1_OCTET_STRING) {
         /* OK, now let's try to decode it and see if it's valid */
         encodedPublicValue.data = ecPoint->pValue;
         encodedPublicValue.len = ecPoint->ulValueLen;
         rv = SEC_QuickDERDecodeItem(arena, publicKeyValue,
                 SEC_ASN1_GET(SEC_OctetStringTemplate), &encodedPublicValue);
 
         /* it coded correctly & we know the key length (and they match)
          * then we are done, return the results. */
-        if (keyLen && rv == SECSuccess && publicKeyValue->len == keyLen) {
+        if (keyLen && rv == SECSuccess && publicKeyValue->len == (unsigned int)keyLen) {
             return CKR_OK;
         }
 
         /* if we know the key length, one of the above tests should have
          * succeded. If it doesn't the module gave us bad data */
         if (keyLen) {
             return CKR_ATTRIBUTE_VALUE_INVALID;
         }
                 
 
@@ skipping 111 matching lines @@
 /*
  * extract a public key from a slot and id
  */
 SECKEYPublicKey *
 PK11_ExtractPublicKey(PK11SlotInfo *slot,KeyType keyType,CK_OBJECT_HANDLE id)
 {
     CK_OBJECT_CLASS keyClass = CKO_PUBLIC_KEY;
     PLArenaPool *arena;
     PLArenaPool *tmp_arena;
     SECKEYPublicKey *pubKey;
-    int templateCount = 0;
+    unsigned int templateCount = 0;
     CK_KEY_TYPE pk11KeyType;
     CK_RV crv;
     CK_ATTRIBUTE template[8];
     CK_ATTRIBUTE *attrs= template;
     CK_ATTRIBUTE *modulus,*exponent,*base,*prime,*subprime,*value;
     CK_ATTRIBUTE *ecparams;
 
     /* if we didn't know the key type, get it */
     if (keyType== nullKey) {
 
@@ skipping 946 matching lines @@
 SECKEYPublicKey *
 PK11_MakeKEAPubKey(unsigned char *keyData,int length)
 {
     SECKEYPublicKey *pubk;
     SECItem pkData;
     SECStatus rv;
     PLArenaPool *arena;
 
     pkData.data = keyData;
     pkData.len = length;
+    pkData.type = siBuffer;
 
     arena = PORT_NewArena (DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL)
         return NULL;
 
     pubk = (SECKEYPublicKey *) PORT_ArenaZAlloc(arena, sizeof(SECKEYPublicKey));
     if (pubk == NULL) {
         PORT_FreeArena (arena, PR_FALSE);
         return NULL;
     }
@@ skipping 772 matching lines @@
     return keys;
 }
 
 SECKEYPublicKeyList*
 PK11_ListPublicKeysInSlot(PK11SlotInfo *slot, char *nickname)
 {
     CK_ATTRIBUTE findTemp[4];
     CK_ATTRIBUTE *attrs;
     CK_BBOOL ckTrue = CK_TRUE;
     CK_OBJECT_CLASS keyclass = CKO_PUBLIC_KEY;
-    int tsize = 0;
+    unsigned int tsize = 0;
     int objCount = 0;
     CK_OBJECT_HANDLE *key_ids;
     SECKEYPublicKeyList *keys;
     int i,len;
 
 
     attrs = findTemp;
     PK11_SETATTRS(attrs, CKA_CLASS, &keyclass, sizeof(keyclass)); attrs++;
     PK11_SETATTRS(attrs, CKA_TOKEN, &ckTrue, sizeof(ckTrue)); attrs++;
     if (nickname) {
@@ skipping 25 matching lines @@
    return keys;
 }
 
 SECKEYPrivateKeyList*
 PK11_ListPrivKeysInSlot(PK11SlotInfo *slot, char *nickname, void *wincx)
 {
     CK_ATTRIBUTE findTemp[4];
     CK_ATTRIBUTE *attrs;
     CK_BBOOL ckTrue = CK_TRUE;
     CK_OBJECT_CLASS keyclass = CKO_PRIVATE_KEY;
-    int tsize = 0;
+    unsigned int tsize = 0;
     int objCount = 0;
     CK_OBJECT_HANDLE *key_ids;
     SECKEYPrivateKeyList *keys;
     int i,len;
 
 
     attrs = findTemp;
     PK11_SETATTRS(attrs, CKA_CLASS, &keyclass, sizeof(keyclass)); attrs++;
     PK11_SETATTRS(attrs, CKA_TOKEN, &ckTrue, sizeof(ckTrue)); attrs++;
     if (nickname) {
@@ skipping 16 matching lines @@
     for (i=0; i < objCount ; i++) {
         SECKEYPrivateKey *privKey = 
                 PK11_MakePrivKey(slot,nullKey,PR_TRUE,key_ids[i],wincx);
         SECKEY_AddPrivateKeyToListTail(keys, privKey);
    }
 
    PORT_Free(key_ids);
    return keys;
 }