Update NSS to NSS 3.13.4 pre-release snapshot 20120319.

net/third_party/nss/ssl/sslcon.c

 /* 
  * SSL v2 handshake functions, and functions common to SSL2 and SSL3.
  *
  * ***** 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/
@@ skipping 19 matching lines @@
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
-/* $Id: sslcon.c,v 1.45 2011/11/19 21:58:21 bsmith%mozilla.com Exp $ */
+/* $Id: sslcon.c,v 1.48 2012/03/18 00:31:20 wtc%google.com Exp $ */
 
 #include "nssrenam.h"
 #include "cert.h"
 #include "secitem.h"
 #include "sechash.h"
 #include "cryptohi.h"           /* for SGN_ funcs */
 #include "keyhi.h"              /* for SECKEY_ high level functions. */
 #include "ssl.h"
 #include "sslimpl.h"
 #include "sslproto.h"
@@ skipping 219 matching lines @@
         goto disabled;
 
     allowed = ss->allowedByPolicy & ss->chosenPreference;
     if (! allowed)
         ss->opt.enableSSL2 = PR_FALSE; /* not really enabled if no ciphers */
 
     /* ssl3_config_match_init was called in ssl2_ConstructCipherSpecs(). */
     /* Ask how many ssl3 CipherSuites were enabled. */
     rv = ssl3_ConstructV2CipherSpecsHack(ss, NULL, &ssl3CipherCount);
     if (rv != SECSuccess || ssl3CipherCount <= 0) {
-        ss->opt.enableSSL3 = PR_FALSE; /* not really enabled if no ciphers */
-        ss->opt.enableTLS  = PR_FALSE;
+        /* SSL3/TLS not really enabled if no ciphers */
+        ss->vrange.min = SSL_LIBRARY_VERSION_NONE;
+        ss->vrange.max = SSL_LIBRARY_VERSION_NONE;
     }
 
