nss: revert encrypted and origin bound certificates support.

net/third_party/nss/ssl/ssl3con.c

 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
  * SSL3 Protocol
  *
  * ***** 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
@@ skipping 2973 matching lines @@
         return SECFailure;
     }
     buf->len = 0;
 
     /* Swap the pending and current read specs. */
     ssl_GetSpecWriteLock(ss);   /*************************************/
     prSpec                    = ss->ssl3.prSpec;
 
     ss->ssl3.prSpec  = ss->ssl3.crSpec;
     ss->ssl3.crSpec  = prSpec;
-
-    if (ss->sec.isServer &&
-        ss->opt.requestCertificate &&
-        ssl3_ExtensionNegotiated(ss, ssl_encrypted_client_certs)) {
-        ss->ssl3.hs.ws = wait_client_cert;
-    } else {
-        ss->ssl3.hs.ws = wait_finished;
-    }
+    ss->ssl3.hs.ws   = wait_finished;
 
     SSL_TRC(3, ("%d: SSL3[%d] Set Current Read Cipher Suite to Pending",
                 SSL_GETPID(), ss->fd ));
 
     /* If we are really through with the old cipher prSpec
      * (Both the read and write sides have changed) destroy it.
      */
     if (ss->ssl3.prSpec == ss->ssl3.pwSpec) {
         ssl3_DestroyCipherSpec(ss->ssl3.prSpec, PR_FALSE/*freeSrvName*/);
     }
@@ skipping 2068 matching lines @@
 loser:
     if (serverKey) 
         SECKEY_DestroyPublicKey(serverKey);
     return rv;  /* err code already set. */
 }
 
 /* Called from ssl3_HandleServerHelloDone(). */
 static SECStatus
 ssl3_SendCertificateVerify(sslSocket *ss)
 {
-    SECStatus      rv           = SECFailure;
-    PRBool         isTLS;
-    SECItem        buf          = {siBuffer, NULL, 0};
-    SSL3Hashes     hashes;
-    ssl3CipherSpec *spec;
+    SECStatus     rv            = SECFailure;
+    PRBool        isTLS;
+    SECItem       buf           = {siBuffer, NULL, 0};
+    SSL3Hashes    hashes;
 
     PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss));
     PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss));
 
     SSL_TRC(3, ("%d: SSL3[%d]: send certificate_verify handshake",
                 SSL_GETPID(), ss->fd));
 
     ssl_GetSpecReadLock(ss);
-    spec = ss->ssl3.pwSpec;
-    if (ssl3_ExtensionNegotiated(ss, ssl_encrypted_client_certs)) {
-        spec = ss->ssl3.cwSpec;
-    }
-    rv = ssl3_ComputeHandshakeHashes(ss, spec, &hashes, 0);
+    rv = ssl3_ComputeHandshakeHashes(ss, ss->ssl3.pwSpec, &hashes, 0);
     ssl_ReleaseSpecReadLock(ss);
     if (rv != SECSuccess) {
         goto done;      /* err code was set by ssl3_ComputeHandshakeHashes */
     }
 
-    isTLS = (PRBool)(spec->version > SSL_LIBRARY_VERSION_3_0);
+    isTLS = (PRBool)(ss->ssl3.pwSpec->version > SSL_LIBRARY_VERSION_3_0);
     if (ss->ssl3.platformClientKey) {
 #ifdef NSS_PLATFORM_CLIENT_AUTH
         rv = ssl3_PlatformSignHashes(&hashes, ss->ssl3.platformClientKey,
                                      &buf, isTLS);
         ssl_FreePlatformKey(ss->ssl3.platformClientKey);
         ss->ssl3.platformClientKey = (PlatformKey)NULL;
 #endif /* NSS_PLATFORM_CLIENT_AUTH */
     } else {
         rv = ssl3_SignHashes(&hashes, ss->ssl3.clientPrivateKey, &buf, isTLS);
         if (rv == SECSuccess) {
@@ skipping 1034 matching lines @@
 
 /* Called from ssl3_HandleServerHelloDone and ssl3_AuthCertificateComplete.
  *
  * Caller must hold Handshake and RecvBuf locks.
  */
 static SECStatus
 ssl3_SendClientSecondRound(sslSocket *ss)
 {
     SECStatus rv;
     PRBool sendClientCert;
-    PRBool sendEmptyCert;
-    int n = 0, i;
-    typedef SECStatus (*SendFunction)(sslSocket*);
-    SendFunction  send_funcs[5];
 
     PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) );
     PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) );
 
     sendClientCert = !ss->ssl3.sendEmptyCert &&
                      ss->ssl3.clientCertChain  != NULL &&
                      (ss->ssl3.platformClientKey ||
                      ss->ssl3.clientPrivateKey != NULL);
 
     /* We must wait for the server's certificate to be authenticated before
@@ skipping 26 matching lines @@
         return SECFailure;
     }
     if (ss->ssl3.hs.authCertificatePending &&
         (sendClientCert || ss->ssl3.sendEmptyCert || ss->firstHsDone)) {
         ss->ssl3.hs.restartTarget = ssl3_SendClientSecondRound;
         return SECWouldBlock;
     }
 
     ssl_GetXmitBufLock(ss);             /*******************************/
 
