Implement TLS 1.2.

net/third_party/nss/ssl/sslsock.c

 /*
  * vtables (and methods that call through them) for the 4 types of 
  * SSLSockets supported.  Only one type is still supported.
  * Various other functions.
  *
  * 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/. */
 /* $Id$ */
 #include "seccomon.h"
 #include "cert.h"
 #include "keyhi.h"
 #include "ssl.h"
 #include "sslimpl.h"
 #include "sslproto.h"
 #include "nspr.h"
 #include "private/pprio.h"
 #ifndef NO_PKCS11_BYPASS
 #include "blapi.h"
 #endif
+#include "pk11pub.h"
 #include "nss.h"
 
+/* This is a bodge to allow this code to be compiled against older NSS headers
+ * that don't contain the TLS 1.2 changes. */
+#ifndef CKM_NSS_TLS_MASTER_KEY_DERIVE_DH_SHA256
+#define CKM_NSS_TLS_MASTER_KEY_DERIVE_DH_SHA256 (CKM_NSS + 24)
+#endif
+
 #define SET_ERROR_CODE   /* reminder */
 
 struct cipherPolicyStr {
         int             cipher;
         unsigned char   export; /* policy value for export policy */
         unsigned char   france; /* policy value for france policy */
 };
 
 typedef struct cipherPolicyStr cipherPolicy;
 
@@ skipping 742 matching lines @@
         if (on) 
             SSL_DisableExportCipherSuites(fd);
         break;
 
       case SSL_BYPASS_PKCS11:
         if (ss->handshakeBegun) {
             PORT_SetError(PR_INVALID_STATE_ERROR);
             rv = SECFailure;
         } else {
             if (PR_FALSE != on) {
+                /* TLS 1.2 isn't supported in bypass mode. */
+                if (ss->vrange.min >= SSL_LIBRARY_VERSION_TLS_1_2) {
+                    /* If the user requested a minimum version of TLS 1.2 then
+                     * we don't silently downgrade. */
+                    PORT_SetError(SSL_ERROR_INVALID_VERSION_RANGE);
+                    rv = SECFailure;
+                    break;
+                }
+                if (ss->vrange.max >= SSL_LIBRARY_VERSION_TLS_1_2) {
+                    ss->vrange.max = SSL_LIBRARY_VERSION_TLS_1_1;
+                }
                 if (PR_SUCCESS == SSL_BypassSetup() ) {
 #ifdef NO_PKCS11_BYPASS
                     ss->opt.bypassPKCS11   = PR_FALSE;
 #else
                     ss->opt.bypassPKCS11   = on;
 #endif
                 } else {
                     rv = SECFailure;
                 }
             } else {
@@ skipping 1093 matching lines @@
     ssl_GetSSL3HandshakeLock(ss);
 
     *vrange = ss->vrange;
 
     ssl_ReleaseSSL3HandshakeLock(ss);
     ssl_Release1stHandshakeLock(ss);
 
     return SECSuccess;
 }
 
+static PRCallOnceType checkTLS12TokenOnce;
+static PRBool tls12TokenExists;
+
+static PRStatus  
+ssl_CheckTLS12Token(void)
+{
+    tls12TokenExists =
+        PK11_TokenExists(CKM_NSS_TLS_MASTER_KEY_DERIVE_DH_SHA256);
+    return PR_SUCCESS;
+}
+
+static PRBool
+ssl_TLS12TokenExists(void)
+{
+    (void) PR_CallOnce(&checkTLS12TokenOnce, ssl_CheckTLS12Token);
+    return tls12TokenExists;
+}
+
 SECStatus
 SSL_VersionRangeSet(PRFileDesc *fd, const SSLVersionRange *vrange)
 {
     sslSocket *ss = ssl_FindSocket(fd);
 
     if (!ss) {
         SSL_DBG(("%d: SSL[%d]: bad socket in SSL3_VersionRangeSet",
                 SSL_GETPID(), fd));
         return SECFailure;
     }
 
     if (!ssl3_VersionRangeIsValid(ss->protocolVariant, vrange)) {
         PORT_SetError(SSL_ERROR_INVALID_VERSION_RANGE);
         return SECFailure;
     }
 
     ssl_Get1stHandshakeLock(ss);
     ssl_GetSSL3HandshakeLock(ss);
 
     ss->vrange = *vrange;
+    /* If we don't have a sufficiently up-to-date softoken then we cannot do
+     * TLS 1.2. */
+    if (ss->vrange.max >= SSL_LIBRARY_VERSION_TLS_1_2 &&
+        !ssl_TLS12TokenExists()) {
+        /* If the user requested a minimum version of 1.2, then we don't
+         * silently downgrade. */
+        if (ss->vrange.min >= SSL_LIBRARY_VERSION_TLS_1_2) {
+            ssl_ReleaseSSL3HandshakeLock(ss);
+            ssl_Release1stHandshakeLock(ss);
+            PORT_SetError(SSL_ERROR_INVALID_VERSION_RANGE);
+            return SECFailure;
+        }
+        ss->vrange.max = SSL_LIBRARY_VERSION_TLS_1_1;
+    }
+    /* PKCS#11 bypass is not supported with TLS 1.2. */
+    if (ss->vrange.max >= SSL_LIBRARY_VERSION_TLS_1_2) {
+        ss->opt.bypassPKCS11 = PR_FALSE;
+    }
 
     ssl_ReleaseSSL3HandshakeLock(ss);
     ssl_Release1stHandshakeLock(ss);
 
     return SECSuccess;
 }
 
 const SECItemArray *
 SSL_PeerStapledOCSPResponses(PRFileDesc *fd)
 {
@@ skipping 1145 matching lines @@
             ssl_DestroySocketContents(ss);
             ssl_DestroyLocks(ss);
             PORT_Free(ss);
             ss = NULL;
         }
         ss->protocolVariant = protocolVariant;
     }
     return ss;
 }