diff -up ./lib/ssl/ssl3con.c.dhe_and_sha384 ./lib/ssl/ssl3con.c

--- ./lib/ssl/ssl3con.c.dhe_and_sha384	2016-02-14 07:51:49.910312410 -0800

+++ ./lib/ssl/ssl3con.c	2016-02-14 08:03:31.562277561 -0800

@@ -68,6 +68,8 @@ static SECStatus ssl3_ComputeHandshakeHa

                                              SSL3Hashes *hashes,

                                              PRUint32 sender);

 static SECStatus ssl3_FlushHandshakeMessages(sslSocket *ss, PRInt32 flags);

+static int       ssl3_OIDToTLSHashAlgorithm(SECOidTag oid);

+static CK_MECHANISM_TYPE ssl3_GetPrfHashMechanism(sslSocket *ss);

 static SECStatus Null_Cipher(void *ctx, unsigned char *output, int *outputLen,

 			     int maxOutputLen, const unsigned char *input,

@@ -95,23 +97,37 @@ static ssl3CipherSuiteCfg cipherSuites[s

    /*      cipher_suite                     policy       enabled   isPresent */

 #ifndef NSS_DISABLE_ECC

- { TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE},

- { TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,   SSL_ALLOWED, PR_TRUE, PR_FALSE},

-   /* TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA is out of order to work around

-    * bug 946147.

-    */

+ /* Ephemeral ECDH */

+ { TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, SSL_ALLOWED, PR_TRUE, PR_FALSE},

  { TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,    SSL_ALLOWED, PR_TRUE, PR_FALSE},

+ /* TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA must be before TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA

+  * to workaround bug 946147.

+  */

+ { TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, SSL_ALLOWED, PR_FALSE, PR_FALSE},

+ { TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE},

  { TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,    SSL_ALLOWED, PR_TRUE, PR_FALSE},

- { TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,      SSL_ALLOWED, PR_TRUE, PR_FALSE},

- { TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE},

- { TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,   SSL_ALLOWED, PR_TRUE, PR_FALSE},

- { TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,      SSL_ALLOWED, PR_TRUE, PR_FALSE},

+ { TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

- { TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,        SSL_ALLOWED, PR_FALSE, PR_FALSE},

+ { TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,   SSL_ALLOWED, PR_TRUE, PR_FALSE},

+ { TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,      SSL_ALLOWED, PR_TRUE, PR_FALSE},

+ { TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

+ { TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,   SSL_ALLOWED, PR_TRUE, PR_FALSE},

+ { TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,      SSL_ALLOWED, PR_TRUE, PR_FALSE},

+ { TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

+ { TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_ECDHE_RSA_WITH_RC4_128_SHA,          SSL_ALLOWED, PR_FALSE, PR_FALSE},

 #endif /* NSS_DISABLE_ECC */

+ /* Ephemeral Finite Field DH */

+ { TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,     SSL_ALLOWED, PR_TRUE, PR_FALSE},

+ { TLS_DHE_DSS_WITH_AES_256_GCM_SHA384,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

+ { TLS_DHE_RSA_WITH_AES_256_CBC_SHA,        SSL_ALLOWED, PR_TRUE,  PR_FALSE},

+ { TLS_DHE_DSS_WITH_AES_256_CBC_SHA,        SSL_ALLOWED, PR_TRUE,  PR_FALSE},

+ { TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,     SSL_ALLOWED, PR_TRUE,  PR_FALSE},

+ { TLS_DHE_DSS_WITH_AES_256_CBC_SHA256,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

+ { TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

+ { TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,     SSL_ALLOWED, PR_TRUE,  PR_FALSE},

  { TLS_DHE_DSS_WITH_AES_128_GCM_SHA256,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_DHE_RSA_WITH_AES_128_CBC_SHA,        SSL_ALLOWED, PR_TRUE,  PR_FALSE},

@@ -120,17 +136,12 @@ static ssl3CipherSuiteCfg cipherSuites[s

  { TLS_DHE_DSS_WITH_AES_128_CBC_SHA256,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

- { TLS_DHE_RSA_WITH_AES_256_CBC_SHA,        SSL_ALLOWED, PR_TRUE,  PR_FALSE},

- { TLS_DHE_DSS_WITH_AES_256_CBC_SHA,        SSL_ALLOWED, PR_TRUE,  PR_FALSE},

- { TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,     SSL_ALLOWED, PR_TRUE,  PR_FALSE},

- { TLS_DHE_DSS_WITH_AES_256_CBC_SHA256,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

- { TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

- { TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,   SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,       SSL_ALLOWED, PR_TRUE,  PR_FALSE},

  { TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA,       SSL_ALLOWED, PR_TRUE,  PR_FALSE},

  { TLS_DHE_DSS_WITH_RC4_128_SHA,            SSL_ALLOWED, PR_FALSE, PR_FALSE},

 #ifndef NSS_DISABLE_ECC

+ /* Non ephemeral ECDH */

  { TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,       SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,     SSL_ALLOWED, PR_FALSE, PR_FALSE},

@@ -142,18 +153,19 @@ static ssl3CipherSuiteCfg cipherSuites[s

 #endif /* NSS_DISABLE_ECC */

  /* RSA */

+ { TLS_RSA_WITH_AES_256_GCM_SHA384,         SSL_ALLOWED, PR_TRUE,  PR_FALSE},

+ { TLS_RSA_WITH_AES_256_CBC_SHA,            SSL_ALLOWED, PR_TRUE,  PR_FALSE},

+ { TLS_RSA_WITH_AES_256_CBC_SHA256,         SSL_ALLOWED, PR_TRUE,  PR_FALSE},

+ { TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,       SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_RSA_WITH_AES_128_GCM_SHA256,         SSL_ALLOWED, PR_TRUE,  PR_FALSE},

  { TLS_RSA_WITH_AES_128_CBC_SHA,            SSL_ALLOWED, PR_TRUE,  PR_FALSE},

  { TLS_RSA_WITH_AES_128_CBC_SHA256,         SSL_ALLOWED, PR_TRUE,  PR_FALSE},

  { TLS_RSA_WITH_CAMELLIA_128_CBC_SHA,       SSL_ALLOWED, PR_FALSE, PR_FALSE},

- { TLS_RSA_WITH_AES_256_CBC_SHA,            SSL_ALLOWED, PR_TRUE,  PR_FALSE},

- { TLS_RSA_WITH_AES_256_CBC_SHA256,         SSL_ALLOWED, PR_TRUE,  PR_FALSE},

- { TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,       SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_RSA_WITH_SEED_CBC_SHA,               SSL_ALLOWED, PR_FALSE, PR_FALSE},

- { SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA,      SSL_ALLOWED, PR_FALSE, PR_FALSE},

  { TLS_RSA_WITH_3DES_EDE_CBC_SHA,           SSL_ALLOWED, PR_TRUE,  PR_FALSE},

  { TLS_RSA_WITH_RC4_128_SHA,                SSL_ALLOWED, PR_TRUE,  PR_FALSE},

  { TLS_RSA_WITH_RC4_128_MD5,                SSL_ALLOWED, PR_TRUE,  PR_FALSE},

+ { SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA,      SSL_ALLOWED, PR_FALSE, PR_FALSE},

  /* 56-bit DES "domestic" cipher suites */

  { TLS_DHE_RSA_WITH_DES_CBC_SHA,            SSL_ALLOWED, PR_FALSE, PR_FALSE},

@@ -292,6 +304,7 @@ static const ssl3BulkCipherDef bulk_ciph

     {cipher_camellia_256, calg_camellia,    32,32, type_block, 16,16, 0, 0},

     {cipher_seed,         calg_seed,        16,16, type_block, 16,16, 0, 0},

     {cipher_aes_128_gcm,  calg_aes_gcm,     16,16, type_aead,   4, 0,16, 8},

+    {cipher_aes_256_gcm,  calg_aes_gcm,     32,32, type_aead,   4, 0,16, 8},

     {cipher_missing,      calg_null,         0, 0, type_stream, 0, 0, 0, 0},

 };

@@ -300,8 +313,8 @@ static const ssl3KEADef kea_defs[] =

     /* kea            exchKeyType signKeyType is_limited limit tls_keygen ephemeral */

     {kea_null,           kt_null, sign_null,  PR_FALSE,   0, PR_FALSE, PR_FALSE},

     {kea_rsa,            kt_rsa,  sign_rsa,   PR_FALSE,   0, PR_FALSE, PR_FALSE},

-    {kea_rsa_export,     kt_rsa,  sign_rsa,   PR_TRUE,  512, PR_FALSE, PR_FALSE},

-    {kea_rsa_export_1024,kt_rsa,  sign_rsa,   PR_TRUE, 1024, PR_FALSE, PR_FALSE},

+    {kea_rsa_export,     kt_rsa,  sign_rsa,   PR_TRUE,  512, PR_FALSE, PR_TRUE},

+    {kea_rsa_export_1024,kt_rsa,  sign_rsa,   PR_TRUE, 1024, PR_FALSE, PR_TRUE},

     {kea_dh_dss,         kt_dh,   sign_dsa,   PR_FALSE,   0, PR_FALSE, PR_FALSE},

     {kea_dh_dss_export,  kt_dh,   sign_dsa,   PR_TRUE,  512, PR_FALSE, PR_FALSE},

     {kea_dh_rsa,         kt_dh,   sign_rsa,   PR_FALSE,   0, PR_FALSE, PR_FALSE},

@@ -327,135 +340,149 @@ static const ssl3CipherSuiteDef cipher_s

 {

 /*  cipher_suite                    bulk_cipher_alg mac_alg key_exchange_alg */

-    {TLS_NULL_WITH_NULL_NULL,       cipher_null,   mac_null, kea_null},

-    {TLS_RSA_WITH_NULL_MD5,         cipher_null,   mac_md5, kea_rsa},

-    {TLS_RSA_WITH_NULL_SHA,         cipher_null,   mac_sha, kea_rsa},

-    {TLS_RSA_WITH_NULL_SHA256,      cipher_null,   hmac_sha256, kea_rsa},

-    {TLS_RSA_EXPORT_WITH_RC4_40_MD5,cipher_rc4_40, mac_md5, kea_rsa_export},

-    {TLS_RSA_WITH_RC4_128_MD5,      cipher_rc4,    mac_md5, kea_rsa},

-    {TLS_RSA_WITH_RC4_128_SHA,      cipher_rc4,    mac_sha, kea_rsa},

+    {TLS_NULL_WITH_NULL_NULL,       cipher_null,   mac_null, kea_null, 0},

+    {TLS_RSA_WITH_NULL_MD5,         cipher_null,   mac_md5, kea_rsa, 0},

+    {TLS_RSA_WITH_NULL_SHA,         cipher_null,   mac_sha, kea_rsa, 0},

+    {TLS_RSA_WITH_NULL_SHA256,      cipher_null,   hmac_sha256, kea_rsa, prf_256},

+    {TLS_RSA_EXPORT_WITH_RC4_40_MD5,cipher_rc4_40, mac_md5, kea_rsa_export, 0},

+    {TLS_RSA_WITH_RC4_128_MD5,      cipher_rc4,    mac_md5, kea_rsa, 0},

+    {TLS_RSA_WITH_RC4_128_SHA,      cipher_rc4,    mac_sha, kea_rsa, 0},

     {TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5,

-                                    cipher_rc2_40, mac_md5, kea_rsa_export},

+                                    cipher_rc2_40, mac_md5, kea_rsa_export, 0},

 #if 0 /* not implemented */

-    {TLS_RSA_WITH_IDEA_CBC_SHA,     cipher_idea,   mac_sha, kea_rsa},

+    {TLS_RSA_WITH_IDEA_CBC_SHA,     cipher_idea,   mac_sha, kea_rsa, 0},

     {TLS_RSA_EXPORT_WITH_DES40_CBC_SHA,

-                                    cipher_des40,  mac_sha, kea_rsa_export},

+                                    cipher_des40,  mac_sha, kea_rsa_export, 0},

 #endif

-    {TLS_RSA_WITH_DES_CBC_SHA,      cipher_des,    mac_sha, kea_rsa},

-    {TLS_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des,   mac_sha, kea_rsa},

-    {TLS_DHE_DSS_WITH_DES_CBC_SHA,  cipher_des,    mac_sha, kea_dhe_dss},

+    {TLS_RSA_WITH_DES_CBC_SHA,      cipher_des,    mac_sha, kea_rsa, 0},

+    {TLS_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des,   mac_sha, kea_rsa, 0},

+    {TLS_DHE_DSS_WITH_DES_CBC_SHA,  cipher_des,    mac_sha, kea_dhe_dss, 0},

     {TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA,

-                                    cipher_3des,   mac_sha, kea_dhe_dss},

-    {TLS_DHE_DSS_WITH_RC4_128_SHA,  cipher_rc4,    mac_sha, kea_dhe_dss},

+                                    cipher_3des,   mac_sha, kea_dhe_dss, 0},

+    {TLS_DHE_DSS_WITH_RC4_128_SHA,  cipher_rc4,    mac_sha, kea_dhe_dss, 0},

 #if 0 /* not implemented */

     {TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA,

-                                    cipher_des40,  mac_sha, kea_dh_dss_export},

-    {TLS_DH_DSS_DES_CBC_SHA,        cipher_des,    mac_sha, kea_dh_dss},

-    {TLS_DH_DSS_3DES_CBC_SHA,       cipher_3des,   mac_sha, kea_dh_dss},

+                                    cipher_des40,  mac_sha, kea_dh_dss_export, 0},

+    {TLS_DH_DSS_DES_CBC_SHA,        cipher_des,    mac_sha, kea_dh_dss, 0},

+    {TLS_DH_DSS_3DES_CBC_SHA,       cipher_3des,   mac_sha, kea_dh_dss, 0},

     {TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA,

-                                    cipher_des40,  mac_sha, kea_dh_rsa_export},

-    {TLS_DH_RSA_DES_CBC_SHA,        cipher_des,    mac_sha, kea_dh_rsa},

-    {TLS_DH_RSA_3DES_CBC_SHA,       cipher_3des,   mac_sha, kea_dh_rsa},

+                                    cipher_des40,  mac_sha, kea_dh_rsa_export, 0},

+    {TLS_DH_RSA_DES_CBC_SHA,        cipher_des,    mac_sha, kea_dh_rsa, 0},

+    {TLS_DH_RSA_3DES_CBC_SHA,       cipher_3des,   mac_sha, kea_dh_rsa, 0},

     {TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA,

-                                    cipher_des40,  mac_sha, kea_dh_dss_export},

+                                    cipher_des40,  mac_sha, kea_dh_dss_export, 0},

     {TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA,

-                                    cipher_des40,  mac_sha, kea_dh_rsa_export},

+                                    cipher_des40,  mac_sha, kea_dh_rsa_export, 0},

 #endif

-    {TLS_DHE_RSA_WITH_DES_CBC_SHA,  cipher_des,    mac_sha, kea_dhe_rsa},

+    {TLS_DHE_RSA_WITH_DES_CBC_SHA,  cipher_des,    mac_sha, kea_dhe_rsa, 0},

     {TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,

-                                    cipher_3des,   mac_sha, kea_dhe_rsa},

+                                    cipher_3des,   mac_sha, kea_dhe_rsa, 0},

 #if 0

-    {SSL_DH_ANON_EXPORT_RC4_40_MD5, cipher_rc4_40, mac_md5, kea_dh_anon_export},

+    {SSL_DH_ANON_EXPORT_RC4_40_MD5, cipher_rc4_40, mac_md5, kea_dh_anon_export, 0},

     {TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA,

-                                    cipher_des40,  mac_sha, kea_dh_anon_export},

-    {TLS_DH_anon_WITH_DES_CBC_SHA,  cipher_des,    mac_sha, kea_dh_anon},

-    {TLS_DH_anon_WITH_3DES_CBC_SHA, cipher_3des,   mac_sha, kea_dh_anon},

+                                    cipher_des40,  mac_sha, kea_dh_anon_export, 0},

+    {TLS_DH_anon_WITH_DES_CBC_SHA,  cipher_des,    mac_sha, kea_dh_anon, 0},

+    {TLS_DH_anon_WITH_3DES_CBC_SHA, cipher_3des,   mac_sha, kea_dh_anon, 0},

 #endif

 /* New TLS cipher suites */

-    {TLS_RSA_WITH_AES_128_CBC_SHA,     	cipher_aes_128, mac_sha, kea_rsa},

-    {TLS_RSA_WITH_AES_128_CBC_SHA256,	cipher_aes_128, hmac_sha256, kea_rsa},

-    {TLS_DHE_DSS_WITH_AES_128_CBC_SHA, 	cipher_aes_128, mac_sha, kea_dhe_dss},

-    {TLS_DHE_RSA_WITH_AES_128_CBC_SHA, 	cipher_aes_128, mac_sha, kea_dhe_rsa},

-    {TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_dhe_rsa},

-    {TLS_RSA_WITH_AES_256_CBC_SHA,     	cipher_aes_256, mac_sha, kea_rsa},

-    {TLS_RSA_WITH_AES_256_CBC_SHA256,	cipher_aes_256, hmac_sha256, kea_rsa},

-    {TLS_DHE_DSS_WITH_AES_256_CBC_SHA, 	cipher_aes_256, mac_sha, kea_dhe_dss},

-    {TLS_DHE_RSA_WITH_AES_256_CBC_SHA, 	cipher_aes_256, mac_sha, kea_dhe_rsa},

-    {TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, cipher_aes_256, hmac_sha256, kea_dhe_rsa},

+    {TLS_RSA_WITH_AES_128_CBC_SHA,     	cipher_aes_128, mac_sha, kea_rsa, 0},

+    {TLS_RSA_WITH_AES_128_CBC_SHA256,	cipher_aes_128, hmac_sha256, kea_rsa, prf_256},

+    {TLS_DHE_DSS_WITH_AES_128_CBC_SHA, 	cipher_aes_128, mac_sha, kea_dhe_dss, 0},

+    {TLS_DHE_RSA_WITH_AES_128_CBC_SHA, 	cipher_aes_128, mac_sha, kea_dhe_rsa, 0},

+    {TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_dhe_rsa, prf_256},

+    {TLS_RSA_WITH_AES_256_CBC_SHA,     	cipher_aes_256, mac_sha, kea_rsa, 0},

+    {TLS_RSA_WITH_AES_256_CBC_SHA256,	cipher_aes_256, hmac_sha256, kea_rsa, prf_256},

+    {TLS_DHE_DSS_WITH_AES_256_CBC_SHA, 	cipher_aes_256, mac_sha, kea_dhe_dss, 0},

+    {TLS_DHE_RSA_WITH_AES_256_CBC_SHA, 	cipher_aes_256, mac_sha, kea_dhe_rsa, 0},

+    {TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, cipher_aes_256, hmac_sha256, kea_dhe_rsa, prf_256},

 #if 0

-    {TLS_DH_DSS_WITH_AES_128_CBC_SHA,  	cipher_aes_128, mac_sha, kea_dh_dss},

-    {TLS_DH_RSA_WITH_AES_128_CBC_SHA,  	cipher_aes_128, mac_sha, kea_dh_rsa},

-    {TLS_DH_anon_WITH_AES_128_CBC_SHA, 	cipher_aes_128, mac_sha, kea_dh_anon},

-    {TLS_DH_DSS_WITH_AES_256_CBC_SHA,  	cipher_aes_256, mac_sha, kea_dh_dss},

-    {TLS_DH_RSA_WITH_AES_256_CBC_SHA,  	cipher_aes_256, mac_sha, kea_dh_rsa},

-    {TLS_DH_anon_WITH_AES_256_CBC_SHA, 	cipher_aes_256, mac_sha, kea_dh_anon},

+    {TLS_DH_DSS_WITH_AES_128_CBC_SHA,  	cipher_aes_128, mac_sha, kea_dh_dss, 0},

+    {TLS_DH_RSA_WITH_AES_128_CBC_SHA,  	cipher_aes_128, mac_sha, kea_dh_rsa, 0},

+    {TLS_DH_anon_WITH_AES_128_CBC_SHA, 	cipher_aes_128, mac_sha, kea_dh_anon, 0},

+    {TLS_DH_DSS_WITH_AES_256_CBC_SHA,  	cipher_aes_256, mac_sha, kea_dh_dss, 0},

+    {TLS_DH_RSA_WITH_AES_256_CBC_SHA,  	cipher_aes_256, mac_sha, kea_dh_rsa, 0},

+    {TLS_DH_anon_WITH_AES_256_CBC_SHA, 	cipher_aes_256, mac_sha, kea_dh_anon, 0},

 #endif

-    {TLS_RSA_WITH_SEED_CBC_SHA,	    cipher_seed,   mac_sha, kea_rsa},

+    {TLS_RSA_WITH_SEED_CBC_SHA,	    cipher_seed,   mac_sha, kea_rsa, 0},

-    {TLS_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_camellia_128, mac_sha, kea_rsa},

+    {TLS_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_camellia_128, mac_sha, kea_rsa, 0},

     {TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,

-     cipher_camellia_128, mac_sha, kea_dhe_dss},

+     cipher_camellia_128, mac_sha, kea_dhe_dss, 0},

     {TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,

-     cipher_camellia_128, mac_sha, kea_dhe_rsa},

-    {TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,	cipher_camellia_256, mac_sha, kea_rsa},

+     cipher_camellia_128, mac_sha, kea_dhe_rsa, 0},

+    {TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,	cipher_camellia_256, mac_sha, kea_rsa, 0},

     {TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,

-     cipher_camellia_256, mac_sha, kea_dhe_dss},

+     cipher_camellia_256, mac_sha, kea_dhe_dss, 0},

     {TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,

-     cipher_camellia_256, mac_sha, kea_dhe_rsa},

+     cipher_camellia_256, mac_sha, kea_dhe_rsa, 0},

     {TLS_RSA_EXPORT1024_WITH_DES_CBC_SHA,

-                                    cipher_des,    mac_sha,kea_rsa_export_1024},