-    sendEmptyCert = ss->ssl3.sendEmptyCert;
-    ss->ssl3.sendEmptyCert = PR_FALSE;
-
-    if (ssl3_ExtensionNegotiated(ss, ssl_encrypted_client_certs)) {
-        send_funcs[n++] = ssl3_SendClientKeyExchange;
-        send_funcs[n++] = ssl3_SendChangeCipherSpecs;
-        if (sendEmptyCert) {
-            send_funcs[n++] = ssl3_SendEmptyCertificate;
-        }
-        if (sendClientCert) {
-            send_funcs[n++] = ssl3_SendCertificate;
-            send_funcs[n++] = ssl3_SendCertificateVerify;
-        }
-    } else {
-        if (sendEmptyCert) {
-            send_funcs[n++] = ssl3_SendEmptyCertificate;
-        }
-        if (sendClientCert) {
-            send_funcs[n++] = ssl3_SendCertificate;
-        }
-        send_funcs[n++] = ssl3_SendClientKeyExchange;
-        if (sendClientCert) {
-            send_funcs[n++] = ssl3_SendCertificateVerify;
-        }
-        send_funcs[n++] = ssl3_SendChangeCipherSpecs;
+    if (ss->ssl3.sendEmptyCert) {
+        ss->ssl3.sendEmptyCert = PR_FALSE;
+        rv = ssl3_SendEmptyCertificate(ss);
+        /* Don't send verify */
+        if (rv != SECSuccess) {
+            goto loser; /* error code is set. */
+        }
+    } else if (sendClientCert) {
+        rv = ssl3_SendCertificate(ss);
+        if (rv != SECSuccess) {
+            goto loser; /* error code is set. */
+        }
     }
 
-    PORT_Assert(n <= sizeof(send_funcs)/sizeof(send_funcs[0]));
+    rv = ssl3_SendClientKeyExchange(ss);
+    if (rv != SECSuccess) {
+        goto loser;     /* err is set. */
+    }
 
-    for (i = 0; i < n; i++) {
-        rv = send_funcs[i](ss);
+    if (sendClientCert) {
+        rv = ssl3_SendCertificateVerify(ss);
         if (rv != SECSuccess) {
-            goto loser; /* err code was set. */
-        }
+            goto loser; /* err is set. */
+        }
+    }
+
+    rv = ssl3_SendChangeCipherSpecs(ss);
+    if (rv != SECSuccess) {
+        goto loser;     /* err code was set. */
     }
 
     /* XXX: If the server's certificate hasn't been authenticated by this
      * point, then we may be leaking this NPN message to an attacker.
      */
     if (!ss->firstHsDone) {
         rv = ssl3_SendNextProto(ss);
         if (rv != SECSuccess) {
             goto loser; /* err code was set. */
         }
@@ skipping 194 matching lines @@
         rv = ssl3_SendCertificateRequest(ss);
         if (rv != SECSuccess) {
             return rv;          /* err code is set. */
         }
     }
     rv = ssl3_SendServerHelloDone(ss);
     if (rv != SECSuccess) {
         return rv;              /* err code is set. */
     }
 
-    if (ss->opt.requestCertificate &&
-        !ssl3_ExtensionNegotiated(ss, ssl_encrypted_client_certs)) {
-        ss->ssl3.hs.ws = wait_client_cert;
-    } else {
-        ss->ssl3.hs.ws = wait_client_key;
-    }
-
+    ss->ssl3.hs.ws = (ss->opt.requestCertificate) ? wait_client_cert
+                                               : wait_client_key;
     return SECSuccess;
 }
 
 /* An empty TLS Renegotiation Info (RI) extension */
 static const PRUint8 emptyRIext[5] = {0xff, 0x01, 0x00, 0x01, 0x00};
 
 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete
  * ssl3 Client Hello message.
  * Caller must hold Handshake and RecvBuf locks.
  */
