NSS: remove cipher policy framework.

net/third_party/nss/ssl/sslcon.c

 /* 
  * SSL v2 handshake functions, and functions common to SSL2 and SSL3.
  *
  * 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/. */
 
 #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"
 #include "ssl3prot.h"
 #include "sslerr.h"
 #include "pk11func.h"
 #include "prinit.h"
 #include "prtime.h"     /* for PR_Now() */
 
-#define XXX
-static PRBool policyWasSet;
-
 /* This ordered list is indexed by (SSL_CK_xx * 3)   */
 /* Second and third bytes are MSB and LSB of master key length. */
 static const PRUint8 allCipherSuites[] = {
     0,                                          0,    0,
     SSL_CK_RC4_128_WITH_MD5,                    0x00, 0x80,
     SSL_CK_RC4_128_EXPORT40_WITH_MD5,           0x00, 0x80,
     SSL_CK_RC2_128_CBC_WITH_MD5,                0x00, 0x80,
     SSL_CK_RC2_128_CBC_EXPORT40_WITH_MD5,       0x00, 0x80,
     SSL_CK_IDEA_128_CBC_WITH_MD5,               0x00, 0x80,
     SSL_CK_DES_64_CBC_WITH_MD5,                 0x00, 0x40,
@@ skipping 72 matching lines @@
     "RC2-CBC",
     "RC2-CBC-Export",
     "IDEA-CBC",
     "DES-CBC",
     "DES-EDE3-CBC",
     "unknown",
     "unknown", /* was fortezza, NO LONGER USED */
 };
 
 
-/* bit-masks, showing which SSLv2 suites are allowed.
+/* bit-mask, showing which SSLv2 suites are allowed.
  * lsb corresponds to first cipher suite in allCipherSuites[].
  */
-static PRUint16 allowedByPolicy;          /* all off by default */
-static PRUint16 maybeAllowedByPolicy;     /* all off by default */
 static PRUint16 chosenPreference = 0xff;  /* all on  by default */
 