+                                    cipher_des,    mac_sha,kea_rsa_export_1024, 0},

     {TLS_RSA_EXPORT1024_WITH_RC4_56_SHA,

-                                    cipher_rc4_56, mac_sha,kea_rsa_export_1024},

+                                    cipher_rc4_56, mac_sha,kea_rsa_export_1024, 0},

-    {SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_rsa_fips},

-    {SSL_RSA_FIPS_WITH_DES_CBC_SHA, cipher_des,    mac_sha, kea_rsa_fips},

+    {SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_rsa_fips, 0},

+    {SSL_RSA_FIPS_WITH_DES_CBC_SHA, cipher_des,    mac_sha, kea_rsa_fips, 0},

-    {TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_dhe_rsa},

-    {TLS_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_rsa},

+    {TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_dhe_rsa, prf_256},

+    {TLS_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_rsa, prf_256},

+#ifndef NSS_DISABLE_ECC

     {TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_ecdhe_rsa},

     {TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_ecdhe_ecdsa},

-

-    {TLS_DHE_DSS_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_dhe_dss},

-    {TLS_DHE_DSS_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_dhe_dss},

-    {TLS_DHE_DSS_WITH_AES_256_CBC_SHA256, cipher_aes_256, hmac_sha256, kea_dhe_dss},

