Update to NSS 3.12.7 and NSPR 4.8.6....

nss/mozilla/security/nss/lib/cryptohi/seckey.c

 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
@@ skipping 209 matching lines @@
 ** This is a "session" (temporary), not "token" (permanent) key. 
 ** Because of the high probability that this key will need to be moved to
 ** another token, and the high cost of moving "sensitive" keys, we attempt
 ** to create this key pair without the "sensitive" attribute, but revert to 
 ** creating a "sensitive" key if necessary.
 */
 SECKEYPrivateKey *
 SECKEY_CreateDHPrivateKey(SECKEYDHParams *param, SECKEYPublicKey **pubk, void *cx)
 {
     SECKEYPrivateKey *privk;
-    PK11SlotInfo *slot = PK11_GetBestSlot(CKM_DH_PKCS_KEY_PAIR_GEN,cx);
+    PK11SlotInfo *slot;
+
+    if (!param || !param->base.data || !param->prime.data ||

[wtc, 2010/08/10 00:24:30]

This is a DH key size check.  Without the DH key size check
in ssl3_HandleServerKeyExchange in libssl, we will get here
and still reject the 256-bit DH domain parameters that the
server suggested.

In my testing with Firefox, the test here alone is enough
to cause SSL handshake to fail.  It's just that the error
code SEC_ERROR_INVALID_ARGS is less informative than
SSL_ERROR_RX_MALFORMED_SERVER_KEY_EXCH.

To find the check in ssl3_HandleServerKeyExchange, search
for "< 512" in ssl3con.c.

+        param->prime.len < 512/8 || param->base.len == 0 || 
+        param->base.len > param->prime.len + 1 || 
+        (param->base.len == 1 && param->base.data[0] == 0)) {
+        PORT_SetError(SEC_ERROR_INVALID_ARGS);
+        return NULL;
+    }
+
+    slot = PK11_GetBestSlot(CKM_DH_PKCS_KEY_PAIR_GEN,cx);
     if (!slot) {
         return NULL;
     }
 
     privk = PK11_GenerateKeyPair(slot, CKM_DH_PKCS_KEY_PAIR_GEN, param, 
                                  pubk, PR_FALSE, PR_FALSE, cx);
     if (!privk) 
         privk = PK11_GenerateKeyPair(slot, CKM_DH_PKCS_KEY_PAIR_GEN, param, 
                                      pubk, PR_FALSE, PR_TRUE, cx);
 
@@ skipping 626 matching lines @@
         if (pubk->u.fortezza.clearance.data == NULL) {
                 return SECFailure;
         }
         PORT_Memcpy(pubk->u.fortezza.clearance.data,clearptr,
                                         pubk->u.fortezza.clearance.len);
 
         /* KEAPrivilege (the string up to the first byte with the hi-bit on */
         clearptr = rawptr;
         while ((rawptr < end) && (*rawptr++ & 0x80));
         if (rawptr >= end) { return SECFailure; }
-        pubk->u.fortezza.KEApriviledge.len = rawptr - clearptr;
-        pubk->u.fortezza.KEApriviledge.data = 
-                (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.KEApriviledge.len);
-        if (pubk->u.fortezza.KEApriviledge.data == NULL) {
+        pubk->u.fortezza.KEAprivilege.len = rawptr - clearptr;
+        pubk->u.fortezza.KEAprivilege.data = 
+                (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.KEAprivilege.len);
+        if (pubk->u.fortezza.KEAprivilege.data == NULL) {
                 return SECFailure;
         }
-        PORT_Memcpy(pubk->u.fortezza.KEApriviledge.data,clearptr,
-                                pubk->u.fortezza.KEApriviledge.len);
+        PORT_Memcpy(pubk->u.fortezza.KEAprivilege.data,clearptr,
+                                pubk->u.fortezza.KEAprivilege.len);
 
 
         /* now copy the key. The next to bytes are the key length, and the
          * key follows */
         pubk->u.fortezza.KEAKey.len = (*rawptr << 8) | rawptr[1];
 
         rawptr += 2;
         if (rawptr+pubk->u.fortezza.KEAKey.len > end) { return SECFailure; }
         pubk->u.fortezza.KEAKey.data = 
                         (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.KEAKey.len);
         if (pubk->u.fortezza.KEAKey.data == NULL) {
                 return SECFailure;
         }
         PORT_Memcpy(pubk->u.fortezza.KEAKey.data,rawptr,
                                         pubk->u.fortezza.KEAKey.len);
         rawptr += pubk->u.fortezza.KEAKey.len;
 
         /* shared key */
         if (rawptr >= end) {
             pubk->u.fortezza.DSSKey.len = pubk->u.fortezza.KEAKey.len;
             /* this depends on the fact that we are going to get freed with an
              * ArenaFree call. We cannot free DSSKey and KEAKey separately */
             pubk->u.fortezza.DSSKey.data=
                                         pubk->u.fortezza.KEAKey.data;
-            pubk->u.fortezza.DSSpriviledge.len = 
-                                pubk->u.fortezza.KEApriviledge.len;
-            pubk->u.fortezza.DSSpriviledge.data =
-                        pubk->u.fortezza.DSSpriviledge.data;
+            pubk->u.fortezza.DSSprivilege.len = 
+                                pubk->u.fortezza.KEAprivilege.len;
+            pubk->u.fortezza.DSSprivilege.data =
+                        pubk->u.fortezza.DSSprivilege.data;
             goto done;
         }
                 
 
         /* DSS Version is next */
         pubk->u.fortezza.DSSversion = *rawptr++;
 
         if (*rawptr++ != 2) {
                 return SECFailure;
         }
 
         /* DSSPrivilege (the string up to the first byte with the hi-bit on */
         clearptr = rawptr;
         while ((rawptr < end) && (*rawptr++ & 0x80));
         if (rawptr >= end) { return SECFailure; }
-        pubk->u.fortezza.DSSpriviledge.len = rawptr - clearptr;
-        pubk->u.fortezza.DSSpriviledge.data = 
-                (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.DSSpriviledge.len);
-        if (pubk->u.fortezza.DSSpriviledge.data == NULL) {
+        pubk->u.fortezza.DSSprivilege.len = rawptr - clearptr;
+        pubk->u.fortezza.DSSprivilege.data = 
+                (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.DSSprivilege.len);
+        if (pubk->u.fortezza.DSSprivilege.data == NULL) {
                 return SECFailure;
         }
-        PORT_Memcpy(pubk->u.fortezza.DSSpriviledge.data,clearptr,
-                                pubk->u.fortezza.DSSpriviledge.len);
+        PORT_Memcpy(pubk->u.fortezza.DSSprivilege.data,clearptr,
+                                pubk->u.fortezza.DSSprivilege.len);
 
         /* finally copy the DSS key. The next to bytes are the key length,
          *  and the key follows */
         pubk->u.fortezza.DSSKey.len = (*rawptr << 8) | rawptr[1];
 
         rawptr += 2;
         if (rawptr+pubk->u.fortezza.DSSKey.len > end){ return SECFailure; }
         pubk->u.fortezza.DSSKey.data = 
                         (unsigned char*)PORT_ArenaZAlloc(arena,pubk->u.fortezza.DSSKey.len);
         if (pubk->u.fortezza.DSSKey.data == NULL) {
@@ skipping 12 matching lines @@
 /* Function used to make an oid tag to a key type */
 KeyType 
 seckey_GetKeyType (SECOidTag tag) {
     KeyType keyType;
 
     switch (tag) {
       case SEC_OID_X500_RSA_ENCRYPTION:
       case SEC_OID_PKCS1_RSA_ENCRYPTION:
         keyType = rsaKey;
         break;
+      case SEC_OID_PKCS1_RSA_PSS_SIGNATURE:
+        keyType = rsaPssKey;
+        break;
+      case SEC_OID_PKCS1_RSA_OAEP_ENCRYPTION:
+        keyType = rsaOaepKey;
+        break;
       case SEC_OID_ANSIX9_DSA_SIGNATURE:
         keyType = dsaKey;
         break;
       case SEC_OID_MISSI_KEA_DSS_OLD:
       case SEC_OID_MISSI_KEA_DSS:
       case SEC_OID_MISSI_DSS_OLD:
       case SEC_OID_MISSI_DSS:  
         keyType = fortezzaKey;
         break;
       case SEC_OID_MISSI_KEA:
@@ skipping 481 matching lines @@
 
 /* returns key strength in bytes (not bits) */
 unsigned
 SECKEY_PublicKeyStrength(const SECKEYPublicKey *pubk)
 {
     unsigned char b0;
     unsigned size;
 
     /* interpret modulus length as key strength... in
      * fortezza that's the public key length */
-
+    if (!pubk)
+        goto loser;
     switch (pubk->keyType) {
     case rsaKey:
+        if (!pubk->u.rsa.modulus.data) break;
         b0 = pubk->u.rsa.modulus.data[0];
         return b0 ? pubk->u.rsa.modulus.len : pubk->u.rsa.modulus.len - 1;
     case dsaKey:
+        if (!pubk->u.dsa.publicValue.data) break;
         b0 = pubk->u.dsa.publicValue.data[0];
         return b0 ? pubk->u.dsa.publicValue.len :
             pubk->u.dsa.publicValue.len - 1;
     case dhKey:
+        if (!pubk->u.dh.publicValue.data) break;
         b0 = pubk->u.dh.publicValue.data[0];
         return b0 ? pubk->u.dh.publicValue.len :
             pubk->u.dh.publicValue.len - 1;
     case fortezzaKey:
         return PR_MAX(pubk->u.fortezza.KEAKey.len, pubk->u.fortezza.DSSKey.len);
     case ecKey:
         /* Get the key size in bits and adjust */
         size =  SECKEY_ECParamsToKeySize(&pubk->u.ec.DEREncodedParams);
         return (size + 7)/8;
     default:
         break;
     }
+loser:
     PORT_SetError(SEC_ERROR_INVALID_KEY);
     return 0;
 }
 
 /* returns key strength in bits */
 unsigned
 SECKEY_PublicKeyStrengthInBits(const SECKEYPublicKey *pubk)
 {
     unsigned size;
     switch (pubk->keyType) {
@@ skipping 146 matching lines @@
                                 &pubk->u.kea.params.hash);
           break;
       case fortezzaKey:
           copyk->u.fortezza.KEAversion = pubk->u.fortezza.KEAversion;
           copyk->u.fortezza.DSSversion = pubk->u.fortezza.DSSversion;
           PORT_Memcpy(copyk->u.fortezza.KMID, pubk->u.fortezza.KMID,
                       sizeof(pubk->u.fortezza.KMID));
           rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.clearance, 
                                 &pubk->u.fortezza.clearance);
           if (rv != SECSuccess) break;
-          rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.KEApriviledge, 
-                                &pubk->u.fortezza.KEApriviledge);
+          rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.KEAprivilege, 
+                                &pubk->u.fortezza.KEAprivilege);
           if (rv != SECSuccess) break;
-          rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.DSSpriviledge, 
-                                &pubk->u.fortezza.DSSpriviledge);
+          rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.DSSprivilege, 
+                                &pubk->u.fortezza.DSSprivilege);
           if (rv != SECSuccess) break;
           rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.KEAKey, 
                                 &pubk->u.fortezza.KEAKey);
           if (rv != SECSuccess) break;
           rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.DSSKey, 
                                 &pubk->u.fortezza.DSSKey);
           if (rv != SECSuccess) break;
           rv = SECITEM_CopyItem(arena, &copyk->u.fortezza.params.prime, 
                                 &pubk->u.fortezza.params.prime);
           if (rv != SECSuccess) break;
@@ skipping 849 matching lines @@
 SECKEY_CacheStaticFlags(SECKEYPrivateKey* key)
 {
     SECStatus rv = SECFailure;
     if (key && key->pkcs11Slot && key->pkcs11ID) {
         key->staticflags |= SECKEY_Attributes_Cached;
         SECKEY_CacheAttribute(key, CKA_PRIVATE);
         rv = SECSuccess;
     }
     return rv;
 }