@@ skipping 1276 matching lines @@
         desc = isTLS ? decrypt_error : handshake_failure;
         goto alert_loser;
     }
 
     signed_hash.data = NULL;
 
     if (length != 0) {
         desc    = isTLS ? decode_error : illegal_parameter;
         goto alert_loser;       /* malformed */
     }
-    if (ssl3_ExtensionNegotiated(ss, ssl_encrypted_client_certs)) {
-        ss->ssl3.hs.ws = wait_finished;
-    } else {
-        ss->ssl3.hs.ws = wait_change_cipher;
-    }
+    ss->ssl3.hs.ws = wait_change_cipher;
     return SECSuccess;
 
 alert_loser:
     SSL3_SendAlert(ss, alert_fatal, desc);
 loser:
     PORT_SetError(errCode);
     return SECFailure;
 }
 
 
@@ skipping 892 matching lines @@
             /* XXX OR server cert is signing only. */
 #ifdef NSS_ENABLE_ECC
             ss->ssl3.hs.kea_def->kea == kea_ecdhe_ecdsa ||
             ss->ssl3.hs.kea_def->kea == kea_ecdhe_rsa ||
 #endif /* NSS_ENABLE_ECC */
             ss->ssl3.hs.kea_def->exchKeyType == kt_dh) {
             ss->ssl3.hs.ws = wait_server_key; /* allow server_key_exchange */
         }
     } else {
 server_no_cert:
-        if (ssl3_ExtensionNegotiated(ss, ssl_encrypted_client_certs)) {
-            ss->ssl3.hs.ws = wait_cert_verify;
-        } else {
-            ss->ssl3.hs.ws = wait_client_key;
-        }
+        ss->ssl3.hs.ws = wait_client_key;
     }
 
     PORT_Assert(rv == SECSuccess);
     if (rv != SECSuccess) {
         errCode = SEC_ERROR_LIBRARY_FAILURE;
         rv = SECFailure;
         goto loser;
     }
 
     return rv;
@@ skipping 594 matching lines @@
      * current message.
      */
     ssl_GetSpecReadLock(ss);    /************************************/
     if((type == finished) || (type == certificate_verify)) {
         SSL3Sender      sender = (SSL3Sender)0;
         ssl3CipherSpec *rSpec  = ss->ssl3.prSpec;
 
         if (type == finished) {
             sender = ss->sec.isServer ? sender_client : sender_server;
             rSpec  = ss->ssl3.crSpec;
-        } else if (ssl3_ExtensionNegotiated(ss, ssl_encrypted_client_certs)) {
-            rSpec  = ss->ssl3.crSpec;
         }
         rv = ssl3_ComputeHandshakeHashes(ss, rSpec, &hashes, sender);
     }
     ssl_ReleaseSpecReadLock(ss); /************************************/
     if (rv != SECSuccess) {
         return rv;      /* error code was set by ssl3_ComputeHandshakeHashes*/
     }
     SSL_TRC(30,("%d: SSL3[%d]: handle handshake message: %s", SSL_GETPID(),
                 ss->fd, ssl3_DecodeHandshakeType(ss->ssl3.hs.msg_type)));
     PRINT_BUF(60, (ss, "MD5 handshake hash:",
@@ skipping 1144 matching lines @@
             PORT_Free(ss->ssl3.hs.recvdFragments.buf);
         }
     }
 
     ss->ssl3.initialized = PR_FALSE;
 
     SECITEM_FreeItem(&ss->ssl3.nextProto, PR_FALSE);
 }
 
 /* End of ssl3con.c */