+    {TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_ecdhe_rsa, prf_256},

+    {TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_ecdhe_ecdsa, prf_256},

+    {TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, cipher_aes_256_gcm, mac_aead, kea_ecdhe_ecdsa, prf_384},

+    {TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, cipher_aes_256_gcm, mac_aead, kea_ecdhe_rsa, prf_384},

+    {TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, cipher_aes_256, hmac_sha384, kea_ecdhe_ecdsa, prf_384},

+    {TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, cipher_aes_256, hmac_sha384, kea_ecdhe_rsa, prf_384},

+#endif /* NSS_DISABLE_ECC */

+    {TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, cipher_aes_256_gcm, mac_aead, kea_dhe_rsa, prf_384},

+    {TLS_DHE_DSS_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_dhe_dss, prf_256},

+    {TLS_DHE_DSS_WITH_AES_256_GCM_SHA384, cipher_aes_256_gcm, mac_aead, kea_dhe_dss, prf_384},

+    {TLS_DHE_DSS_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_dhe_dss, prf_256},

+    {TLS_DHE_DSS_WITH_AES_256_CBC_SHA256, cipher_aes_256, hmac_sha256, kea_dhe_dss, prf_256},

+    {TLS_RSA_WITH_AES_256_GCM_SHA384, cipher_aes_256_gcm, mac_aead, kea_rsa, prf_384},