-/* bit values for the above two bit masks */
+/* bit values for the above bit mask */
 #define SSL_CB_RC4_128_WITH_MD5              (1 << SSL_CK_RC4_128_WITH_MD5)
 #define SSL_CB_RC4_128_EXPORT40_WITH_MD5     (1 << SSL_CK_RC4_128_EXPORT40_WITH_MD5)
 #define SSL_CB_RC2_128_CBC_WITH_MD5          (1 << SSL_CK_RC2_128_CBC_WITH_MD5)
 #define SSL_CB_RC2_128_CBC_EXPORT40_WITH_MD5 (1 << SSL_CK_RC2_128_CBC_EXPORT40_WITH_MD5)
 #define SSL_CB_IDEA_128_CBC_WITH_MD5         (1 << SSL_CK_IDEA_128_CBC_WITH_MD5)
 #define SSL_CB_DES_64_CBC_WITH_MD5           (1 << SSL_CK_DES_64_CBC_WITH_MD5)
 #define SSL_CB_DES_192_EDE3_CBC_WITH_MD5     (1 << SSL_CK_DES_192_EDE3_CBC_WITH_MD5)
 #define SSL_CB_IMPLEMENTED \
    (SSL_CB_RC4_128_WITH_MD5              | \
     SSL_CB_RC4_128_EXPORT40_WITH_MD5     | \
@@ skipping 14 matching lines @@
     int                 ssl3_count      = 0;
     int                 final_count;
     int                 i;
     SECStatus           rv;
 
     PORT_Assert( ss->opt.noLocks || ssl_Have1stHandshakeLock(ss) );
 
     count = 0;
     PORT_Assert(ss != 0);
     allowed = !ss->opt.enableSSL2 ? 0 :
-        (ss->allowedByPolicy & ss->chosenPreference & SSL_CB_IMPLEMENTED);
+        (ss->chosenPreference & SSL_CB_IMPLEMENTED);
     while (allowed) {
         if (allowed & 1) 
             ++count;
         allowed >>= 1;
     }
 
-    /* Call ssl3_config_match_init() once here, 
+    /* Call ssl3_cipher_suite_available_init() once here, 
      * instead of inside ssl3_ConstructV2CipherSpecsHack(),
      * because the latter gets called twice below, 
      * and then again in ssl2_BeginClientHandshake().
      */
-    ssl3_config_match_init(ss);
+    ssl3_cipher_suite_available_init(ss);
 
     /* ask SSL3 how many cipher suites it has. */
     rv = ssl3_ConstructV2CipherSpecsHack(ss, NULL, &ssl3_count);
     if (rv < 0) 
         return rv;
     count += ssl3_count;
 
     /* Allocate memory to hold cipher specs */
     if (count > 0)
         cs = (PRUint8*) PORT_Alloc(count * 3);
     else
         PORT_SetError(SSL_ERROR_SSL_DISABLED);
     if (cs == NULL)
         return SECFailure;
 
     if (ss->cipherSpecs != NULL) {
         PORT_Free(ss->cipherSpecs);
     }
     ss->cipherSpecs     = cs;
     ss->sizeCipherSpecs = count * 3;
 
     /* fill in cipher specs for SSL2 cipher suites */
     allowed = !ss->opt.enableSSL2 ? 0 :
-        (ss->allowedByPolicy & ss->chosenPreference & SSL_CB_IMPLEMENTED);
+        (ss->chosenPreference & SSL_CB_IMPLEMENTED);
     for (i = 0; i < ssl2_NUM_SUITES_IMPLEMENTED * 3; i += 3) {
         const PRUint8 * hs = implementedCipherSuites + i;
         int             ok = allowed & (1U << hs[0]);
         if (ok) {
             cs[0] = hs[0];
             cs[1] = hs[1];
             cs[2] = hs[2];
             cs += 3;
         }
     }
@@ skipping 11 matching lines @@
 ** at the beginning of a handshake.  It detects cases where a protocol
 ** (e.g. SSL2 or SSL3) is logically enabled, but all its cipher suites
 ** for that protocol have been disabled.  If such cases, it clears the 
 ** enable bit for the protocol.  If no protocols remain enabled, or
 ** if no cipher suites are found, it sets the error code and returns
 ** SECFailure, otherwise it returns SECSuccess.
 */
 static SECStatus
 ssl2_CheckConfigSanity(sslSocket *ss)
 {
-    unsigned int      allowed;
     int               ssl3CipherCount = 0;
     SECStatus         rv;
 
     /* count the SSL2 and SSL3 enabled ciphers.
      * if either is zero, clear the socket's enable for that protocol.
      */
     if (!ss->cipherSpecs)
         goto disabled;
 
-    allowed = ss->allowedByPolicy & ss->chosenPreference;
-    if (! allowed)
+    if (!ss->chosenPreference)
         ss->opt.enableSSL2 = PR_FALSE; /* not really enabled if no ciphers */
 
-    /* ssl3_config_match_init was called in ssl2_ConstructCipherSpecs(). */
+    /* ssl3_cipher_suite_available_init was called in
+     * ssl2_ConstructCipherSpecs(). */
     /* Ask how many ssl3 CipherSuites were enabled. */
     rv = ssl3_ConstructV2CipherSpecsHack(ss, NULL, &ssl3CipherCount);
     if (rv != SECSuccess || ssl3CipherCount <= 0) {
         /* 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 && 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
  * HandshakeLock to protect this.  Probably want a global lock.
- */
-SECStatus
-ssl2_SetPolicy(PRInt32 which, PRInt32 policy)
-{
-    PRUint32  bitMask;
-    SECStatus rv       = SECSuccess;
-
-    which &= 0x000f;
-    bitMask = 1 << which;
-
-    if (!(bitMask & SSL_CB_IMPLEMENTED)) {
-        PORT_SetError(SSL_ERROR_UNKNOWN_CIPHER_SUITE);
-        return SECFailure;
-    }
-
-    if (policy == SSL_ALLOWED) {
-        allowedByPolicy         |= bitMask;
-        maybeAllowedByPolicy    |= bitMask;
-    } else if (policy == SSL_RESTRICTED) {
-        allowedByPolicy         &= ~bitMask;
-        maybeAllowedByPolicy    |= bitMask;
-    } else {
-        allowedByPolicy         &= ~bitMask;
-        maybeAllowedByPolicy    &= ~bitMask;
-    }
-    allowedByPolicy             &= SSL_CB_IMPLEMENTED;
-    maybeAllowedByPolicy        &= SSL_CB_IMPLEMENTED;
-
-    policyWasSet = PR_TRUE;
-    return rv;
-}
-
-SECStatus
-ssl2_GetPolicy(PRInt32 which, PRInt32 *oPolicy)
-{
-    PRUint32     bitMask;
-    PRInt32      policy;
-
-    which &= 0x000f;
-    bitMask = 1 << which;
-
-    /* Caller assures oPolicy is not null. */
-    if (!(bitMask & SSL_CB_IMPLEMENTED)) {
-        PORT_SetError(SSL_ERROR_UNKNOWN_CIPHER_SUITE);
-        *oPolicy = SSL_NOT_ALLOWED;
-        return SECFailure;
-    }
-
-    if (maybeAllowedByPolicy & bitMask) {
-        policy = (allowedByPolicy & bitMask) ? SSL_ALLOWED : SSL_RESTRICTED;
-    } else {
-        policy = SSL_NOT_ALLOWED;
-    }
-
-    *oPolicy = policy;
-    return SECSuccess;
-}
-
-/* 
- * Since this is a global (not per-socket) setting, we cannot use the
- * HandshakeLock to protect this.  Probably want a global lock.
  * Called from SSL_CipherPrefSetDefault in sslsock.c
  * These changes have no effect on any sslSockets already created. 
  */
 SECStatus
 ssl2_CipherPrefSetDefault(PRInt32 which, PRBool enabled)
 {
     PRUint32     bitMask;
     
     which &= 0x000f;
     bitMask = 1 << which;
@@ skipping 68 matching lines @@
         *enabled = PR_FALSE;
         return SECFailure;
     }
 
     rv = (PRBool)((ss->chosenPreference & bitMask) != 0);
     *enabled = rv;
     return SECSuccess;
 }
 
 
-/* copy global default policy into socket. */
+/* copy global default cipher suite preferences into socket. */
 void      
-ssl2_InitSocketPolicy(sslSocket *ss)
+ssl2_InitSocketCipherSuites(sslSocket *ss)
 {
-    ss->allowedByPolicy         = allowedByPolicy;
-    ss->maybeAllowedByPolicy    = maybeAllowedByPolicy;
     ss->chosenPreference        = chosenPreference;
 }
 
 
 /************************************************************************/
 
 /* Called from ssl2_CreateSessionCypher(), which already holds handshake lock.
  */
 static SECStatus
 ssl2_CreateMAC(sslSecurityInfo *sec, SECItem *readKey, SECItem *writeKey, 
@@ skipping 1120 matching lines @@
 {
     PRUint8      *    dk   = NULL; /* decrypted master key */
     sslSessionID *    sid;
     sslServerCerts *  sc   = ss->serverCerts + kt_rsa;
     PRUint8       *   kbuf = 0; /* buffer for RSA decrypted data. */
     unsigned int      ddLen;    /* length of RSA decrypted data in kbuf */
     unsigned int      keySize;
     unsigned int      dkLen;    /* decrypted key length in bytes */
     int               modulusLen;
     SECStatus         rv;
-    PRUint16          allowed;  /* cipher kinds enabled and allowed by policy */
+    PRUint16          allowed;  /* cipher kinds enabled */
     PRUint8           mkbuf[SSL_MAX_MASTER_KEY_BYTES];
 
     PORT_Assert( ss->opt.noLocks || ssl_Have1stHandshakeLock(ss) );
     PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss)   );
     PORT_Assert((sc->SERVERKEY != 0));
     PORT_Assert((ss->sec.ci.sid != 0));
     sid = ss->sec.ci.sid;
 
     /* Trying to cut down on all these switch statements that should be tables.
      * So, test cipherType once, here, and then use tables below. 
      */
     switch (cipher) {
     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:
     case SSL_CK_DES_64_CBC_WITH_MD5:
     case SSL_CK_DES_192_EDE3_CBC_WITH_MD5:
         break;
 
     default:
         SSL_DBG(("%d: SSL[%d]: ssl2_ServerSetupSessionCypher: unknown cipher=%d",
                  SSL_GETPID(), ss->fd, cipher));
         PORT_SetError(SSL_ERROR_BAD_CLIENT);
         goto loser;
     }
 
-    allowed = ss->allowedByPolicy & ss->chosenPreference & SSL_CB_IMPLEMENTED;
+    allowed = ss->chosenPreference & SSL_CB_IMPLEMENTED;
     if (!(allowed & (1 << cipher))) {
         /* client chose a kind we don't allow! */
         SSL_DBG(("%d: SSL[%d]: disallowed cipher=%d",
                  SSL_GETPID(), ss->fd, cipher));
         PORT_SetError(SSL_ERROR_BAD_CLIENT);
         goto loser;
     }
 
     keySize = ssl_Specs[cipher].keyLen;
     if (keyBits != keySize * BPB) {
@@ skipping 209 matching lines @@
     PORT_Assert( ss->opt.noLocks || ssl_Have1stHandshakeLock(ss) );
     PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss)   );
 
     if (!ss->cipherSpecs) {
         SECStatus rv = ssl2_ConstructCipherSpecs(ss);
         if (rv != SECSuccess || !ss->cipherSpecs) 
             goto loser;
     }
 
     if (!ss->preferredCipher) {
-        unsigned int allowed = ss->allowedByPolicy & ss->chosenPreference &
-                               SSL_CB_IMPLEMENTED;
+        unsigned int allowed = ss->chosenPreference & SSL_CB_IMPLEMENTED;
         if (allowed) {
             preferred = implementedCipherSuites;
             for (i = ssl2_NUM_SUITES_IMPLEMENTED; i > 0; --i) {
                 if (0 != (allowed & (1U << preferred[0]))) {
                     ss->preferredCipher = preferred;
                     break;
                 }
                 preferred += 3;
             }
         }
@@ skipping 1858 matching lines @@
 
     c = __nss_ssl_rcsid[0] + __nss_ssl_sccsid[0]; 
     return NSS_VersionCheck(importedVersion);
 }
 
 const char *
 NSSSSL_GetVersion(void)
 {
     return NSS_VERSION;
 }