-    if (!ss->opt.enableSSL2 && !ss->opt.enableSSL3 && !ss->opt.enableTLS) {
-        SSL_DBG(("%d: SSL[%d]: Can't handshake! both v2 and v3 disabled.",
+    if (!ss->opt.enableSSL2 && SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) {
+        SSL_DBG(("%d: SSL[%d]: Can't handshake! all versions disabled.",
                  SSL_GETPID(), ss->fd));
 disabled:
         PORT_SetError(SSL_ERROR_SSL_DISABLED);
         return SECFailure;
     }
     return SECSuccess;
 }
 
 /* 
  * Since this is a global (not per-socket) setting, we cannot use the
@@ skipping 1132 matching lines @@
     CK_MECHANISM_TYPE mechanism;
     SECItem           readKey;
     SECItem           writeKey;
 
     void *readcx = 0;
     void *writecx = 0;
     readKey.data = 0;
     writeKey.data = 0;
 
     PORT_Assert( ss->opt.noLocks || ssl_Have1stHandshakeLock(ss) );
-    if(ss->sec.ci.sid == 0)
+    if (ss->sec.ci.sid == 0)
         goto sec_loser; /* don't crash if asserts are off */
 
     /* Trying to cut down on all these switch statements that should be tables.
      * So, test cipherType once, here, and then use tables below. 
      */
     switch (cipherType) {
     case SSL_CK_RC4_128_EXPORT40_WITH_MD5:
     case SSL_CK_RC4_128_WITH_MD5:
     case SSL_CK_RC2_128_CBC_EXPORT40_WITH_MD5:
     case SSL_CK_RC2_128_CBC_WITH_MD5:
@@ skipping 227 matching lines @@
 
     /* Cheaply verify that PKCS#1 was used to format the encryption block */
     if ((kbuf[0] != 0x00) || (kbuf[1] != 0x02) || (dk[-1] != 0x00)) {
         SSL_DBG(("%d: SSL[%d]: strange encryption block",
                  SSL_GETPID(), ss->fd));
         PORT_SetError(SSL_ERROR_BAD_CLIENT);
         goto hide_loser;
     }
 
     /* Make sure we're not subject to a version rollback attack. */
-    if (ss->opt.enableSSL3 || ss->opt.enableTLS) {
+    if (!SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) {
         static const PRUint8 threes[8] = { 0x03, 0x03, 0x03, 0x03,
                                            0x03, 0x03, 0x03, 0x03 };
         
         if (PORT_Memcmp(dk - 8 - 1, threes, 8) == 0) {
             PORT_SetError(SSL_ERROR_BAD_CLIENT);
             goto hide_loser;
         }
     }
     if (0) {
 hide_loser:
@@ skipping 440 matching lines @@
     */
     modulusLen = SECKEY_PublicKeyStrength(serverKey);
     rek.data   = keyData + ckLen;
     rek.len    = keyLen  - ckLen;
     eblock = ssl_FormatSSL2Block(modulusLen, &rek);
     if (eblock == NULL) 
         goto loser;
 
     /* Set up the padding for version 2 rollback detection. */
     /* XXX We should really use defines here */
-    if (ss->opt.enableSSL3 || ss->opt.enableTLS) {
+    if (!SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) {
         PORT_Assert((modulusLen - rek.len) > 12);
         PORT_Memset(eblock + modulusLen - rek.len - 8 - 1, 0x03, 8);
     }
     ekbuf = (PRUint8*) PORT_Alloc(modulusLen);
     if (!ekbuf) 
         goto loser;
     PRINT_BUF(10, (ss, "master key encryption block:",
                    eblock, modulusLen));
 
     /* Encrypt ekitem */
@@ skipping 886 matching lines @@
     SSL_TRC(3, ("%d: SSL[%d]: sending client-hello", SSL_GETPID(), ss->fd));
 
     /* Try to find server in our session-id cache */
     if (ss->opt.noCache) {
         sid = NULL;
     } else {
         sid = ssl_LookupSID(&ss->sec.ci.peer, ss->sec.ci.port, ss->peerID, 
                             ss->url);
     }
     while (sid) {  /* this isn't really a loop */
+        PRBool sidVersionEnabled =
+            (!SSL3_ALL_VERSIONS_DISABLED(&ss->vrange) &&
+             sid->version >= ss->vrange.min &&
+             sid->version <= ss->vrange.max) ||
+            (sid->version < SSL_LIBRARY_VERSION_3_0 && ss->opt.enableSSL2);
+
         /* if we're not doing this SID's protocol any more, drop it. */
-        if (((sid->version  < SSL_LIBRARY_VERSION_3_0) && !ss->opt.enableSSL2) ||
-            ((sid->version == SSL_LIBRARY_VERSION_3_0) && !ss->opt.enableSSL3) ||
-            ((sid->version >  SSL_LIBRARY_VERSION_3_0) && !ss->opt.enableTLS)) {
+        if (!sidVersionEnabled) {
             ss->sec.uncache(sid);
             ssl_FreeSID(sid);
             sid = NULL;
             break;
         }
-        if (ss->opt.enableSSL2 && sid->version < SSL_LIBRARY_VERSION_3_0) {
+        if (sid->version < SSL_LIBRARY_VERSION_3_0) {
             /* If the cipher in this sid is not enabled, drop it. */
             for (i = 0; i < ss->sizeCipherSpecs; i += 3) {
                 if (ss->cipherSpecs[i] == sid->u.ssl2.cipherType)
                     break;
             }
             if (i >= ss->sizeCipherSpecs) {
                 ss->sec.uncache(sid);
                 ssl_FreeSID(sid);
                 sid = NULL;
                 break;
@@ skipping 25 matching lines @@
         }
         if (ss->url != NULL) {
             sid->urlSvrName = PORT_Strdup(ss->url);
         }
     }
     ss->sec.ci.sid = sid;
 
     PORT_Assert(sid != NULL);
 
     if ((sid->version >= SSL_LIBRARY_VERSION_3_0 || !ss->opt.v2CompatibleHello) &&
-        (ss->opt.enableSSL3 || ss->opt.enableTLS)) {
-
+        !SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) {
         ss->gs.state      = GS_INIT;
         ss->handshake     = ssl_GatherRecord1stHandshake;
 
         /* ssl3_SendClientHello will override this if it succeeds. */
         ss->version       = SSL_LIBRARY_VERSION_3_0;
 
         ssl_GetSSL3HandshakeLock(ss);
         ssl_GetXmitBufLock(ss);
         rv =  ssl3_SendClientHello(ss);
         ssl_ReleaseXmitBufLock(ss);
@@ skipping 29 matching lines @@
 
     ssl_GetXmitBufLock(ss);    /***************************************/
 
     rv = ssl2_GetSendBuffer(ss, sendLen);
     if (rv) 
         goto unlock_loser;
 
     /* Construct client-hello message */
     cp = msg = ss->sec.ci.sendBuf.buf;
     msg[0] = SSL_MT_CLIENT_HELLO;
-    if ( ss->opt.enableTLS ) {
-        ss->clientHelloVersion = SSL_LIBRARY_VERSION_3_1_TLS;
-    } else if ( ss->opt.enableSSL3 ) {
-        ss->clientHelloVersion = SSL_LIBRARY_VERSION_3_0;
-    } else {
-        ss->clientHelloVersion = SSL_LIBRARY_VERSION_2;
-    }
-    
+    ss->clientHelloVersion = SSL3_ALL_VERSIONS_DISABLED(&ss->vrange) ?
+        SSL_LIBRARY_VERSION_2 : ss->vrange.max;
+
     msg[1] = MSB(ss->clientHelloVersion);
     msg[2] = LSB(ss->clientHelloVersion);
     /* Add 3 for SCSV */
     msg[3] = MSB(localCipherSize + 3);
     msg[4] = LSB(localCipherSize + 3);
     msg[5] = MSB(sidLen);
     msg[6] = LSB(sidLen);
     msg[7] = MSB(SSL_CHALLENGE_BYTES);
     msg[8] = LSB(SSL_CHALLENGE_BYTES);
     cp += SSL_HL_CLIENT_HELLO_HBYTES;
@@ skipping 196 matching lines @@
     if (rv != SECSuccess) {
         goto loser;
     }
 
     /* Examine version information */
     /*
      * See if this might be a V2 client hello asking to use the V3 protocol
      */
     if ((data[0] == SSL_MT_CLIENT_HELLO) && 
         (data[1] >= MSB(SSL_LIBRARY_VERSION_3_0)) && 
-        (ss->opt.enableSSL3 || ss->opt.enableTLS)) {
+        !SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) {
         rv = ssl3_HandleV2ClientHello(ss, data, ss->gs.recordLen);
         if (rv != SECFailure) { /* Success */
             ss->handshake             = NULL;
             ss->nextHandshake         = ssl_GatherRecord1stHandshake;
             ss->securityHandshake     = NULL;
             ss->gs.state              = GS_INIT;
 
             /* ssl3_HandleV3ClientHello has set ss->version,
             ** and has gotten us a brand new sid.  
             */
@@ skipping 318 matching lines @@
 
     c = __nss_ssl_rcsid[0] + __nss_ssl_sccsid[0]; 
     return NSS_VersionCheck(importedVersion);
 }
 
 const char *
 NSSSSL_GetVersion(void)
 {
     return NSS_VERSION;
 }