+

+    {TLS_DHE_DSS_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_dhe_dss, 0},

+    {TLS_DHE_DSS_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_dhe_dss, 0},

+    {TLS_DHE_DSS_WITH_AES_256_CBC_SHA256, cipher_aes_256, hmac_sha256, kea_dhe_dss, 0},

 #ifndef NSS_DISABLE_ECC

-    {TLS_ECDH_ECDSA_WITH_NULL_SHA,        cipher_null, mac_sha, kea_ecdh_ecdsa},

-    {TLS_ECDH_ECDSA_WITH_RC4_128_SHA,      cipher_rc4, mac_sha, kea_ecdh_ecdsa},

-    {TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdh_ecdsa},

-    {TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdh_ecdsa},

-    {TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdh_ecdsa},

-

-    {TLS_ECDHE_ECDSA_WITH_NULL_SHA,        cipher_null, mac_sha, kea_ecdhe_ecdsa},

-    {TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,      cipher_rc4, mac_sha, kea_ecdhe_ecdsa},

-    {TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdhe_ecdsa},

-    {TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdhe_ecdsa},

-    {TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_ecdhe_ecdsa},

-    {TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdhe_ecdsa},

-

-    {TLS_ECDH_RSA_WITH_NULL_SHA,         cipher_null,    mac_sha, kea_ecdh_rsa},

-    {TLS_ECDH_RSA_WITH_RC4_128_SHA,      cipher_rc4,     mac_sha, kea_ecdh_rsa},

-    {TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des,    mac_sha, kea_ecdh_rsa},

-    {TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,  cipher_aes_128, mac_sha, kea_ecdh_rsa},

-    {TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,  cipher_aes_256, mac_sha, kea_ecdh_rsa},

-

-    {TLS_ECDHE_RSA_WITH_NULL_SHA,         cipher_null,    mac_sha, kea_ecdhe_rsa},

-    {TLS_ECDHE_RSA_WITH_RC4_128_SHA,      cipher_rc4,     mac_sha, kea_ecdhe_rsa},

-    {TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des,    mac_sha, kea_ecdhe_rsa},

-    {TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,  cipher_aes_128, mac_sha, kea_ecdhe_rsa},

-    {TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_ecdhe_rsa},

-    {TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,  cipher_aes_256, mac_sha, kea_ecdhe_rsa},

+    {TLS_ECDH_ECDSA_WITH_NULL_SHA,        cipher_null, mac_sha, kea_ecdh_ecdsa, 0},

+    {TLS_ECDH_ECDSA_WITH_RC4_128_SHA,      cipher_rc4, mac_sha, kea_ecdh_ecdsa, 0},

+    {TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdh_ecdsa, 0},

+    {TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdh_ecdsa, 0},

+    {TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdh_ecdsa, 0},

+

+    {TLS_ECDHE_ECDSA_WITH_NULL_SHA,        cipher_null, mac_sha, kea_ecdhe_ecdsa, 0},

+    {TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,      cipher_rc4, mac_sha, kea_ecdhe_ecdsa, 0},

+    {TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdhe_ecdsa, 0},

+    {TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdhe_ecdsa, 0},

+    {TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_ecdhe_ecdsa, prf_256},

+    {TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdhe_ecdsa, 0},

+

+    {TLS_ECDH_RSA_WITH_NULL_SHA,         cipher_null,    mac_sha, kea_ecdh_rsa, 0},

+    {TLS_ECDH_RSA_WITH_RC4_128_SHA,      cipher_rc4,     mac_sha, kea_ecdh_rsa, 0},

+    {TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des,    mac_sha, kea_ecdh_rsa, 0},

+    {TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,  cipher_aes_128, mac_sha, kea_ecdh_rsa, 0},

+    {TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,  cipher_aes_256, mac_sha, kea_ecdh_rsa, 0},

+

+    {TLS_ECDHE_RSA_WITH_NULL_SHA,         cipher_null,    mac_sha, kea_ecdhe_rsa, 0},

+    {TLS_ECDHE_RSA_WITH_RC4_128_SHA,      cipher_rc4,     mac_sha, kea_ecdhe_rsa, 0},

+    {TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des,    mac_sha, kea_ecdhe_rsa, 0},

+    {TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,  cipher_aes_128, mac_sha, kea_ecdhe_rsa, 0},

+    {TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_ecdhe_rsa, prf_256},

+    {TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,  cipher_aes_256, mac_sha, kea_ecdhe_rsa, 0},

 #if 0

-    {TLS_ECDH_anon_WITH_NULL_SHA,         cipher_null,    mac_sha, kea_ecdh_anon},

-    {TLS_ECDH_anon_WITH_RC4_128_SHA,      cipher_rc4,     mac_sha, kea_ecdh_anon},

-    {TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA, cipher_3des,    mac_sha, kea_ecdh_anon},

-    {TLS_ECDH_anon_WITH_AES_128_CBC_SHA,  cipher_aes_128, mac_sha, kea_ecdh_anon},

-    {TLS_ECDH_anon_WITH_AES_256_CBC_SHA,  cipher_aes_256, mac_sha, kea_ecdh_anon},

+    {TLS_ECDH_anon_WITH_NULL_SHA,         cipher_null,    mac_sha, kea_ecdh_anon, 0},

+    {TLS_ECDH_anon_WITH_RC4_128_SHA,      cipher_rc4,     mac_sha, kea_ecdh_anon, 0},

+    {TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA, cipher_3des,    mac_sha, kea_ecdh_anon, 0},

+    {TLS_ECDH_anon_WITH_AES_128_CBC_SHA,  cipher_aes_128, mac_sha, kea_ecdh_anon, 0},

+    {TLS_ECDH_anon_WITH_AES_256_CBC_SHA,  cipher_aes_256, mac_sha, kea_ecdh_anon, 0},

 #endif

 #endif /* NSS_DISABLE_ECC */

 };

@@ -496,6 +523,7 @@ static const SSLCipher2Mech alg2Mech[] =

 #define mmech_md5_hmac CKM_MD5_HMAC

 #define mmech_sha_hmac CKM_SHA_1_HMAC

 #define mmech_sha256_hmac CKM_SHA256_HMAC

+#define mmech_sha384_hmac CKM_SHA384_HMAC

 static const ssl3MACDef mac_defs[] = { /* indexed by SSL3MACAlgorithm */

     /* pad_size is only used for SSL 3.0 MAC. See RFC 6101 Sec. 5.2.3.1. */

@@ -507,6 +535,7 @@ static const ssl3MACDef mac_defs[] = { /

     {hmac_sha,  mmech_sha_hmac,   0,  SHA1_LENGTH},

     {hmac_sha256, mmech_sha256_hmac, 0, SHA256_LENGTH},

     { mac_aead, mmech_invalid,    0,  0          },

+    {hmac_sha384, mmech_sha384_hmac, 0, SHA384_LENGTH}

 };

 /* indexed by SSL3BulkCipher */

@@ -655,19 +684,26 @@ ssl3_CipherSuiteAllowedForVersionRange(

     case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256:

     case TLS_RSA_WITH_AES_256_CBC_SHA256:

     case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:

+    case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:

     case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:

+    case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384:

     case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256:

     case TLS_RSA_WITH_AES_128_CBC_SHA256:

     case TLS_RSA_WITH_AES_128_GCM_SHA256:

+    case TLS_RSA_WITH_AES_256_GCM_SHA384:

     case TLS_DHE_DSS_WITH_AES_128_CBC_SHA256:

     case TLS_DHE_DSS_WITH_AES_256_CBC_SHA256:

     case TLS_RSA_WITH_NULL_SHA256:

         return vrange->max == SSL_LIBRARY_VERSION_TLS_1_2;

     case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:

+    case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:

     case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:

+    case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:

     case TLS_DHE_RSA_WITH_AES_128_GCM_SHA256:

+    case TLS_DHE_RSA_WITH_AES_256_GCM_SHA384:

     case TLS_DHE_DSS_WITH_AES_128_GCM_SHA256:

+    case TLS_DHE_DSS_WITH_AES_256_GCM_SHA384:

 	return vrange->max >= SSL_LIBRARY_VERSION_TLS_1_2;

     /* RFC 4492: ECC cipher suites need TLS extensions to negotiate curves and

@@ -2348,6 +2384,9 @@ ssl3_ComputeRecordMAC(

 	case ssl_hmac_sha256: /* used with TLS */

 	    hashObj = HASH_GetRawHashObject(HASH_AlgSHA256);

 	    break;

+	case ssl_hmac_sha384: /* used with TLS */

+	    hashObj = HASH_GetRawHashObject(HASH_AlgSHA384);

+	    break;

 	default:

 	    break;

 	}

@@ -3592,6 +3631,18 @@ ssl3_HandleChangeCipherSpecs(sslSocket *

     return SECSuccess;

 }

+static CK_MECHANISM_TYPE

+ssl3_GetPrfHashMechanism(sslSocket *ss)

+{

+   SSL3PRF prf_alg = ss->ssl3.hs.suite_def->prf_alg;

+

+   if (prf_alg == 0)

+	return CKM_SHA256;

+    

+   return prf_alg;

+}

+

+

 /* This method completes the derivation of the MS from the PMS.

 **

 ** 1. Derive the MS, if possible, else return an error.

@@ -3682,6 +3733,9 @@ ssl3_ComputeMasterSecretInt(sslSocket *s

     CK_TLS12_MASTER_KEY_DERIVE_PARAMS master_params;

     unsigned int      master_params_len;

+    PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss));

+    PORT_Assert( ss->opt.noLocks || ssl_HaveSpecWriteLock(ss));

+    PORT_Assert(ss->ssl3.prSpec == ss->ssl3.pwSpec);

     if (isTLS12) {

 	if(isDH) master_derive = CKM_TLS12_MASTER_KEY_DERIVE_DH;

 	else master_derive = CKM_TLS12_MASTER_KEY_DERIVE;

@@ -3709,7 +3763,7 @@ ssl3_ComputeMasterSecretInt(sslSocket *s

     master_params.RandomInfo.pServerRandom     = sr;

     master_params.RandomInfo.ulServerRandomLen = SSL3_RANDOM_LENGTH;

     if (isTLS12) {

-        master_params.prfHashMechanism = CKM_SHA256;

+        master_params.prfHashMechanism = ssl3_GetPrfHashMechanism(ss);

         master_params_len = sizeof(CK_TLS12_MASTER_KEY_DERIVE_PARAMS);

     } else {

         /* prfHashMechanism is not relevant with this PRF */

@@ -3845,7 +3899,7 @@ ssl3_DeriveMasterSecret(sslSocket *ss, P

 	rv = PK11_ExtractKeyValue(pwSpec->master_secret);

 	if (rv != SECSuccess) {

 	    return rv;

-        }

+	}

 	/* This returns the address of the secItem inside the key struct,

 	 * not a copy or a reference.  So, there's no need to free it.

 	 */

@@ -3954,7 +4008,7 @@ ssl3_DeriveConnectionKeysPKCS11(sslSocke

     if (isTLS12) {

 	key_derive    = CKM_TLS12_KEY_AND_MAC_DERIVE;

-	key_material_params.prfHashMechanism = CKM_SHA256;

+	key_material_params.prfHashMechanism = ssl3_GetPrfHashMechanism(ss);

 	key_material_params_len = sizeof(CK_TLS12_KEY_MAT_PARAMS);

     } else if (isTLS) {

 	key_derive    = CKM_TLS_KEY_AND_MAC_DERIVE;

@@ -4032,7 +4086,20 @@ ssl3_InitHandshakeHashes(sslSocket *ss)

 	if (ss->version >= SSL_LIBRARY_VERSION_TLS_1_2) {

 	    /* If we ever support ciphersuites where the PRF hash isn't SHA-256

 	     * then this will need to be updated. */

-	    ss->ssl3.hs.sha_obj = HASH_GetRawHashObject(HASH_AlgSHA256);

+	    HASH_HashType ht;

+	    CK_MECHANISM_TYPE hm;

+	    SECOidTag ot;

+	    SECOidData *hashOid;

+

+	    hm = ssl3_GetPrfHashMechanism(ss);

+	    hashOid = SECOID_FindOIDByMechanism(hm);

+	    if (hashOid == NULL) {

+	        ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE);

+	        return SECFailure;

+	    }

+	    ot = hashOid->offset;

+	    ht = HASH_GetHashTypeByOidTag(ot);

+	    ss->ssl3.hs.sha_obj = HASH_GetRawHashObject(ht);

 	    if (!ss->ssl3.hs.sha_obj) {

 		ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE);

 		return SECFailure;

@@ -4055,9 +4122,20 @@ ssl3_InitHandshakeHashes(sslSocket *ss)

 	 * that the master secret will wind up in ...

 	 */

 	if (ss->version >= SSL_LIBRARY_VERSION_TLS_1_2) {

-	    /* If we ever support ciphersuites where the PRF hash isn't SHA-256

-	     * then this will need to be updated. */

-	    ss->ssl3.hs.sha = PK11_CreateDigestContext(SEC_OID_SHA256);

+	    /* determine the hash from the prf */

+	    const SECOidData *hash_oid;

+

+	    PORT_Assert(ss->ssl3.hs.suite_def);

+	    /* Get the PKCS #11 mechanism for the Hash from the cipher suite (prf_alg)

+	     * Convert that to the OidTag. We can then use that OidTag to create our

+         * PK11Context */

+	    hash_oid = SECOID_FindOIDByMechanism(ssl3_GetPrfHashMechanism(ss));

+	    PORT_Assert(hash_oid != NULL);

+	    if (hash_oid == NULL) {

+		ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE);

+		return SECFailure;

+	    }

+	    ss->ssl3.hs.sha = PK11_CreateDigestContext(hash_oid->offset);

 	    if (ss->ssl3.hs.sha == NULL) {

 		ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE);

 		return SECFailure;

@@ -4378,6 +4456,11 @@ ssl3_AppendSignatureAndHashAlgorithm(

     sslSocket *ss, const SSLSignatureAndHashAlg* sigAndHash)

 {

     PRUint8 serialized[2];

+    unsigned char hashAlg = ssl3_OIDToTLSHashAlgorithm(sigAndHash->hashAlg);

+    if (hashAlg == 0) {

+	PORT_SetError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM);

+	return SECFailure;

+    }

     serialized[0] = (PRUint8)sigAndHash->hashAlg;

     serialized[1] = (PRUint8)sigAndHash->sigAlg;

@@ -4499,6 +4582,7 @@ static const struct {

     SECOidTag oid;

 } tlsHashOIDMap[] = {

     { ssl_hash_sha1, SEC_OID_SHA1 },

+    { ssl_hash_sha224, SEC_OID_SHA224 },

     { ssl_hash_sha256, SEC_OID_SHA256 },

     { ssl_hash_sha384, SEC_OID_SHA384 },

     { ssl_hash_sha512, SEC_OID_SHA512 }

@@ -4521,6 +4605,23 @@ ssl3_TLSHashAlgorithmToOID(SSLHashType h

     return SEC_OID_UNKNOWN;

 }

+/* ssl3_OIDToTLSHashAlgorithm converts an OID to a TLS hash algorithm

+ * identifier. If the hash is not recognised, zero is returned.

+ *

+ * See https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1 */

+static int

+ssl3_OIDToTLSHashAlgorithm(SECOidTag oid)

+{

+    unsigned int i;

+

+    for (i = 0; i < PR_ARRAY_SIZE(tlsHashOIDMap); i++) {

+	if (oid == tlsHashOIDMap[i].oid) {

+	    return tlsHashOIDMap[i].tlsHash;

+	}

+    }

+    return 0;

+}

+

 /* ssl3_TLSSignatureAlgorithmForKeyType returns the TLS 1.2 signature algorithm

  * identifier for a given KeyType. */

 static SECStatus

@@ -4843,6 +4944,11 @@ tls12_loser:

 	unsigned char md5StackBuf[256];

 	unsigned char shaStackBuf[512];

+	if (!spec->master_secret) {

+	    PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HANDSHAKE);

+	    return SECFailure;

+	}

+

 	md5StateBuf = PK11_SaveContextAlloc(ss->ssl3.hs.md5, md5StackBuf,

 					    sizeof md5StackBuf, &md5StateLen);

 	if (md5StateBuf == NULL) {

@@ -6568,6 +6674,14 @@ ssl3_HandleServerHello(sslSocket *ss, SS

     }

     ss->ssl3.hs.compression = (SSLCompressionMethod)temp;

+    /* Wait until we've figured out the cipher suite before we initialize the handshake hashes */

+    rv = ssl3_InitHandshakeHashes(ss);

+    if (rv != SECSuccess) {

+	desc = internal_error;

+	errCode = PORT_GetError();

+	goto alert_loser;

+    }

+

     /* Note that if !isTLS and the extra stuff is not extensions, we

      * do NOT goto alert_loser.

      * There are some old SSL 3.0 implementations that do send stuff

@@ -8287,6 +8401,14 @@ compression_found:

     suites.data = NULL;

     comps.data = NULL;

+    /* Wait until we've figured out the cipher suite before we initialize the handshake hashes */

+    rv = ssl3_InitHandshakeHashes(ss);

+    if (rv != SECSuccess) {

+	desc = internal_error;

+	errCode = PORT_GetError();

+	goto alert_loser;

+    }

+

     ss->sec.send = ssl3_SendApplicationData;

     /* If there are any failures while processing the old sid,

@@ -8857,6 +8979,15 @@ suite_found:

     }

     ss->ssl3.hs.compression = ssl_compression_null;

+

+    /* Wait until we've figured out the cipher suite before we initialize the handshake hashes */

+    rv = ssl3_InitHandshakeHashes(ss);

+    if (rv != SECSuccess) {

+	desc = internal_error;

+	errCode = PORT_GetError();

+	goto alert_loser;

+    }

+

     ss->sec.send            = ssl3_SendApplicationData;

     /* we don't even search for a cache hit here.  It's just a miss. */

@@ -9388,7 +9519,7 @@ ssl3_EncodeCertificateRequestSigAlgs(ssl

         /* Note that we don't support a handshake hash with anything other than

          * SHA-256, so asking for a signature from clients for something else

          * would be inviting disaster. */

-        if (alg->hashAlg == ssl_hash_sha256) {

+        if (alg->hashAlg == ssl_hash_sha256 /* || alg->hashAlg == ssl_hash_sha384*/) {

             buf[(*len)++] = (PRUint8)alg->hashAlg;

             buf[(*len)++] = (PRUint8)alg->sigAlg;

         }

@@ -10841,7 +10972,7 @@ done:

 }

 static SECStatus

-ssl3_ComputeTLSFinished(ssl3CipherSpec *spec,

+ssl3_ComputeTLSFinished(sslSocket *ss, ssl3CipherSpec *spec,

 			PRBool          isServer,

                 const   SSL3Hashes   *  hashes,

                         TLSFinished  *  tlsFinished)

@@ -10864,7 +10995,7 @@ ssl3_ComputeTLSFinished(ssl3CipherSpec *

     if (spec->version < SSL_LIBRARY_VERSION_TLS_1_2) {

 	tls_mac_params.prfMechanism = CKM_TLS_PRF;

     } else {

-	tls_mac_params.prfMechanism = CKM_SHA256;

+	tls_mac_params.prfMechanism = ssl3_GetPrfHashMechanism(ss);

     }

     tls_mac_params.ulMacLength = 12;

     tls_mac_params.ulServerOrClient = isServer ? 1 : 2;

@@ -11066,7 +11197,7 @@ ssl3_SendFinished(sslSocket *ss, PRInt32

     isTLS = (PRBool)(cwSpec->version > SSL_LIBRARY_VERSION_3_0);

     rv = ssl3_ComputeHandshakeHashes(ss, cwSpec, &hashes, sender);

     if (isTLS && rv == SECSuccess) {

-	rv = ssl3_ComputeTLSFinished(cwSpec, isServer, &hashes, &tlsFinished);

+	rv = ssl3_ComputeTLSFinished(ss, cwSpec, isServer, &hashes, &tlsFinished);

     }

     ssl_ReleaseSpecReadLock(ss);

     if (rv != SECSuccess) {

@@ -11237,7 +11368,7 @@ ssl3_HandleFinished(sslSocket *ss, SSL3O

 	    PORT_SetError(SSL_ERROR_RX_MALFORMED_FINISHED);

 	    return SECFailure;

 	}

-	rv = ssl3_ComputeTLSFinished(ss->ssl3.crSpec, !isServer, 

+	rv = ssl3_ComputeTLSFinished(ss, ss->ssl3.crSpec, !isServer, 

 	                             hashes, &tlsFinished);

 	if (!isServer)

 	    ss->ssl3.hs.finishedMsgs.tFinished[1] = tlsFinished;

diff -up ./lib/ssl/ssl3ecc.c.dhe_and_sha384 ./lib/ssl/ssl3ecc.c

--- ./lib/ssl/ssl3ecc.c.dhe_and_sha384	2015-11-08 21:12:59.000000000 -0800

+++ ./lib/ssl/ssl3ecc.c	2016-02-14 07:51:49.915312514 -0800

@@ -919,7 +919,9 @@ static const ssl3CipherSuite ecdhe_ecdsa

     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,

     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,

     TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,

+    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,

     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,

+    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,

     TLS_ECDHE_ECDSA_WITH_NULL_SHA,

     TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,

     0 /* end of list marker */

@@ -930,7 +932,9 @@ static const ssl3CipherSuite ecdhe_rsa_s

     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,

     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,

     TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,

+    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,

     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,

+    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,

     TLS_ECDHE_RSA_WITH_NULL_SHA,

     TLS_ECDHE_RSA_WITH_RC4_128_SHA,

     0 /* end of list marker */

@@ -945,11 +949,15 @@ static const ssl3CipherSuite ecSuites[]

     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,

     TLS_ECDHE_ECDSA_WITH_NULL_SHA,

     TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,

+    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,

+    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,

     TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,

     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,

     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,

     TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,

+    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,

     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,

+    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,

     TLS_ECDHE_RSA_WITH_NULL_SHA,

     TLS_ECDHE_RSA_WITH_RC4_128_SHA,

     TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,

diff -up ./lib/ssl/ssl3prot.h.dhe_and_sha384 ./lib/ssl/ssl3prot.h

--- ./lib/ssl/ssl3prot.h.dhe_and_sha384	2015-11-08 21:12:59.000000000 -0800

+++ ./lib/ssl/ssl3prot.h	2016-02-14 07:51:49.915312514 -0800

@@ -217,6 +217,32 @@ typedef struct {

     } u;

 } SSL3ServerParams;

+/* This enum reflects HashAlgorithm enum from

+ * https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1

+ *

+ * When updating, be sure to also update ssl3_TLSHashAlgorithmToOID. */

+typedef enum {

+    tls_hash_md5 = 1,

+    tls_hash_sha1 = 2,