1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ 2 /* 3 * SSL3 Protocol 4 * 5 * This Source Code Form is subject to the terms of the Mozilla Public 6 * License, v. 2.0. If a copy of the MPL was not distributed with this 7 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 8 9 /* TODO(ekr): Implement HelloVerifyRequest on server side. OK for now. */ 10 11 #include "cert.h" 12 #include "ssl.h" 13 #include "cryptohi.h" /* for DSAU_ stuff */ 14 #include "keyhi.h" 15 #include "secder.h" 16 #include "secitem.h" 17 #include "sechash.h" 18 19 #include "sslimpl.h" 20 #include "sslproto.h" 21 #include "sslerr.h" 22 #include "prtime.h" 23 #include "prinrval.h" 24 #include "prerror.h" 25 #include "pratom.h" 26 #include "prthread.h" 27 28 #include "pk11func.h" 29 #include "secmod.h" 30 #ifndef NO_PKCS11_BYPASS 31 #include "blapi.h" 32 #endif 33 34 /* This is a bodge to allow this code to be compiled against older NSS headers 35 * that don't contain the TLS 1.2 changes. */ 36 #ifndef CKM_NSS_TLS_PRF_GENERAL_SHA256 37 #define CKM_NSS_TLS_PRF_GENERAL_SHA256 (CKM_NSS + 21) 38 #define CKM_NSS_TLS_MASTER_KEY_DERIVE_SHA256 (CKM_NSS + 22) 39 #define CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256 (CKM_NSS + 23) 40 #define CKM_NSS_TLS_MASTER_KEY_DERIVE_DH_SHA256 (CKM_NSS + 24) 41 #endif 42 43 /* This is a bodge to allow this code to be compiled against older NSS 44 * headers. */ 45 #ifndef CKM_NSS_CHACHA20_POLY1305 46 #define CKM_NSS_CHACHA20_POLY1305 (CKM_NSS + 26) 47 48 typedef struct CK_NSS_AEAD_PARAMS { 49 CK_BYTE_PTR pIv; /* This is the nonce. */ 50 CK_ULONG ulIvLen; 51 CK_BYTE_PTR pAAD; 52 CK_ULONG ulAADLen; 53 CK_ULONG ulTagLen; 54 } CK_NSS_AEAD_PARAMS; 55 56 #endif 57 58 #include <stdio.h> 59 #ifdef NSS_ENABLE_ZLIB 60 #include "zlib.h" 61 #endif 62 #ifdef LINUX 63 #include <dlfcn.h> 64 #endif 65 66 #ifndef PK11_SETATTRS 67 #define PK11_SETATTRS(x,id,v,l) (x)->type = (id); \ 68 (x)->pValue=(v); (x)->ulValueLen = (l); 69 #endif 70 71 static SECStatus ssl3_AuthCertificate(sslSocket *ss); 72 static void ssl3_CleanupPeerCerts(sslSocket *ss); 73 static void ssl3_CopyPeerCertsFromSID(sslSocket *ss, sslSessionID *sid); 74 static PK11SymKey *ssl3_GenerateRSAPMS(sslSocket *ss, ssl3CipherSpec *spec, 75 PK11SlotInfo * serverKeySlot); 76 static SECStatus ssl3_DeriveMasterSecret(sslSocket *ss, PK11SymKey *pms); 77 static SECStatus ssl3_DeriveConnectionKeysPKCS11(sslSocket *ss); 78 static SECStatus ssl3_HandshakeFailure( sslSocket *ss); 79 static SECStatus ssl3_InitState( sslSocket *ss); 80 static SECStatus ssl3_SendCertificate( sslSocket *ss); 81 static SECStatus ssl3_SendCertificateStatus( sslSocket *ss); 82 static SECStatus ssl3_SendEmptyCertificate( sslSocket *ss); 83 static SECStatus ssl3_SendCertificateRequest(sslSocket *ss); 84 static SECStatus ssl3_SendNextProto( sslSocket *ss); 85 static SECStatus ssl3_SendEncryptedExtensions(sslSocket *ss); 86 static SECStatus ssl3_SendFinished( sslSocket *ss, PRInt32 flags); 87 static SECStatus ssl3_SendServerHello( sslSocket *ss); 88 static SECStatus ssl3_SendServerHelloDone( sslSocket *ss); 89 static SECStatus ssl3_SendServerKeyExchange( sslSocket *ss); 90 static SECStatus ssl3_UpdateHandshakeHashes( sslSocket *ss, 91 const unsigned char *b, 92 unsigned int l); 93 static SECStatus ssl3_FlushHandshakeMessages(sslSocket *ss, PRInt32 flags); 94 static int ssl3_OIDToTLSHashAlgorithm(SECOidTag oid); 95 96 static SECStatus Null_Cipher(void *ctx, unsigned char *output, int *outputLen, 97 int maxOutputLen, const unsigned char *input, 98 int inputLen); 99 #ifndef NO_PKCS11_BYPASS 100 static SECStatus ssl3_AESGCMBypass(ssl3KeyMaterial *keys, PRBool doDecrypt, 101 unsigned char *out, int *outlen, int maxout, 102 const unsigned char *in, int inlen, 103 const unsigned char *additionalData, 104 int additionalDataLen); 105 #endif 106 107 #define MAX_SEND_BUF_LENGTH 32000 /* watch for 16-bit integer overflow */ 108 #define MIN_SEND_BUF_LENGTH 4000 109 110 /* This list of SSL3 cipher suites is sorted in descending order of 111 * precedence (desirability). It only includes cipher suites we implement. 112 * This table is modified by SSL3_SetPolicy(). The ordering of cipher suites 113 * in this table must match the ordering in SSL_ImplementedCiphers (sslenum.c) 114 * 115 * Important: See bug 946147 before enabling, reordering, or adding any cipher 116 * suites to this list. 117 */ 118 static ssl3CipherSuiteCfg cipherSuites[ssl_V3_SUITES_IMPLEMENTED] = { 119 /* cipher_suite policy enabled isPresent */ 120 121 #ifdef NSS_ENABLE_ECC 122 { TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 123 { TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 124 { TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 125 { TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 126 /* TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA is out of order to work around 127 * bug 946147. 128 */ 129 { TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 130 { TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 131 { TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 132 { TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 133 { TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 134 { TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 135 { TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 136 { TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 137 { TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 138 { TLS_ECDHE_RSA_WITH_RC4_128_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 139 #endif /* NSS_ENABLE_ECC */ 140 141 { TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 142 { TLS_DHE_RSA_WITH_AES_128_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 143 { TLS_DHE_DSS_WITH_AES_128_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 144 { TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 145 { TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 146 { TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 147 { TLS_DHE_RSA_WITH_AES_256_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 148 { TLS_DHE_DSS_WITH_AES_256_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 149 { TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 150 { TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 151 { TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 152 { SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 153 { SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 154 { TLS_DHE_DSS_WITH_RC4_128_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 155 156 #ifdef NSS_ENABLE_ECC 157 { TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 158 { TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 159 { TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 160 { TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 161 { TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 162 { TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 163 { TLS_ECDH_ECDSA_WITH_RC4_128_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 164 { TLS_ECDH_RSA_WITH_RC4_128_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 165 #endif /* NSS_ENABLE_ECC */ 166 167 /* RSA */ 168 { TLS_RSA_WITH_AES_128_GCM_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 169 { TLS_RSA_WITH_AES_128_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 170 { TLS_RSA_WITH_AES_128_CBC_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 171 { TLS_RSA_WITH_CAMELLIA_128_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 172 { TLS_RSA_WITH_AES_256_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 173 { TLS_RSA_WITH_AES_256_CBC_SHA256, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 174 { TLS_RSA_WITH_CAMELLIA_256_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 175 { TLS_RSA_WITH_SEED_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 176 { SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 177 { SSL_RSA_WITH_3DES_EDE_CBC_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 178 { SSL_RSA_WITH_RC4_128_SHA, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 179 { SSL_RSA_WITH_RC4_128_MD5, SSL_ALLOWED, PR_TRUE, PR_FALSE}, 180 181 /* 56-bit DES "domestic" cipher suites */ 182 { SSL_DHE_RSA_WITH_DES_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 183 { SSL_DHE_DSS_WITH_DES_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 184 { SSL_RSA_FIPS_WITH_DES_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 185 { SSL_RSA_WITH_DES_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 186 187 /* export ciphersuites with 1024-bit public key exchange keys */ 188 { TLS_RSA_EXPORT1024_WITH_RC4_56_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 189 { TLS_RSA_EXPORT1024_WITH_DES_CBC_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 190 191 /* export ciphersuites with 512-bit public key exchange keys */ 192 { SSL_RSA_EXPORT_WITH_RC4_40_MD5, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 193 { SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 194 195 /* ciphersuites with no encryption */ 196 #ifdef NSS_ENABLE_ECC 197 { TLS_ECDHE_ECDSA_WITH_NULL_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 198 { TLS_ECDHE_RSA_WITH_NULL_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 199 { TLS_ECDH_RSA_WITH_NULL_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 200 { TLS_ECDH_ECDSA_WITH_NULL_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 201 #endif /* NSS_ENABLE_ECC */ 202 { SSL_RSA_WITH_NULL_SHA, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 203 { TLS_RSA_WITH_NULL_SHA256, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 204 { SSL_RSA_WITH_NULL_MD5, SSL_ALLOWED, PR_FALSE, PR_FALSE}, 205 }; 206 207 /* Verify that SSL_ImplementedCiphers and cipherSuites are in consistent order. 208 */ 209 #ifdef DEBUG 210 void ssl3_CheckCipherSuiteOrderConsistency() 211 { 212 unsigned int i; 213 214 /* Note that SSL_ImplementedCiphers has more elements than cipherSuites 215 * because it SSL_ImplementedCiphers includes SSL 2.0 cipher suites. 216 */ 217 PORT_Assert(SSL_NumImplementedCiphers >= PR_ARRAY_SIZE(cipherSuites)); 218 219 for (i = 0; i < PR_ARRAY_SIZE(cipherSuites); ++i) { 220 PORT_Assert(SSL_ImplementedCiphers[i] == cipherSuites[i].cipher_suite); 221 } 222 } 223 #endif 224 225 /* This list of SSL3 compression methods is sorted in descending order of 226 * precedence (desirability). It only includes compression methods we 227 * implement. 228 */ 229 static const /*SSLCompressionMethod*/ PRUint8 compressions [] = { 230 #ifdef NSS_ENABLE_ZLIB 231 ssl_compression_deflate, 232 #endif 233 ssl_compression_null 234 }; 235 236 static const int compressionMethodsCount = 237 sizeof(compressions) / sizeof(compressions[0]); 238 239 /* compressionEnabled returns true iff the compression algorithm is enabled 240 * for the given SSL socket. */ 241 static PRBool 242 compressionEnabled(sslSocket *ss, SSLCompressionMethod compression) 243 { 244 switch (compression) { 245 case ssl_compression_null: 246 return PR_TRUE; /* Always enabled */ 247 #ifdef NSS_ENABLE_ZLIB 248 case ssl_compression_deflate: 249 return ss->opt.enableDeflate; 250 #endif 251 default: 252 return PR_FALSE; 253 } 254 } 255 256 static const /*SSL3ClientCertificateType */ PRUint8 certificate_types [] = { 257 ct_RSA_sign, 258 #ifdef NSS_ENABLE_ECC 259 ct_ECDSA_sign, 260 #endif /* NSS_ENABLE_ECC */ 261 ct_DSS_sign, 262 }; 263 264 /* This block is the contents of the supported_signature_algorithms field of 265 * our TLS 1.2 CertificateRequest message, in wire format. See 266 * https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1 267 * 268 * This block contains only sha256 entries because we only support TLS 1.2 269 * CertificateVerify messages that use the handshake hash. */ 270 static const PRUint8 supported_signature_algorithms[] = { 271 tls_hash_sha256, tls_sig_rsa, 272 #ifdef NSS_ENABLE_ECC 273 tls_hash_sha256, tls_sig_ecdsa, 274 #endif 275 tls_hash_sha256, tls_sig_dsa, 276 }; 277 278 #define EXPORT_RSA_KEY_LENGTH 64 /* bytes */ 279 280 281 /* This global item is used only in servers. It is is initialized by 282 ** SSL_ConfigSecureServer(), and is used in ssl3_SendCertificateRequest(). 283 */ 284 CERTDistNames *ssl3_server_ca_list = NULL; 285 static SSL3Statistics ssl3stats; 286 287 /* indexed by SSL3BulkCipher */ 288 static const ssl3BulkCipherDef bulk_cipher_defs[] = { 289 /* |--------- Lengths --------| */ 290 /* cipher calg k s type i b t n */ 291 /* e e v l a o */ 292 /* y c | o g n */ 293 /* | r | c | c */ 294 /* | e | k | e */ 295 /* | t | | | | */ 296 {cipher_null, calg_null, 0, 0, type_stream, 0, 0, 0, 0}, 297 {cipher_rc4, calg_rc4, 16,16, type_stream, 0, 0, 0, 0}, 298 {cipher_rc4_40, calg_rc4, 16, 5, type_stream, 0, 0, 0, 0}, 299 {cipher_rc4_56, calg_rc4, 16, 7, type_stream, 0, 0, 0, 0}, 300 {cipher_rc2, calg_rc2, 16,16, type_block, 8, 8, 0, 0}, 301 {cipher_rc2_40, calg_rc2, 16, 5, type_block, 8, 8, 0, 0}, 302 {cipher_des, calg_des, 8, 8, type_block, 8, 8, 0, 0}, 303 {cipher_3des, calg_3des, 24,24, type_block, 8, 8, 0, 0}, 304 {cipher_des40, calg_des, 8, 5, type_block, 8, 8, 0, 0}, 305 {cipher_idea, calg_idea, 16,16, type_block, 8, 8, 0, 0}, 306 {cipher_aes_128, calg_aes, 16,16, type_block, 16,16, 0, 0}, 307 {cipher_aes_256, calg_aes, 32,32, type_block, 16,16, 0, 0}, 308 {cipher_camellia_128, calg_camellia, 16,16, type_block, 16,16, 0, 0}, 309 {cipher_camellia_256, calg_camellia, 32,32, type_block, 16,16, 0, 0}, 310 {cipher_seed, calg_seed, 16,16, type_block, 16,16, 0, 0}, 311 {cipher_aes_128_gcm, calg_aes_gcm, 16,16, type_aead, 4, 0,16, 8}, 312 {cipher_chacha20, calg_chacha20, 32,32, type_aead, 0, 0,16, 0}, 313 {cipher_missing, calg_null, 0, 0, type_stream, 0, 0, 0, 0}, 314 }; 315 316 static const ssl3KEADef kea_defs[] = 317 { /* indexed by SSL3KeyExchangeAlgorithm */ 318 /* kea exchKeyType signKeyType is_limited limit tls_keygen */ 319 {kea_null, kt_null, sign_null, PR_FALSE, 0, PR_FALSE}, 320 {kea_rsa, kt_rsa, sign_rsa, PR_FALSE, 0, PR_FALSE}, 321 {kea_rsa_export, kt_rsa, sign_rsa, PR_TRUE, 512, PR_FALSE}, 322 {kea_rsa_export_1024,kt_rsa, sign_rsa, PR_TRUE, 1024, PR_FALSE}, 323 {kea_dh_dss, kt_dh, sign_dsa, PR_FALSE, 0, PR_FALSE}, 324 {kea_dh_dss_export, kt_dh, sign_dsa, PR_TRUE, 512, PR_FALSE}, 325 {kea_dh_rsa, kt_dh, sign_rsa, PR_FALSE, 0, PR_FALSE}, 326 {kea_dh_rsa_export, kt_dh, sign_rsa, PR_TRUE, 512, PR_FALSE}, 327 {kea_dhe_dss, kt_dh, sign_dsa, PR_FALSE, 0, PR_FALSE}, 328 {kea_dhe_dss_export, kt_dh, sign_dsa, PR_TRUE, 512, PR_FALSE}, 329 {kea_dhe_rsa, kt_dh, sign_rsa, PR_FALSE, 0, PR_FALSE}, 330 {kea_dhe_rsa_export, kt_dh, sign_rsa, PR_TRUE, 512, PR_FALSE}, 331 {kea_dh_anon, kt_dh, sign_null, PR_FALSE, 0, PR_FALSE}, 332 {kea_dh_anon_export, kt_dh, sign_null, PR_TRUE, 512, PR_FALSE}, 333 {kea_rsa_fips, kt_rsa, sign_rsa, PR_FALSE, 0, PR_TRUE }, 334 #ifdef NSS_ENABLE_ECC 335 {kea_ecdh_ecdsa, kt_ecdh, sign_ecdsa, PR_FALSE, 0, PR_FALSE}, 336 {kea_ecdhe_ecdsa, kt_ecdh, sign_ecdsa, PR_FALSE, 0, PR_FALSE}, 337 {kea_ecdh_rsa, kt_ecdh, sign_rsa, PR_FALSE, 0, PR_FALSE}, 338 {kea_ecdhe_rsa, kt_ecdh, sign_rsa, PR_FALSE, 0, PR_FALSE}, 339 {kea_ecdh_anon, kt_ecdh, sign_null, PR_FALSE, 0, PR_FALSE}, 340 #endif /* NSS_ENABLE_ECC */ 341 }; 342 343 /* must use ssl_LookupCipherSuiteDef to access */ 344 static const ssl3CipherSuiteDef cipher_suite_defs[] = 345 { 346 /* cipher_suite bulk_cipher_alg mac_alg key_exchange_alg */ 347 348 {SSL_NULL_WITH_NULL_NULL, cipher_null, mac_null, kea_null}, 349 {SSL_RSA_WITH_NULL_MD5, cipher_null, mac_md5, kea_rsa}, 350 {SSL_RSA_WITH_NULL_SHA, cipher_null, mac_sha, kea_rsa}, 351 {TLS_RSA_WITH_NULL_SHA256, cipher_null, hmac_sha256, kea_rsa}, 352 {SSL_RSA_EXPORT_WITH_RC4_40_MD5,cipher_rc4_40, mac_md5, kea_rsa_export}, 353 {SSL_RSA_WITH_RC4_128_MD5, cipher_rc4, mac_md5, kea_rsa}, 354 {SSL_RSA_WITH_RC4_128_SHA, cipher_rc4, mac_sha, kea_rsa}, 355 {SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5, 356 cipher_rc2_40, mac_md5, kea_rsa_export}, 357 #if 0 /* not implemented */ 358 {SSL_RSA_WITH_IDEA_CBC_SHA, cipher_idea, mac_sha, kea_rsa}, 359 {SSL_RSA_EXPORT_WITH_DES40_CBC_SHA, 360 cipher_des40, mac_sha, kea_rsa_export}, 361 #endif 362 {SSL_RSA_WITH_DES_CBC_SHA, cipher_des, mac_sha, kea_rsa}, 363 {SSL_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_rsa}, 364 {SSL_DHE_DSS_WITH_DES_CBC_SHA, cipher_des, mac_sha, kea_dhe_dss}, 365 {SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA, 366 cipher_3des, mac_sha, kea_dhe_dss}, 367 {TLS_DHE_DSS_WITH_RC4_128_SHA, cipher_rc4, mac_sha, kea_dhe_dss}, 368 #if 0 /* not implemented */ 369 {SSL_DH_DSS_EXPORT_WITH_DES40_CBC_SHA, 370 cipher_des40, mac_sha, kea_dh_dss_export}, 371 {SSL_DH_DSS_DES_CBC_SHA, cipher_des, mac_sha, kea_dh_dss}, 372 {SSL_DH_DSS_3DES_CBC_SHA, cipher_3des, mac_sha, kea_dh_dss}, 373 {SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA, 374 cipher_des40, mac_sha, kea_dh_rsa_export}, 375 {SSL_DH_RSA_DES_CBC_SHA, cipher_des, mac_sha, kea_dh_rsa}, 376 {SSL_DH_RSA_3DES_CBC_SHA, cipher_3des, mac_sha, kea_dh_rsa}, 377 {SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA, 378 cipher_des40, mac_sha, kea_dh_dss_export}, 379 {SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA, 380 cipher_des40, mac_sha, kea_dh_rsa_export}, 381 #endif 382 {SSL_DHE_RSA_WITH_DES_CBC_SHA, cipher_des, mac_sha, kea_dhe_rsa}, 383 {SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA, 384 cipher_3des, mac_sha, kea_dhe_rsa}, 385 #if 0 386 {SSL_DH_ANON_EXPORT_RC4_40_MD5, cipher_rc4_40, mac_md5, kea_dh_anon_export}, 387 {SSL_DH_ANON_EXPORT_WITH_DES40_CBC_SHA, 388 cipher_des40, mac_sha, kea_dh_anon_export}, 389 {SSL_DH_ANON_DES_CBC_SHA, cipher_des, mac_sha, kea_dh_anon}, 390 {SSL_DH_ANON_3DES_CBC_SHA, cipher_3des, mac_sha, kea_dh_anon}, 391 #endif 392 393 394 /* New TLS cipher suites */ 395 {TLS_RSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_rsa}, 396 {TLS_RSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_rsa}, 397 {TLS_DHE_DSS_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_dhe_dss}, 398 {TLS_DHE_RSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_dhe_rsa}, 399 {TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_dhe_rsa}, 400 {TLS_RSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_rsa}, 401 {TLS_RSA_WITH_AES_256_CBC_SHA256, cipher_aes_256, hmac_sha256, kea_rsa}, 402 {TLS_DHE_DSS_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_dhe_dss}, 403 {TLS_DHE_RSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_dhe_rsa}, 404 {TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, cipher_aes_256, hmac_sha256, kea_dhe_rsa}, 405 #if 0 406 {TLS_DH_DSS_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_dh_dss}, 407 {TLS_DH_RSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_dh_rsa}, 408 {TLS_DH_ANON_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_dh_anon}, 409 {TLS_DH_DSS_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_dh_dss}, 410 {TLS_DH_RSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_dh_rsa}, 411 {TLS_DH_ANON_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_dh_anon}, 412 #endif 413 414 {TLS_RSA_WITH_SEED_CBC_SHA, cipher_seed, mac_sha, kea_rsa}, 415 416 {TLS_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_camellia_128, mac_sha, kea_rsa}, 417 {TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, 418 cipher_camellia_128, mac_sha, kea_dhe_dss}, 419 {TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, 420 cipher_camellia_128, mac_sha, kea_dhe_rsa}, 421 {TLS_RSA_WITH_CAMELLIA_256_CBC_SHA, cipher_camellia_256, mac_sha, kea_rsa}, 422 {TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, 423 cipher_camellia_256, mac_sha, kea_dhe_dss}, 424 {TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, 425 cipher_camellia_256, mac_sha, kea_dhe_rsa}, 426 427 {TLS_RSA_EXPORT1024_WITH_DES_CBC_SHA, 428 cipher_des, mac_sha,kea_rsa_export_1024}, 429 {TLS_RSA_EXPORT1024_WITH_RC4_56_SHA, 430 cipher_rc4_56, mac_sha,kea_rsa_export_1024}, 431 432 {SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_rsa_fips}, 433 {SSL_RSA_FIPS_WITH_DES_CBC_SHA, cipher_des, mac_sha, kea_rsa_fips}, 434 435 {TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_dhe_rsa}, 436 {TLS_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_rsa}, 437 {TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_ecdhe_rsa}, 438 {TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, cipher_aes_128_gcm, mac_aead, kea_ecdhe_ecdsa}, 439 {TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305, cipher_chacha20, mac_aead, kea_ecdhe_rsa}, 440 {TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, cipher_chacha20, mac_aead, kea_ecdhe_ecdsa}, 441 442 #ifdef NSS_ENABLE_ECC 443 {TLS_ECDH_ECDSA_WITH_NULL_SHA, cipher_null, mac_sha, kea_ecdh_ecdsa}, 444 {TLS_ECDH_ECDSA_WITH_RC4_128_SHA, cipher_rc4, mac_sha, kea_ecdh_ecdsa}, 445 {TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdh_ecdsa}, 446 {TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdh_ecdsa}, 447 {TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdh_ecdsa}, 448 449 {TLS_ECDHE_ECDSA_WITH_NULL_SHA, cipher_null, mac_sha, kea_ecdhe_ecdsa}, 450 {TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, cipher_rc4, mac_sha, kea_ecdhe_ecdsa}, 451 {TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdhe_ecdsa}, 452 {TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdhe_ecdsa}, 453 {TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_ecdhe_ecdsa}, 454 {TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdhe_ecdsa}, 455 456 {TLS_ECDH_RSA_WITH_NULL_SHA, cipher_null, mac_sha, kea_ecdh_rsa}, 457 {TLS_ECDH_RSA_WITH_RC4_128_SHA, cipher_rc4, mac_sha, kea_ecdh_rsa}, 458 {TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdh_rsa}, 459 {TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdh_rsa}, 460 {TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdh_rsa}, 461 462 {TLS_ECDHE_RSA_WITH_NULL_SHA, cipher_null, mac_sha, kea_ecdhe_rsa}, 463 {TLS_ECDHE_RSA_WITH_RC4_128_SHA, cipher_rc4, mac_sha, kea_ecdhe_rsa}, 464 {TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdhe_rsa}, 465 {TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdhe_rsa}, 466 {TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, cipher_aes_128, hmac_sha256, kea_ecdhe_rsa}, 467 {TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdhe_rsa}, 468 469 #if 0 470 {TLS_ECDH_anon_WITH_NULL_SHA, cipher_null, mac_sha, kea_ecdh_anon}, 471 {TLS_ECDH_anon_WITH_RC4_128_SHA, cipher_rc4, mac_sha, kea_ecdh_anon}, 472 {TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA, cipher_3des, mac_sha, kea_ecdh_anon}, 473 {TLS_ECDH_anon_WITH_AES_128_CBC_SHA, cipher_aes_128, mac_sha, kea_ecdh_anon}, 474 {TLS_ECDH_anon_WITH_AES_256_CBC_SHA, cipher_aes_256, mac_sha, kea_ecdh_anon}, 475 #endif 476 #endif /* NSS_ENABLE_ECC */ 477 }; 478 479 static const CK_MECHANISM_TYPE kea_alg_defs[] = { 480 0x80000000L, 481 CKM_RSA_PKCS, 482 CKM_DH_PKCS_DERIVE, 483 CKM_KEA_KEY_DERIVE, 484 CKM_ECDH1_DERIVE 485 }; 486 487 typedef struct SSLCipher2MechStr { 488 SSLCipherAlgorithm calg; 489 CK_MECHANISM_TYPE cmech; 490 } SSLCipher2Mech; 491 492 /* indexed by type SSLCipherAlgorithm */ 493 static const SSLCipher2Mech alg2Mech[] = { 494 /* calg, cmech */ 495 { calg_null , (CK_MECHANISM_TYPE)0x80000000L }, 496 { calg_rc4 , CKM_RC4 }, 497 { calg_rc2 , CKM_RC2_CBC }, 498 { calg_des , CKM_DES_CBC }, 499 { calg_3des , CKM_DES3_CBC }, 500 { calg_idea , CKM_IDEA_CBC }, 501 { calg_fortezza , CKM_SKIPJACK_CBC64 }, 502 { calg_aes , CKM_AES_CBC }, 503 { calg_camellia , CKM_CAMELLIA_CBC }, 504 { calg_seed , CKM_SEED_CBC }, 505 { calg_aes_gcm , CKM_AES_GCM }, 506 { calg_chacha20 , CKM_NSS_CHACHA20_POLY1305 }, 507 /* { calg_init , (CK_MECHANISM_TYPE)0x7fffffffL } */ 508 }; 509 510 #define mmech_invalid (CK_MECHANISM_TYPE)0x80000000L 511 #define mmech_md5 CKM_SSL3_MD5_MAC 512 #define mmech_sha CKM_SSL3_SHA1_MAC 513 #define mmech_md5_hmac CKM_MD5_HMAC 514 #define mmech_sha_hmac CKM_SHA_1_HMAC 515 #define mmech_sha256_hmac CKM_SHA256_HMAC 516 517 static const ssl3MACDef mac_defs[] = { /* indexed by SSL3MACAlgorithm */ 518 /* pad_size is only used for SSL 3.0 MAC. See RFC 6101 Sec. 5.2.3.1. */ 519 /* mac mmech pad_size mac_size */ 520 { mac_null, mmech_invalid, 0, 0 }, 521 { mac_md5, mmech_md5, 48, MD5_LENGTH }, 522 { mac_sha, mmech_sha, 40, SHA1_LENGTH}, 523 {hmac_md5, mmech_md5_hmac, 0, MD5_LENGTH }, 524 {hmac_sha, mmech_sha_hmac, 0, SHA1_LENGTH}, 525 {hmac_sha256, mmech_sha256_hmac, 0, SHA256_LENGTH}, 526 { mac_aead, mmech_invalid, 0, 0 }, 527 }; 528 529 /* indexed by SSL3BulkCipher */ 530 const char * const ssl3_cipherName[] = { 531 "NULL", 532 "RC4", 533 "RC4-40", 534 "RC4-56", 535 "RC2-CBC", 536 "RC2-CBC-40", 537 "DES-CBC", 538 "3DES-EDE-CBC", 539 "DES-CBC-40", 540 "IDEA-CBC", 541 "AES-128", 542 "AES-256", 543 "Camellia-128", 544 "Camellia-256", 545 "SEED-CBC", 546 "AES-128-GCM", 547 "missing" 548 }; 549 550 #ifdef NSS_ENABLE_ECC 551 /* The ECCWrappedKeyInfo structure defines how various pieces of 552 * information are laid out within wrappedSymmetricWrappingkey 553 * for ECDH key exchange. Since wrappedSymmetricWrappingkey is 554 * a 512-byte buffer (see sslimpl.h), the variable length field 555 * in ECCWrappedKeyInfo can be at most (512 - 8) = 504 bytes. 556 * 557 * XXX For now, NSS only supports named elliptic curves of size 571 bits 558 * or smaller. The public value will fit within 145 bytes and EC params 559 * will fit within 12 bytes. We'll need to revisit this when NSS 560 * supports arbitrary curves. 561 */ 562 #define MAX_EC_WRAPPED_KEY_BUFLEN 504 563 564 typedef struct ECCWrappedKeyInfoStr { 565 PRUint16 size; /* EC public key size in bits */ 566 PRUint16 encodedParamLen; /* length (in bytes) of DER encoded EC params */ 567 PRUint16 pubValueLen; /* length (in bytes) of EC public value */ 568 PRUint16 wrappedKeyLen; /* length (in bytes) of the wrapped key */ 569 PRUint8 var[MAX_EC_WRAPPED_KEY_BUFLEN]; /* this buffer contains the */ 570 /* EC public-key params, the EC public value and the wrapped key */ 571 } ECCWrappedKeyInfo; 572 #endif /* NSS_ENABLE_ECC */ 573 574 #if defined(TRACE) 575 576 static char * 577 ssl3_DecodeHandshakeType(int msgType) 578 { 579 char * rv; 580 static char line[40]; 581 582 switch(msgType) { 583 case hello_request: rv = "hello_request (0)"; break; 584 case client_hello: rv = "client_hello (1)"; break; 585 case server_hello: rv = "server_hello (2)"; break; 586 case hello_verify_request: rv = "hello_verify_request (3)"; break; 587 case certificate: rv = "certificate (11)"; break; 588 case server_key_exchange: rv = "server_key_exchange (12)"; break; 589 case certificate_request: rv = "certificate_request (13)"; break; 590 case server_hello_done: rv = "server_hello_done (14)"; break; 591 case certificate_verify: rv = "certificate_verify (15)"; break; 592 case client_key_exchange: rv = "client_key_exchange (16)"; break; 593 case finished: rv = "finished (20)"; break; 594 default: 595 sprintf(line, "*UNKNOWN* handshake type! (%d)", msgType); 596 rv = line; 597 } 598 return rv; 599 } 600 601 static char * 602 ssl3_DecodeContentType(int msgType) 603 { 604 char * rv; 605 static char line[40]; 606 607 switch(msgType) { 608 case content_change_cipher_spec: 609 rv = "change_cipher_spec (20)"; break; 610 case content_alert: rv = "alert (21)"; break; 611 case content_handshake: rv = "handshake (22)"; break; 612 case content_application_data: 613 rv = "application_data (23)"; break; 614 default: 615 sprintf(line, "*UNKNOWN* record type! (%d)", msgType); 616 rv = line; 617 } 618 return rv; 619 } 620 621 #endif 622 623 SSL3Statistics * 624 SSL_GetStatistics(void) 625 { 626 return &ssl3stats; 627 } 628 629 typedef struct tooLongStr { 630 #if defined(IS_LITTLE_ENDIAN) 631 PRInt32 low; 632 PRInt32 high; 633 #else 634 PRInt32 high; 635 PRInt32 low; 636 #endif 637 } tooLong; 638 639 void SSL_AtomicIncrementLong(long * x) 640 { 641 if ((sizeof *x) == sizeof(PRInt32)) { 642 PR_ATOMIC_INCREMENT((PRInt32 *)x); 643 } else { 644 tooLong * tl = (tooLong *)x; 645 if (PR_ATOMIC_INCREMENT(&tl->low) == 0) 646 PR_ATOMIC_INCREMENT(&tl->high); 647 } 648 } 649 650 static PRBool 651 ssl3_CipherSuiteAllowedForVersionRange( 652 ssl3CipherSuite cipherSuite, 653 const SSLVersionRange *vrange) 654 { 655 switch (cipherSuite) { 656 /* See RFC 4346 A.5. Export cipher suites must not be used in TLS 1.1 or 657 * later. This set of cipher suites is similar to, but different from, the 658 * set of cipher suites considered exportable by SSL_IsExportCipherSuite. 659 */ 660 case SSL_RSA_EXPORT_WITH_RC4_40_MD5: 661 case SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5: 662 /* SSL_RSA_EXPORT_WITH_DES40_CBC_SHA: never implemented 663 * SSL_DH_DSS_EXPORT_WITH_DES40_CBC_SHA: never implemented 664 * SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA: never implemented 665 * SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA: never implemented 666 * SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA: never implemented 667 * SSL_DH_ANON_EXPORT_WITH_RC4_40_MD5: never implemented 668 * SSL_DH_ANON_EXPORT_WITH_DES40_CBC_SHA: never implemented 669 */ 670 return vrange->min <= SSL_LIBRARY_VERSION_TLS_1_0; 671 case TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305: 672 case TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305: 673 case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256: 674 case TLS_RSA_WITH_AES_256_CBC_SHA256: 675 case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256: 676 case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: 677 case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256: 678 case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256: 679 case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256: 680 case TLS_DHE_RSA_WITH_AES_128_GCM_SHA256: 681 case TLS_RSA_WITH_AES_128_CBC_SHA256: 682 case TLS_RSA_WITH_AES_128_GCM_SHA256: 683 case TLS_RSA_WITH_NULL_SHA256: 684 return vrange->max >= SSL_LIBRARY_VERSION_TLS_1_2; 685 default: 686 return PR_TRUE; 687 } 688 } 689 690 /* return pointer to ssl3CipherSuiteDef for suite, or NULL */ 691 /* XXX This does a linear search. A binary search would be better. */ 692 static const ssl3CipherSuiteDef * 693 ssl_LookupCipherSuiteDef(ssl3CipherSuite suite) 694 { 695 int cipher_suite_def_len = 696 sizeof(cipher_suite_defs) / sizeof(cipher_suite_defs[0]); 697 int i; 698 699 for (i = 0; i < cipher_suite_def_len; i++) { 700 if (cipher_suite_defs[i].cipher_suite == suite) 701 return &cipher_suite_defs[i]; 702 } 703 PORT_Assert(PR_FALSE); /* We should never get here. */ 704 PORT_SetError(SSL_ERROR_UNKNOWN_CIPHER_SUITE); 705 return NULL; 706 } 707 708 /* Find the cipher configuration struct associate with suite */ 709 /* XXX This does a linear search. A binary search would be better. */ 710 static ssl3CipherSuiteCfg * 711 ssl_LookupCipherSuiteCfg(ssl3CipherSuite suite, ssl3CipherSuiteCfg *suites) 712 { 713 int i; 714 715 for (i = 0; i < ssl_V3_SUITES_IMPLEMENTED; i++) { 716 if (suites[i].cipher_suite == suite) 717 return &suites[i]; 718 } 719 /* return NULL and let the caller handle it. */ 720 PORT_SetError(SSL_ERROR_UNKNOWN_CIPHER_SUITE); 721 return NULL; 722 } 723 724 725 /* Initialize the suite->isPresent value for config_match 726 * Returns count of enabled ciphers supported by extant tokens, 727 * regardless of policy or user preference. 728 * If this returns zero, the user cannot do SSL v3. 729 */ 730 int 731 ssl3_config_match_init(sslSocket *ss) 732 { 733 ssl3CipherSuiteCfg * suite; 734 const ssl3CipherSuiteDef *cipher_def; 735 SSLCipherAlgorithm cipher_alg; 736 CK_MECHANISM_TYPE cipher_mech; 737 SSL3KEAType exchKeyType; 738 int i; 739 int numPresent = 0; 740 int numEnabled = 0; 741 PRBool isServer; 742 sslServerCerts *svrAuth; 743 744 PORT_Assert(ss); 745 if (!ss) { 746 PORT_SetError(SEC_ERROR_INVALID_ARGS); 747 return 0; 748 } 749 if (SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) { 750 return 0; 751 } 752 isServer = (PRBool)(ss->sec.isServer != 0); 753 754 for (i = 0; i < ssl_V3_SUITES_IMPLEMENTED; i++) { 755 suite = &ss->cipherSuites[i]; 756 if (suite->enabled) { 757 ++numEnabled; 758 /* We need the cipher defs to see if we have a token that can handle 759 * this cipher. It isn't part of the static definition. 760 */ 761 cipher_def = ssl_LookupCipherSuiteDef(suite->cipher_suite); 762 if (!cipher_def) { 763 suite->isPresent = PR_FALSE; 764 continue; 765 } 766 cipher_alg = bulk_cipher_defs[cipher_def->bulk_cipher_alg].calg; 767 PORT_Assert( alg2Mech[cipher_alg].calg == cipher_alg); 768 cipher_mech = alg2Mech[cipher_alg].cmech; 769 exchKeyType = 770 kea_defs[cipher_def->key_exchange_alg].exchKeyType; 771 #ifndef NSS_ENABLE_ECC 772 svrAuth = ss->serverCerts + exchKeyType; 773 #else 774 /* XXX SSLKEAType isn't really a good choice for 775 * indexing certificates. It doesn't work for 776 * (EC)DHE-* ciphers. Here we use a hack to ensure 777 * that the server uses an RSA cert for (EC)DHE-RSA. 778 */ 779 switch (cipher_def->key_exchange_alg) { 780 case kea_ecdhe_rsa: 781 #if NSS_SERVER_DHE_IMPLEMENTED 782 /* XXX NSS does not yet implement the server side of _DHE_ 783 * cipher suites. Correcting the computation for svrAuth, 784 * as the case below does, causes NSS SSL servers to begin to 785 * negotiate cipher suites they do not implement. So, until 786 * server side _DHE_ is implemented, keep this disabled. 787 */ 788 case kea_dhe_rsa: 789 #endif 790 svrAuth = ss->serverCerts + kt_rsa; 791 break; 792 case kea_ecdh_ecdsa: 793 case kea_ecdh_rsa: 794 /* 795 * XXX We ought to have different indices for 796 * ECDSA- and RSA-signed EC certificates so 797 * we could support both key exchange mechanisms 798 * simultaneously. For now, both of them use 799 * whatever is in the certificate slot for kt_ecdh 800 */ 801 default: 802 svrAuth = ss->serverCerts + exchKeyType; 803 break; 804 } 805 #endif /* NSS_ENABLE_ECC */ 806 807 /* Mark the suites that are backed by real tokens, certs and keys */ 808 suite->isPresent = (PRBool) 809 (((exchKeyType == kt_null) || 810 ((!isServer || (svrAuth->serverKeyPair && 811 svrAuth->SERVERKEY && 812 svrAuth->serverCertChain)) && 813 PK11_TokenExists(kea_alg_defs[exchKeyType]))) && 814 ((cipher_alg == calg_null) || PK11_TokenExists(cipher_mech))); 815 if (suite->isPresent) 816 ++numPresent; 817 } 818 } 819 PORT_Assert(numPresent > 0 || numEnabled == 0); 820 if (numPresent <= 0) { 821 PORT_SetError(SSL_ERROR_NO_CIPHERS_SUPPORTED); 822 } 823 return numPresent; 824 } 825 826 827 /* return PR_TRUE if suite matches policy, enabled state and is applicable to 828 * the given version range. */ 829 /* It would be a REALLY BAD THING (tm) if we ever permitted the use 830 ** of a cipher that was NOT_ALLOWED. So, if this is ever called with 831 ** policy == SSL_NOT_ALLOWED, report no match. 832 */ 833 /* adjust suite enabled to the availability of a token that can do the 834 * cipher suite. */ 835 static PRBool 836 config_match(ssl3CipherSuiteCfg *suite, int policy, PRBool enabled, 837 const SSLVersionRange *vrange) 838 { 839 PORT_Assert(policy != SSL_NOT_ALLOWED && enabled != PR_FALSE); 840 if (policy == SSL_NOT_ALLOWED || !enabled) 841 return PR_FALSE; 842 return (PRBool)(suite->enabled && 843 suite->isPresent && 844 suite->policy != SSL_NOT_ALLOWED && 845 suite->policy <= policy && 846 ssl3_CipherSuiteAllowedForVersionRange( 847 suite->cipher_suite, vrange)); 848 } 849 850 /* return number of cipher suites that match policy, enabled state and are 851 * applicable for the configured protocol version range. */ 852 /* called from ssl3_SendClientHello and ssl3_ConstructV2CipherSpecsHack */ 853 static int 854 count_cipher_suites(sslSocket *ss, int policy, PRBool enabled) 855 { 856 int i, count = 0; 857 858 if (SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) { 859 return 0; 860 } 861 for (i = 0; i < ssl_V3_SUITES_IMPLEMENTED; i++) { 862 if (config_match(&ss->cipherSuites[i], policy, enabled, &ss->vrange)) 863 count++; 864 } 865 if (count <= 0) { 866 PORT_SetError(SSL_ERROR_SSL_DISABLED); 867 } 868 return count; 869 } 870 871 /* 872 * Null compression, mac and encryption functions 873 */ 874 875 static SECStatus 876 Null_Cipher(void *ctx, unsigned char *output, int *outputLen, int maxOutputLen, 877 const unsigned char *input, int inputLen) 878 { 879 if (inputLen > maxOutputLen) { 880 *outputLen = 0; /* Match PK11_CipherOp in setting outputLen */ 881 PORT_SetError(SEC_ERROR_OUTPUT_LEN); 882 return SECFailure; 883 } 884 *outputLen = inputLen; 885 if (input != output) 886 PORT_Memcpy(output, input, inputLen); 887 return SECSuccess; 888 } 889 890 /* 891 * SSL3 Utility functions 892 */ 893 894 /* allowLargerPeerVersion controls whether the function will select the 895 * highest enabled SSL version or fail when peerVersion is greater than the 896 * highest enabled version. 897 * 898 * If allowLargerPeerVersion is true, peerVersion is the peer's highest 899 * enabled version rather than the peer's selected version. 900 */ 901 SECStatus 902 ssl3_NegotiateVersion(sslSocket *ss, SSL3ProtocolVersion peerVersion, 903 PRBool allowLargerPeerVersion) 904 { 905 if (SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) { 906 PORT_SetError(SSL_ERROR_SSL_DISABLED); 907 return SECFailure; 908 } 909 910 if (peerVersion < ss->vrange.min || 911 (peerVersion > ss->vrange.max && !allowLargerPeerVersion)) { 912 PORT_SetError(SSL_ERROR_NO_CYPHER_OVERLAP); 913 return SECFailure; 914 } 915 916 ss->version = PR_MIN(peerVersion, ss->vrange.max); 917 PORT_Assert(ssl3_VersionIsSupported(ss->protocolVariant, ss->version)); 918 919 return SECSuccess; 920 } 921 922 static SECStatus 923 ssl3_GetNewRandom(SSL3Random *random) 924 { 925 SECStatus rv; 926 927 /* first 4 bytes are reserverd for time */ 928 rv = PK11_GenerateRandom(random->rand, SSL3_RANDOM_LENGTH); 929 if (rv != SECSuccess) { 930 ssl_MapLowLevelError(SSL_ERROR_GENERATE_RANDOM_FAILURE); 931 } 932 return rv; 933 } 934 935 /* Called by ssl3_SendServerKeyExchange and ssl3_SendCertificateVerify */ 936 SECStatus 937 ssl3_SignHashes(SSL3Hashes *hash, SECKEYPrivateKey *key, SECItem *buf, 938 PRBool isTLS) 939 { 940 SECStatus rv = SECFailure; 941 PRBool doDerEncode = PR_FALSE; 942 int signatureLen; 943 SECItem hashItem; 944 945 buf->data = NULL; 946 947 switch (key->keyType) { 948 case rsaKey: 949 hashItem.data = hash->u.raw; 950 hashItem.len = hash->len; 951 break; 952 case dsaKey: 953 doDerEncode = isTLS; 954 /* SEC_OID_UNKNOWN is used to specify the MD5/SHA1 concatenated hash. 955 * In that case, we use just the SHA1 part. */ 956 if (hash->hashAlg == SEC_OID_UNKNOWN) { 957 hashItem.data = hash->u.s.sha; 958 hashItem.len = sizeof(hash->u.s.sha); 959 } else { 960 hashItem.data = hash->u.raw; 961 hashItem.len = hash->len; 962 } 963 break; 964 #ifdef NSS_ENABLE_ECC 965 case ecKey: 966 doDerEncode = PR_TRUE; 967 /* SEC_OID_UNKNOWN is used to specify the MD5/SHA1 concatenated hash. 968 * In that case, we use just the SHA1 part. */ 969 if (hash->hashAlg == SEC_OID_UNKNOWN) { 970 hashItem.data = hash->u.s.sha; 971 hashItem.len = sizeof(hash->u.s.sha); 972 } else { 973 hashItem.data = hash->u.raw; 974 hashItem.len = hash->len; 975 } 976 break; 977 #endif /* NSS_ENABLE_ECC */ 978 default: 979 PORT_SetError(SEC_ERROR_INVALID_KEY); 980 goto done; 981 } 982 PRINT_BUF(60, (NULL, "hash(es) to be signed", hashItem.data, hashItem.len)); 983 984 if (hash->hashAlg == SEC_OID_UNKNOWN) { 985 signatureLen = PK11_SignatureLen(key); 986 if (signatureLen <= 0) { 987 PORT_SetError(SEC_ERROR_INVALID_KEY); 988 goto done; 989 } 990 991 buf->len = (unsigned)signatureLen; 992 buf->data = (unsigned char *)PORT_Alloc(signatureLen); 993 if (!buf->data) 994 goto done; /* error code was set. */ 995 996 rv = PK11_Sign(key, buf, &hashItem); 997 } else { 998 rv = SGN_Digest(key, hash->hashAlg, buf, &hashItem); 999 } 1000 if (rv != SECSuccess) { 1001 ssl_MapLowLevelError(SSL_ERROR_SIGN_HASHES_FAILURE); 1002 } else if (doDerEncode) { 1003 SECItem derSig = {siBuffer, NULL, 0}; 1004 1005 /* This also works for an ECDSA signature */ 1006 rv = DSAU_EncodeDerSigWithLen(&derSig, buf, buf->len); 1007 if (rv == SECSuccess) { 1008 PORT_Free(buf->data); /* discard unencoded signature. */ 1009 *buf = derSig; /* give caller encoded signature. */ 1010 } else if (derSig.data) { 1011 PORT_Free(derSig.data); 1012 } 1013 } 1014 1015 PRINT_BUF(60, (NULL, "signed hashes", (unsigned char*)buf->data, buf->len)); 1016 done: 1017 if (rv != SECSuccess && buf->data) { 1018 PORT_Free(buf->data); 1019 buf->data = NULL; 1020 } 1021 return rv; 1022 } 1023 1024 /* Called from ssl3_HandleServerKeyExchange, ssl3_HandleCertificateVerify */ 1025 SECStatus 1026 ssl3_VerifySignedHashes(SSL3Hashes *hash, CERTCertificate *cert, 1027 SECItem *buf, PRBool isTLS, void *pwArg) 1028 { 1029 SECKEYPublicKey * key; 1030 SECItem * signature = NULL; 1031 SECStatus rv; 1032 SECItem hashItem; 1033 SECOidTag encAlg; 1034 SECOidTag hashAlg; 1035 1036 1037 PRINT_BUF(60, (NULL, "check signed hashes", 1038 buf->data, buf->len)); 1039 1040 key = CERT_ExtractPublicKey(cert); 1041 if (key == NULL) { 1042 ssl_MapLowLevelError(SSL_ERROR_EXTRACT_PUBLIC_KEY_FAILURE); 1043 return SECFailure; 1044 } 1045 1046 hashAlg = hash->hashAlg; 1047 switch (key->keyType) { 1048 case rsaKey: 1049 encAlg = SEC_OID_PKCS1_RSA_ENCRYPTION; 1050 hashItem.data = hash->u.raw; 1051 hashItem.len = hash->len; 1052 break; 1053 case dsaKey: 1054 encAlg = SEC_OID_ANSIX9_DSA_SIGNATURE; 1055 /* SEC_OID_UNKNOWN is used to specify the MD5/SHA1 concatenated hash. 1056 * In that case, we use just the SHA1 part. */ 1057 if (hash->hashAlg == SEC_OID_UNKNOWN) { 1058 hashItem.data = hash->u.s.sha; 1059 hashItem.len = sizeof(hash->u.s.sha); 1060 } else { 1061 hashItem.data = hash->u.raw; 1062 hashItem.len = hash->len; 1063 } 1064 /* Allow DER encoded DSA signatures in SSL 3.0 */ 1065 if (isTLS || buf->len != SECKEY_SignatureLen(key)) { 1066 signature = DSAU_DecodeDerSigToLen(buf, SECKEY_SignatureLen(key)); 1067 if (!signature) { 1068 PORT_SetError(SSL_ERROR_BAD_HANDSHAKE_HASH_VALUE); 1069 return SECFailure; 1070 } 1071 buf = signature; 1072 } 1073 break; 1074 1075 #ifdef NSS_ENABLE_ECC 1076 case ecKey: 1077 encAlg = SEC_OID_ANSIX962_EC_PUBLIC_KEY; 1078 /* SEC_OID_UNKNOWN is used to specify the MD5/SHA1 concatenated hash. 1079 * In that case, we use just the SHA1 part. 1080 * ECDSA signatures always encode the integers r and s using ASN.1 1081 * (unlike DSA where ASN.1 encoding is used with TLS but not with 1082 * SSL3). So we can use VFY_VerifyDigestDirect for ECDSA. 1083 */ 1084 if (hash->hashAlg == SEC_OID_UNKNOWN) { 1085 hashAlg = SEC_OID_SHA1; 1086 hashItem.data = hash->u.s.sha; 1087 hashItem.len = sizeof(hash->u.s.sha); 1088 } else { 1089 hashItem.data = hash->u.raw; 1090 hashItem.len = hash->len; 1091 } 1092 break; 1093 #endif /* NSS_ENABLE_ECC */ 1094 1095 default: 1096 SECKEY_DestroyPublicKey(key); 1097 PORT_SetError(SEC_ERROR_UNSUPPORTED_KEYALG); 1098 return SECFailure; 1099 } 1100 1101 PRINT_BUF(60, (NULL, "hash(es) to be verified", 1102 hashItem.data, hashItem.len)); 1103 1104 if (hashAlg == SEC_OID_UNKNOWN || key->keyType == dsaKey) { 1105 /* VFY_VerifyDigestDirect requires DSA signatures to be DER-encoded. 1106 * DSA signatures are DER-encoded in TLS but not in SSL3 and the code 1107 * above always removes the DER encoding of DSA signatures when 1108 * present. Thus DSA signatures are always verified with PK11_Verify. 1109 */ 1110 rv = PK11_Verify(key, buf, &hashItem, pwArg); 1111 } else { 1112 rv = VFY_VerifyDigestDirect(&hashItem, key, buf, encAlg, hashAlg, 1113 pwArg); 1114 } 1115 SECKEY_DestroyPublicKey(key); 1116 if (signature) { 1117 SECITEM_FreeItem(signature, PR_TRUE); 1118 } 1119 if (rv != SECSuccess) { 1120 ssl_MapLowLevelError(SSL_ERROR_BAD_HANDSHAKE_HASH_VALUE); 1121 } 1122 return rv; 1123 } 1124 1125 1126 /* Caller must set hiLevel error code. */ 1127 /* Called from ssl3_ComputeExportRSAKeyHash 1128 * ssl3_ComputeDHKeyHash 1129 * which are called from ssl3_HandleServerKeyExchange. 1130 * 1131 * hashAlg: either the OID for a hash algorithm or SEC_OID_UNKNOWN to specify 1132 * the pre-1.2, MD5/SHA1 combination hash. 1133 */ 1134 SECStatus 1135 ssl3_ComputeCommonKeyHash(SECOidTag hashAlg, 1136 PRUint8 * hashBuf, unsigned int bufLen, 1137 SSL3Hashes *hashes, PRBool bypassPKCS11) 1138 { 1139 SECStatus rv = SECSuccess; 1140 1141 #ifndef NO_PKCS11_BYPASS 1142 if (bypassPKCS11) { 1143 if (hashAlg == SEC_OID_UNKNOWN) { 1144 MD5_HashBuf (hashes->u.s.md5, hashBuf, bufLen); 1145 SHA1_HashBuf(hashes->u.s.sha, hashBuf, bufLen); 1146 hashes->len = MD5_LENGTH + SHA1_LENGTH; 1147 } else if (hashAlg == SEC_OID_SHA1) { 1148 SHA1_HashBuf(hashes->u.raw, hashBuf, bufLen); 1149 hashes->len = SHA1_LENGTH; 1150 } else if (hashAlg == SEC_OID_SHA256) { 1151 SHA256_HashBuf(hashes->u.raw, hashBuf, bufLen); 1152 hashes->len = SHA256_LENGTH; 1153 } else if (hashAlg == SEC_OID_SHA384) { 1154 SHA384_HashBuf(hashes->u.raw, hashBuf, bufLen); 1155 hashes->len = SHA384_LENGTH; 1156 } else if (hashAlg == SEC_OID_SHA512) { 1157 SHA512_HashBuf(hashes->u.raw, hashBuf, bufLen); 1158 hashes->len = SHA512_LENGTH; 1159 } else { 1160 PORT_SetError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM); 1161 return SECFailure; 1162 } 1163 } else 1164 #endif 1165 { 1166 if (hashAlg == SEC_OID_UNKNOWN) { 1167 rv = PK11_HashBuf(SEC_OID_MD5, hashes->u.s.md5, hashBuf, bufLen); 1168 if (rv != SECSuccess) { 1169 ssl_MapLowLevelError(SSL_ERROR_MD5_DIGEST_FAILURE); 1170 rv = SECFailure; 1171 goto done; 1172 } 1173 1174 rv = PK11_HashBuf(SEC_OID_SHA1, hashes->u.s.sha, hashBuf, bufLen); 1175 if (rv != SECSuccess) { 1176 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 1177 rv = SECFailure; 1178 } 1179 hashes->len = MD5_LENGTH + SHA1_LENGTH; 1180 } else { 1181 hashes->len = HASH_ResultLenByOidTag(hashAlg); 1182 if (hashes->len > sizeof(hashes->u.raw)) { 1183 ssl_MapLowLevelError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM); 1184 rv = SECFailure; 1185 goto done; 1186 } 1187 rv = PK11_HashBuf(hashAlg, hashes->u.raw, hashBuf, bufLen); 1188 if (rv != SECSuccess) { 1189 ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE); 1190 rv = SECFailure; 1191 } 1192 } 1193 } 1194 hashes->hashAlg = hashAlg; 1195 1196 done: 1197 return rv; 1198 } 1199 1200 /* Caller must set hiLevel error code. 1201 ** Called from ssl3_SendServerKeyExchange and 1202 ** ssl3_HandleServerKeyExchange. 1203 */ 1204 static SECStatus 1205 ssl3_ComputeExportRSAKeyHash(SECOidTag hashAlg, 1206 SECItem modulus, SECItem publicExponent, 1207 SSL3Random *client_rand, SSL3Random *server_rand, 1208 SSL3Hashes *hashes, PRBool bypassPKCS11) 1209 { 1210 PRUint8 * hashBuf; 1211 PRUint8 * pBuf; 1212 SECStatus rv = SECSuccess; 1213 unsigned int bufLen; 1214 PRUint8 buf[2*SSL3_RANDOM_LENGTH + 2 + 4096/8 + 2 + 4096/8]; 1215 1216 bufLen = 2*SSL3_RANDOM_LENGTH + 2 + modulus.len + 2 + publicExponent.len; 1217 if (bufLen <= sizeof buf) { 1218 hashBuf = buf; 1219 } else { 1220 hashBuf = PORT_Alloc(bufLen); 1221 if (!hashBuf) { 1222 return SECFailure; 1223 } 1224 } 1225 1226 memcpy(hashBuf, client_rand, SSL3_RANDOM_LENGTH); 1227 pBuf = hashBuf + SSL3_RANDOM_LENGTH; 1228 memcpy(pBuf, server_rand, SSL3_RANDOM_LENGTH); 1229 pBuf += SSL3_RANDOM_LENGTH; 1230 pBuf[0] = (PRUint8)(modulus.len >> 8); 1231 pBuf[1] = (PRUint8)(modulus.len); 1232 pBuf += 2; 1233 memcpy(pBuf, modulus.data, modulus.len); 1234 pBuf += modulus.len; 1235 pBuf[0] = (PRUint8)(publicExponent.len >> 8); 1236 pBuf[1] = (PRUint8)(publicExponent.len); 1237 pBuf += 2; 1238 memcpy(pBuf, publicExponent.data, publicExponent.len); 1239 pBuf += publicExponent.len; 1240 PORT_Assert((unsigned int)(pBuf - hashBuf) == bufLen); 1241 1242 rv = ssl3_ComputeCommonKeyHash(hashAlg, hashBuf, bufLen, hashes, 1243 bypassPKCS11); 1244 1245 PRINT_BUF(95, (NULL, "RSAkey hash: ", hashBuf, bufLen)); 1246 if (hashAlg == SEC_OID_UNKNOWN) { 1247 PRINT_BUF(95, (NULL, "RSAkey hash: MD5 result", 1248 hashes->u.s.md5, MD5_LENGTH)); 1249 PRINT_BUF(95, (NULL, "RSAkey hash: SHA1 result", 1250 hashes->u.s.sha, SHA1_LENGTH)); 1251 } else { 1252 PRINT_BUF(95, (NULL, "RSAkey hash: result", 1253 hashes->u.raw, hashes->len)); 1254 } 1255 1256 if (hashBuf != buf && hashBuf != NULL) 1257 PORT_Free(hashBuf); 1258 return rv; 1259 } 1260 1261 /* Caller must set hiLevel error code. */ 1262 /* Called from ssl3_HandleServerKeyExchange. */ 1263 static SECStatus 1264 ssl3_ComputeDHKeyHash(SECOidTag hashAlg, 1265 SECItem dh_p, SECItem dh_g, SECItem dh_Ys, 1266 SSL3Random *client_rand, SSL3Random *server_rand, 1267 SSL3Hashes *hashes, PRBool bypassPKCS11) 1268 { 1269 PRUint8 * hashBuf; 1270 PRUint8 * pBuf; 1271 SECStatus rv = SECSuccess; 1272 unsigned int bufLen; 1273 PRUint8 buf[2*SSL3_RANDOM_LENGTH + 2 + 4096/8 + 2 + 4096/8]; 1274 1275 bufLen = 2*SSL3_RANDOM_LENGTH + 2 + dh_p.len + 2 + dh_g.len + 2 + dh_Ys.len; 1276 if (bufLen <= sizeof buf) { 1277 hashBuf = buf; 1278 } else { 1279 hashBuf = PORT_Alloc(bufLen); 1280 if (!hashBuf) { 1281 return SECFailure; 1282 } 1283 } 1284 1285 memcpy(hashBuf, client_rand, SSL3_RANDOM_LENGTH); 1286 pBuf = hashBuf + SSL3_RANDOM_LENGTH; 1287 memcpy(pBuf, server_rand, SSL3_RANDOM_LENGTH); 1288 pBuf += SSL3_RANDOM_LENGTH; 1289 pBuf[0] = (PRUint8)(dh_p.len >> 8); 1290 pBuf[1] = (PRUint8)(dh_p.len); 1291 pBuf += 2; 1292 memcpy(pBuf, dh_p.data, dh_p.len); 1293 pBuf += dh_p.len; 1294 pBuf[0] = (PRUint8)(dh_g.len >> 8); 1295 pBuf[1] = (PRUint8)(dh_g.len); 1296 pBuf += 2; 1297 memcpy(pBuf, dh_g.data, dh_g.len); 1298 pBuf += dh_g.len; 1299 pBuf[0] = (PRUint8)(dh_Ys.len >> 8); 1300 pBuf[1] = (PRUint8)(dh_Ys.len); 1301 pBuf += 2; 1302 memcpy(pBuf, dh_Ys.data, dh_Ys.len); 1303 pBuf += dh_Ys.len; 1304 PORT_Assert((unsigned int)(pBuf - hashBuf) == bufLen); 1305 1306 rv = ssl3_ComputeCommonKeyHash(hashAlg, hashBuf, bufLen, hashes, 1307 bypassPKCS11); 1308 1309 PRINT_BUF(95, (NULL, "DHkey hash: ", hashBuf, bufLen)); 1310 if (hashAlg == SEC_OID_UNKNOWN) { 1311 PRINT_BUF(95, (NULL, "DHkey hash: MD5 result", 1312 hashes->u.s.md5, MD5_LENGTH)); 1313 PRINT_BUF(95, (NULL, "DHkey hash: SHA1 result", 1314 hashes->u.s.sha, SHA1_LENGTH)); 1315 } else { 1316 PRINT_BUF(95, (NULL, "DHkey hash: result", 1317 hashes->u.raw, hashes->len)); 1318 } 1319 1320 if (hashBuf != buf && hashBuf != NULL) 1321 PORT_Free(hashBuf); 1322 return rv; 1323 } 1324 1325 static void 1326 ssl3_BumpSequenceNumber(SSL3SequenceNumber *num) 1327 { 1328 num->low++; 1329 if (num->low == 0) 1330 num->high++; 1331 } 1332 1333 /* Called twice, only from ssl3_DestroyCipherSpec (immediately below). */ 1334 static void 1335 ssl3_CleanupKeyMaterial(ssl3KeyMaterial *mat) 1336 { 1337 if (mat->write_key != NULL) { 1338 PK11_FreeSymKey(mat->write_key); 1339 mat->write_key = NULL; 1340 } 1341 if (mat->write_mac_key != NULL) { 1342 PK11_FreeSymKey(mat->write_mac_key); 1343 mat->write_mac_key = NULL; 1344 } 1345 if (mat->write_mac_context != NULL) { 1346 PK11_DestroyContext(mat->write_mac_context, PR_TRUE); 1347 mat->write_mac_context = NULL; 1348 } 1349 } 1350 1351 /* Called from ssl3_SendChangeCipherSpecs() and 1352 ** ssl3_HandleChangeCipherSpecs() 1353 ** ssl3_DestroySSL3Info 1354 ** Caller must hold SpecWriteLock. 1355 */ 1356 void 1357 ssl3_DestroyCipherSpec(ssl3CipherSpec *spec, PRBool freeSrvName) 1358 { 1359 PRBool freeit = (PRBool)(!spec->bypassCiphers); 1360 /* PORT_Assert( ss->opt.noLocks || ssl_HaveSpecWriteLock(ss)); Don't have ss! */ 1361 if (spec->destroy) { 1362 spec->destroy(spec->encodeContext, freeit); 1363 spec->destroy(spec->decodeContext, freeit); 1364 spec->encodeContext = NULL; /* paranoia */ 1365 spec->decodeContext = NULL; 1366 } 1367 if (spec->destroyCompressContext && spec->compressContext) { 1368 spec->destroyCompressContext(spec->compressContext, 1); 1369 spec->compressContext = NULL; 1370 } 1371 if (spec->destroyDecompressContext && spec->decompressContext) { 1372 spec->destroyDecompressContext(spec->decompressContext, 1); 1373 spec->decompressContext = NULL; 1374 } 1375 if (freeSrvName && spec->srvVirtName.data) { 1376 SECITEM_FreeItem(&spec->srvVirtName, PR_FALSE); 1377 } 1378 if (spec->master_secret != NULL) { 1379 PK11_FreeSymKey(spec->master_secret); 1380 spec->master_secret = NULL; 1381 } 1382 spec->msItem.data = NULL; 1383 spec->msItem.len = 0; 1384 ssl3_CleanupKeyMaterial(&spec->client); 1385 ssl3_CleanupKeyMaterial(&spec->server); 1386 spec->bypassCiphers = PR_FALSE; 1387 spec->destroy=NULL; 1388 spec->destroyCompressContext = NULL; 1389 spec->destroyDecompressContext = NULL; 1390 } 1391 1392 /* Fill in the pending cipher spec with info from the selected ciphersuite. 1393 ** This is as much initialization as we can do without having key material. 1394 ** Called from ssl3_HandleServerHello(), ssl3_SendServerHello() 1395 ** Caller must hold the ssl3 handshake lock. 1396 ** Acquires & releases SpecWriteLock. 1397 */ 1398 static SECStatus 1399 ssl3_SetupPendingCipherSpec(sslSocket *ss) 1400 { 1401 ssl3CipherSpec * pwSpec; 1402 ssl3CipherSpec * cwSpec; 1403 ssl3CipherSuite suite = ss->ssl3.hs.cipher_suite; 1404 SSL3MACAlgorithm mac; 1405 SSL3BulkCipher cipher; 1406 SSL3KeyExchangeAlgorithm kea; 1407 const ssl3CipherSuiteDef *suite_def; 1408 PRBool isTLS; 1409 1410 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 1411 1412 ssl_GetSpecWriteLock(ss); /*******************************/ 1413 1414 pwSpec = ss->ssl3.pwSpec; 1415 PORT_Assert(pwSpec == ss->ssl3.prSpec); 1416 1417 /* This hack provides maximal interoperability with SSL 3 servers. */ 1418 cwSpec = ss->ssl3.cwSpec; 1419 if (cwSpec->mac_def->mac == mac_null) { 1420 /* SSL records are not being MACed. */ 1421 cwSpec->version = ss->version; 1422 } 1423 1424 pwSpec->version = ss->version; 1425 isTLS = (PRBool)(pwSpec->version > SSL_LIBRARY_VERSION_3_0); 1426 1427 SSL_TRC(3, ("%d: SSL3[%d]: Set XXX Pending Cipher Suite to 0x%04x", 1428 SSL_GETPID(), ss->fd, suite)); 1429 1430 suite_def = ssl_LookupCipherSuiteDef(suite); 1431 if (suite_def == NULL) { 1432 ssl_ReleaseSpecWriteLock(ss); 1433 return SECFailure; /* error code set by ssl_LookupCipherSuiteDef */ 1434 } 1435 1436 if (IS_DTLS(ss)) { 1437 /* Double-check that we did not pick an RC4 suite */ 1438 PORT_Assert((suite_def->bulk_cipher_alg != cipher_rc4) && 1439 (suite_def->bulk_cipher_alg != cipher_rc4_40) && 1440 (suite_def->bulk_cipher_alg != cipher_rc4_56)); 1441 } 1442 1443 cipher = suite_def->bulk_cipher_alg; 1444 kea = suite_def->key_exchange_alg; 1445 mac = suite_def->mac_alg; 1446 if (mac <= ssl_mac_sha && mac != ssl_mac_null && isTLS) 1447 mac += 2; 1448 1449 ss->ssl3.hs.suite_def = suite_def; 1450 ss->ssl3.hs.kea_def = &kea_defs[kea]; 1451 PORT_Assert(ss->ssl3.hs.kea_def->kea == kea); 1452 1453 pwSpec->cipher_def = &bulk_cipher_defs[cipher]; 1454 PORT_Assert(pwSpec->cipher_def->cipher == cipher); 1455 1456 pwSpec->mac_def = &mac_defs[mac]; 1457 PORT_Assert(pwSpec->mac_def->mac == mac); 1458 1459 ss->sec.keyBits = pwSpec->cipher_def->key_size * BPB; 1460 ss->sec.secretKeyBits = pwSpec->cipher_def->secret_key_size * BPB; 1461 ss->sec.cipherType = cipher; 1462 1463 pwSpec->encodeContext = NULL; 1464 pwSpec->decodeContext = NULL; 1465 1466 pwSpec->mac_size = pwSpec->mac_def->mac_size; 1467 1468 pwSpec->compression_method = ss->ssl3.hs.compression; 1469 pwSpec->compressContext = NULL; 1470 pwSpec->decompressContext = NULL; 1471 1472 ssl_ReleaseSpecWriteLock(ss); /*******************************/ 1473 return SECSuccess; 1474 } 1475 1476 #ifdef NSS_ENABLE_ZLIB 1477 #define SSL3_DEFLATE_CONTEXT_SIZE sizeof(z_stream) 1478 1479 static SECStatus 1480 ssl3_MapZlibError(int zlib_error) 1481 { 1482 switch (zlib_error) { 1483 case Z_OK: 1484 return SECSuccess; 1485 default: 1486 return SECFailure; 1487 } 1488 } 1489 1490 static SECStatus 1491 ssl3_DeflateInit(void *void_context) 1492 { 1493 z_stream *context = void_context; 1494 context->zalloc = NULL; 1495 context->zfree = NULL; 1496 context->opaque = NULL; 1497 1498 return ssl3_MapZlibError(deflateInit(context, Z_DEFAULT_COMPRESSION)); 1499 } 1500 1501 static SECStatus 1502 ssl3_InflateInit(void *void_context) 1503 { 1504 z_stream *context = void_context; 1505 context->zalloc = NULL; 1506 context->zfree = NULL; 1507 context->opaque = NULL; 1508 context->next_in = NULL; 1509 context->avail_in = 0; 1510 1511 return ssl3_MapZlibError(inflateInit(context)); 1512 } 1513 1514 static SECStatus 1515 ssl3_DeflateCompress(void *void_context, unsigned char *out, int *out_len, 1516 int maxout, const unsigned char *in, int inlen) 1517 { 1518 z_stream *context = void_context; 1519 1520 if (!inlen) { 1521 *out_len = 0; 1522 return SECSuccess; 1523 } 1524 1525 context->next_in = (unsigned char*) in; 1526 context->avail_in = inlen; 1527 context->next_out = out; 1528 context->avail_out = maxout; 1529 if (deflate(context, Z_SYNC_FLUSH) != Z_OK) { 1530 return SECFailure; 1531 } 1532 if (context->avail_out == 0) { 1533 /* We ran out of space! */ 1534 SSL_TRC(3, ("%d: SSL3[%d] Ran out of buffer while compressing", 1535 SSL_GETPID())); 1536 return SECFailure; 1537 } 1538 1539 *out_len = maxout - context->avail_out; 1540 return SECSuccess; 1541 } 1542 1543 static SECStatus 1544 ssl3_DeflateDecompress(void *void_context, unsigned char *out, int *out_len, 1545 int maxout, const unsigned char *in, int inlen) 1546 { 1547 z_stream *context = void_context; 1548 1549 if (!inlen) { 1550 *out_len = 0; 1551 return SECSuccess; 1552 } 1553 1554 context->next_in = (unsigned char*) in; 1555 context->avail_in = inlen; 1556 context->next_out = out; 1557 context->avail_out = maxout; 1558 if (inflate(context, Z_SYNC_FLUSH) != Z_OK) { 1559 PORT_SetError(SSL_ERROR_DECOMPRESSION_FAILURE); 1560 return SECFailure; 1561 } 1562 1563 *out_len = maxout - context->avail_out; 1564 return SECSuccess; 1565 } 1566 1567 static SECStatus 1568 ssl3_DestroyCompressContext(void *void_context, PRBool unused) 1569 { 1570 deflateEnd(void_context); 1571 PORT_Free(void_context); 1572 return SECSuccess; 1573 } 1574 1575 static SECStatus 1576 ssl3_DestroyDecompressContext(void *void_context, PRBool unused) 1577 { 1578 inflateEnd(void_context); 1579 PORT_Free(void_context); 1580 return SECSuccess; 1581 } 1582 1583 #endif /* NSS_ENABLE_ZLIB */ 1584 1585 /* Initialize the compression functions and contexts for the given 1586 * CipherSpec. */ 1587 static SECStatus 1588 ssl3_InitCompressionContext(ssl3CipherSpec *pwSpec) 1589 { 1590 /* Setup the compression functions */ 1591 switch (pwSpec->compression_method) { 1592 case ssl_compression_null: 1593 pwSpec->compressor = NULL; 1594 pwSpec->decompressor = NULL; 1595 pwSpec->compressContext = NULL; 1596 pwSpec->decompressContext = NULL; 1597 pwSpec->destroyCompressContext = NULL; 1598 pwSpec->destroyDecompressContext = NULL; 1599 break; 1600 #ifdef NSS_ENABLE_ZLIB 1601 case ssl_compression_deflate: 1602 pwSpec->compressor = ssl3_DeflateCompress; 1603 pwSpec->decompressor = ssl3_DeflateDecompress; 1604 pwSpec->compressContext = PORT_Alloc(SSL3_DEFLATE_CONTEXT_SIZE); 1605 pwSpec->decompressContext = PORT_Alloc(SSL3_DEFLATE_CONTEXT_SIZE); 1606 pwSpec->destroyCompressContext = ssl3_DestroyCompressContext; 1607 pwSpec->destroyDecompressContext = ssl3_DestroyDecompressContext; 1608 ssl3_DeflateInit(pwSpec->compressContext); 1609 ssl3_InflateInit(pwSpec->decompressContext); 1610 break; 1611 #endif /* NSS_ENABLE_ZLIB */ 1612 default: 1613 PORT_Assert(0); 1614 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 1615 return SECFailure; 1616 } 1617 1618 return SECSuccess; 1619 } 1620 1621 #ifndef NO_PKCS11_BYPASS 1622 /* Initialize encryption contexts for pending spec. 1623 * MAC contexts are set up when computing the mac, not here. 1624 * Master Secret already is derived in spec->msItem 1625 * Caller holds Spec write lock. 1626 */ 1627 static SECStatus 1628 ssl3_InitPendingContextsBypass(sslSocket *ss) 1629 { 1630 ssl3CipherSpec * pwSpec; 1631 const ssl3BulkCipherDef *cipher_def; 1632 void * serverContext = NULL; 1633 void * clientContext = NULL; 1634 BLapiInitContextFunc initFn = (BLapiInitContextFunc)NULL; 1635 int mode = 0; 1636 unsigned int optArg1 = 0; 1637 unsigned int optArg2 = 0; 1638 PRBool server_encrypts = ss->sec.isServer; 1639 SSLCipherAlgorithm calg; 1640 SECStatus rv; 1641 1642 PORT_Assert(ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 1643 PORT_Assert(ss->opt.noLocks || ssl_HaveSpecWriteLock(ss)); 1644 PORT_Assert(ss->ssl3.prSpec == ss->ssl3.pwSpec); 1645 1646 pwSpec = ss->ssl3.pwSpec; 1647 cipher_def = pwSpec->cipher_def; 1648 1649 calg = cipher_def->calg; 1650 1651 if (calg == ssl_calg_aes_gcm) { 1652 pwSpec->encode = NULL; 1653 pwSpec->decode = NULL; 1654 pwSpec->destroy = NULL; 1655 pwSpec->encodeContext = NULL; 1656 pwSpec->decodeContext = NULL; 1657 pwSpec->aead = ssl3_AESGCMBypass; 1658 ssl3_InitCompressionContext(pwSpec); 1659 return SECSuccess; 1660 } 1661 1662 serverContext = pwSpec->server.cipher_context; 1663 clientContext = pwSpec->client.cipher_context; 1664 1665 switch (calg) { 1666 case ssl_calg_null: 1667 pwSpec->encode = Null_Cipher; 1668 pwSpec->decode = Null_Cipher; 1669 pwSpec->destroy = NULL; 1670 goto success; 1671 1672 case ssl_calg_rc4: 1673 initFn = (BLapiInitContextFunc)RC4_InitContext; 1674 pwSpec->encode = (SSLCipher) RC4_Encrypt; 1675 pwSpec->decode = (SSLCipher) RC4_Decrypt; 1676 pwSpec->destroy = (SSLDestroy) RC4_DestroyContext; 1677 break; 1678 case ssl_calg_rc2: 1679 initFn = (BLapiInitContextFunc)RC2_InitContext; 1680 mode = NSS_RC2_CBC; 1681 optArg1 = cipher_def->key_size; 1682 pwSpec->encode = (SSLCipher) RC2_Encrypt; 1683 pwSpec->decode = (SSLCipher) RC2_Decrypt; 1684 pwSpec->destroy = (SSLDestroy) RC2_DestroyContext; 1685 break; 1686 case ssl_calg_des: 1687 initFn = (BLapiInitContextFunc)DES_InitContext; 1688 mode = NSS_DES_CBC; 1689 optArg1 = server_encrypts; 1690 pwSpec->encode = (SSLCipher) DES_Encrypt; 1691 pwSpec->decode = (SSLCipher) DES_Decrypt; 1692 pwSpec->destroy = (SSLDestroy) DES_DestroyContext; 1693 break; 1694 case ssl_calg_3des: 1695 initFn = (BLapiInitContextFunc)DES_InitContext; 1696 mode = NSS_DES_EDE3_CBC; 1697 optArg1 = server_encrypts; 1698 pwSpec->encode = (SSLCipher) DES_Encrypt; 1699 pwSpec->decode = (SSLCipher) DES_Decrypt; 1700 pwSpec->destroy = (SSLDestroy) DES_DestroyContext; 1701 break; 1702 case ssl_calg_aes: 1703 initFn = (BLapiInitContextFunc)AES_InitContext; 1704 mode = NSS_AES_CBC; 1705 optArg1 = server_encrypts; 1706 optArg2 = AES_BLOCK_SIZE; 1707 pwSpec->encode = (SSLCipher) AES_Encrypt; 1708 pwSpec->decode = (SSLCipher) AES_Decrypt; 1709 pwSpec->destroy = (SSLDestroy) AES_DestroyContext; 1710 break; 1711 1712 case ssl_calg_camellia: 1713 initFn = (BLapiInitContextFunc)Camellia_InitContext; 1714 mode = NSS_CAMELLIA_CBC; 1715 optArg1 = server_encrypts; 1716 optArg2 = CAMELLIA_BLOCK_SIZE; 1717 pwSpec->encode = (SSLCipher) Camellia_Encrypt; 1718 pwSpec->decode = (SSLCipher) Camellia_Decrypt; 1719 pwSpec->destroy = (SSLDestroy) Camellia_DestroyContext; 1720 break; 1721 1722 case ssl_calg_seed: 1723 initFn = (BLapiInitContextFunc)SEED_InitContext; 1724 mode = NSS_SEED_CBC; 1725 optArg1 = server_encrypts; 1726 optArg2 = SEED_BLOCK_SIZE; 1727 pwSpec->encode = (SSLCipher) SEED_Encrypt; 1728 pwSpec->decode = (SSLCipher) SEED_Decrypt; 1729 pwSpec->destroy = (SSLDestroy) SEED_DestroyContext; 1730 break; 1731 1732 case ssl_calg_idea: 1733 case ssl_calg_fortezza : 1734 default: 1735 PORT_Assert(0); 1736 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 1737 goto bail_out; 1738 } 1739 rv = (*initFn)(serverContext, 1740 pwSpec->server.write_key_item.data, 1741 pwSpec->server.write_key_item.len, 1742 pwSpec->server.write_iv_item.data, 1743 mode, optArg1, optArg2); 1744 if (rv != SECSuccess) { 1745 PORT_Assert(0); 1746 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 1747 goto bail_out; 1748 } 1749 1750 switch (calg) { 1751 case ssl_calg_des: 1752 case ssl_calg_3des: 1753 case ssl_calg_aes: 1754 case ssl_calg_camellia: 1755 case ssl_calg_seed: 1756 /* For block ciphers, if the server is encrypting, then the client 1757 * is decrypting, and vice versa. 1758 */ 1759 optArg1 = !optArg1; 1760 break; 1761 /* kill warnings. */ 1762 case ssl_calg_null: 1763 case ssl_calg_rc4: 1764 case ssl_calg_rc2: 1765 case ssl_calg_idea: 1766 case ssl_calg_fortezza: 1767 case ssl_calg_aes_gcm: 1768 break; 1769 } 1770 1771 rv = (*initFn)(clientContext, 1772 pwSpec->client.write_key_item.data, 1773 pwSpec->client.write_key_item.len, 1774 pwSpec->client.write_iv_item.data, 1775 mode, optArg1, optArg2); 1776 if (rv != SECSuccess) { 1777 PORT_Assert(0); 1778 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 1779 goto bail_out; 1780 } 1781 1782 pwSpec->encodeContext = (ss->sec.isServer) ? serverContext : clientContext; 1783 pwSpec->decodeContext = (ss->sec.isServer) ? clientContext : serverContext; 1784 1785 ssl3_InitCompressionContext(pwSpec); 1786 1787 success: 1788 return SECSuccess; 1789 1790 bail_out: 1791 return SECFailure; 1792 } 1793 #endif 1794 1795 /* This function should probably be moved to pk11wrap and be named 1796 * PK11_ParamFromIVAndEffectiveKeyBits 1797 */ 1798 static SECItem * 1799 ssl3_ParamFromIV(CK_MECHANISM_TYPE mtype, SECItem *iv, CK_ULONG ulEffectiveBits) 1800 { 1801 SECItem * param = PK11_ParamFromIV(mtype, iv); 1802 if (param && param->data && param->len >= sizeof(CK_RC2_PARAMS)) { 1803 switch (mtype) { 1804 case CKM_RC2_KEY_GEN: 1805 case CKM_RC2_ECB: 1806 case CKM_RC2_CBC: 1807 case CKM_RC2_MAC: 1808 case CKM_RC2_MAC_GENERAL: 1809 case CKM_RC2_CBC_PAD: 1810 *(CK_RC2_PARAMS *)param->data = ulEffectiveBits; 1811 default: break; 1812 } 1813 } 1814 return param; 1815 } 1816 1817 /* ssl3_BuildRecordPseudoHeader writes the SSL/TLS pseudo-header (the data 1818 * which is included in the MAC or AEAD additional data) to |out| and returns 1819 * its length. See https://tools.ietf.org/html/rfc5246#section-6.2.3.3 for the 1820 * definition of the AEAD additional data. 1821 * 1822 * TLS pseudo-header includes the record's version field, SSL's doesn't. Which 1823 * pseudo-header defintiion to use should be decided based on the version of 1824 * the protocol that was negotiated when the cipher spec became current, NOT 1825 * based on the version value in the record itself, and the decision is passed 1826 * to this function as the |includesVersion| argument. But, the |version| 1827 * argument should be the record's version value. 1828 */ 1829 static unsigned int 1830 ssl3_BuildRecordPseudoHeader(unsigned char *out, 1831 SSL3SequenceNumber seq_num, 1832 SSL3ContentType type, 1833 PRBool includesVersion, 1834 SSL3ProtocolVersion version, 1835 PRBool isDTLS, 1836 int length) 1837 { 1838 out[0] = (unsigned char)(seq_num.high >> 24); 1839 out[1] = (unsigned char)(seq_num.high >> 16); 1840 out[2] = (unsigned char)(seq_num.high >> 8); 1841 out[3] = (unsigned char)(seq_num.high >> 0); 1842 out[4] = (unsigned char)(seq_num.low >> 24); 1843 out[5] = (unsigned char)(seq_num.low >> 16); 1844 out[6] = (unsigned char)(seq_num.low >> 8); 1845 out[7] = (unsigned char)(seq_num.low >> 0); 1846 out[8] = type; 1847 1848 /* SSL3 MAC doesn't include the record's version field. */ 1849 if (!includesVersion) { 1850 out[9] = MSB(length); 1851 out[10] = LSB(length); 1852 return 11; 1853 } 1854 1855 /* TLS MAC and AEAD additional data include version. */ 1856 if (isDTLS) { 1857 SSL3ProtocolVersion dtls_version; 1858 1859 dtls_version = dtls_TLSVersionToDTLSVersion(version); 1860 out[9] = MSB(dtls_version); 1861 out[10] = LSB(dtls_version); 1862 } else { 1863 out[9] = MSB(version); 1864 out[10] = LSB(version); 1865 } 1866 out[11] = MSB(length); 1867 out[12] = LSB(length); 1868 return 13; 1869 } 1870 1871 typedef SECStatus (*PK11CryptFcn)( 1872 PK11SymKey *symKey, CK_MECHANISM_TYPE mechanism, SECItem *param, 1873 unsigned char *out, unsigned int *outLen, unsigned int maxLen, 1874 const unsigned char *in, unsigned int inLen); 1875 1876 static PK11CryptFcn pk11_encrypt = NULL; 1877 static PK11CryptFcn pk11_decrypt = NULL; 1878 1879 static PRCallOnceType resolvePK11CryptOnce; 1880 1881 static PRStatus 1882 ssl3_ResolvePK11CryptFunctions(void) 1883 { 1884 #ifdef LINUX 1885 /* On Linux we use the system NSS libraries. Look up the PK11_Encrypt and 1886 * PK11_Decrypt functions at run time. */ 1887 void *handle = dlopen(NULL, RTLD_LAZY); 1888 if (!handle) { 1889 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 1890 return PR_FAILURE; 1891 } 1892 pk11_encrypt = (PK11CryptFcn)dlsym(handle, "PK11_Encrypt"); 1893 pk11_decrypt = (PK11CryptFcn)dlsym(handle, "PK11_Decrypt"); 1894 dlclose(handle); 1895 return PR_SUCCESS; 1896 #else 1897 /* On other platforms we use our own copy of NSS. PK11_Encrypt and 1898 * PK11_Decrypt are known to be available. */ 1899 pk11_encrypt = PK11_Encrypt; 1900 pk11_decrypt = PK11_Decrypt; 1901 return PR_SUCCESS; 1902 #endif 1903 } 1904 1905 /* 1906 * In NSS 3.15, PK11_Encrypt and PK11_Decrypt were added to provide access 1907 * to the AES GCM implementation in the NSS softoken. So the presence of 1908 * these two functions implies the NSS version supports AES GCM. 1909 */ 1910 static PRBool 1911 ssl3_HasGCMSupport(void) 1912 { 1913 (void)PR_CallOnce(&resolvePK11CryptOnce, ssl3_ResolvePK11CryptFunctions); 1914 return pk11_encrypt != NULL; 1915 } 1916 1917 /* On this socket, disable the GCM cipher suites */ 1918 SECStatus 1919 ssl3_DisableGCMSuites(sslSocket * ss) 1920 { 1921 unsigned int i; 1922 1923 for (i = 0; i < PR_ARRAY_SIZE(cipher_suite_defs); i++) { 1924 const ssl3CipherSuiteDef *cipher_def = &cipher_suite_defs[i]; 1925 if (cipher_def->bulk_cipher_alg == cipher_aes_128_gcm) { 1926 SECStatus rv = ssl3_CipherPrefSet(ss, cipher_def->cipher_suite, 1927 PR_FALSE); 1928 PORT_Assert(rv == SECSuccess); /* else is coding error */ 1929 } 1930 } 1931 return SECSuccess; 1932 } 1933 1934 static SECStatus 1935 ssl3_AESGCM(ssl3KeyMaterial *keys, 1936 PRBool doDecrypt, 1937 unsigned char *out, 1938 int *outlen, 1939 int maxout, 1940 const unsigned char *in, 1941 int inlen, 1942 const unsigned char *additionalData, 1943 int additionalDataLen) 1944 { 1945 SECItem param; 1946 SECStatus rv = SECFailure; 1947 unsigned char nonce[12]; 1948 unsigned int uOutLen; 1949 CK_GCM_PARAMS gcmParams; 1950 1951 static const int tagSize = 16; 1952 static const int explicitNonceLen = 8; 1953 1954 /* See https://tools.ietf.org/html/rfc5288#section-3 for details of how the 1955 * nonce is formed. */ 1956 memcpy(nonce, keys->write_iv, 4); 1957 if (doDecrypt) { 1958 memcpy(nonce + 4, in, explicitNonceLen); 1959 in += explicitNonceLen; 1960 inlen -= explicitNonceLen; 1961 *outlen = 0; 1962 } else { 1963 if (maxout < explicitNonceLen) { 1964 PORT_SetError(SEC_ERROR_INPUT_LEN); 1965 return SECFailure; 1966 } 1967 /* Use the 64-bit sequence number as the explicit nonce. */ 1968 memcpy(nonce + 4, additionalData, explicitNonceLen); 1969 memcpy(out, additionalData, explicitNonceLen); 1970 out += explicitNonceLen; 1971 maxout -= explicitNonceLen; 1972 *outlen = explicitNonceLen; 1973 } 1974 1975 param.type = siBuffer; 1976 param.data = (unsigned char *) &gcmParams; 1977 param.len = sizeof(gcmParams); 1978 gcmParams.pIv = nonce; 1979 gcmParams.ulIvLen = sizeof(nonce); 1980 gcmParams.pAAD = (unsigned char *)additionalData; /* const cast */ 1981 gcmParams.ulAADLen = additionalDataLen; 1982 gcmParams.ulTagBits = tagSize * 8; 1983 1984 if (doDecrypt) { 1985 rv = pk11_decrypt(keys->write_key, CKM_AES_GCM, ¶m, out, &uOutLen, 1986 maxout, in, inlen); 1987 } else { 1988 rv = pk11_encrypt(keys->write_key, CKM_AES_GCM, ¶m, out, &uOutLen, 1989 maxout, in, inlen); 1990 } 1991 *outlen += (int) uOutLen; 1992 1993 return rv; 1994 } 1995 1996 #ifndef NO_PKCS11_BYPASS 1997 static SECStatus 1998 ssl3_AESGCMBypass(ssl3KeyMaterial *keys, 1999 PRBool doDecrypt, 2000 unsigned char *out, 2001 int *outlen, 2002 int maxout, 2003 const unsigned char *in, 2004 int inlen, 2005 const unsigned char *additionalData, 2006 int additionalDataLen) 2007 { 2008 SECStatus rv = SECFailure; 2009 unsigned char nonce[12]; 2010 unsigned int uOutLen; 2011 AESContext *cx; 2012 CK_GCM_PARAMS gcmParams; 2013 2014 static const int tagSize = 16; 2015 static const int explicitNonceLen = 8; 2016 2017 /* See https://tools.ietf.org/html/rfc5288#section-3 for details of how the 2018 * nonce is formed. */ 2019 PORT_Assert(keys->write_iv_item.len == 4); 2020 if (keys->write_iv_item.len != 4) { 2021 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 2022 return SECFailure; 2023 } 2024 memcpy(nonce, keys->write_iv_item.data, 4); 2025 if (doDecrypt) { 2026 memcpy(nonce + 4, in, explicitNonceLen); 2027 in += explicitNonceLen; 2028 inlen -= explicitNonceLen; 2029 *outlen = 0; 2030 } else { 2031 if (maxout < explicitNonceLen) { 2032 PORT_SetError(SEC_ERROR_INPUT_LEN); 2033 return SECFailure; 2034 } 2035 /* Use the 64-bit sequence number as the explicit nonce. */ 2036 memcpy(nonce + 4, additionalData, explicitNonceLen); 2037 memcpy(out, additionalData, explicitNonceLen); 2038 out += explicitNonceLen; 2039 maxout -= explicitNonceLen; 2040 *outlen = explicitNonceLen; 2041 } 2042 2043 gcmParams.pIv = nonce; 2044 gcmParams.ulIvLen = sizeof(nonce); 2045 gcmParams.pAAD = (unsigned char *)additionalData; /* const cast */ 2046 gcmParams.ulAADLen = additionalDataLen; 2047 gcmParams.ulTagBits = tagSize * 8; 2048 2049 cx = (AESContext *)keys->cipher_context; 2050 rv = AES_InitContext(cx, keys->write_key_item.data, 2051 keys->write_key_item.len, 2052 (unsigned char *)&gcmParams, NSS_AES_GCM, !doDecrypt, 2053 AES_BLOCK_SIZE); 2054 if (rv != SECSuccess) { 2055 return rv; 2056 } 2057 if (doDecrypt) { 2058 rv = AES_Decrypt(cx, out, &uOutLen, maxout, in, inlen); 2059 } else { 2060 rv = AES_Encrypt(cx, out, &uOutLen, maxout, in, inlen); 2061 } 2062 AES_DestroyContext(cx, PR_FALSE); 2063 *outlen += (int) uOutLen; 2064 2065 return rv; 2066 } 2067 #endif 2068 2069 static SECStatus 2070 ssl3_ChaCha20Poly1305( 2071 ssl3KeyMaterial *keys, 2072 PRBool doDecrypt, 2073 unsigned char *out, 2074 int *outlen, 2075 int maxout, 2076 const unsigned char *in, 2077 int inlen, 2078 const unsigned char *additionalData, 2079 int additionalDataLen) 2080 { 2081 SECItem param; 2082 SECStatus rv = SECFailure; 2083 unsigned int uOutLen; 2084 CK_NSS_AEAD_PARAMS aeadParams; 2085 static const int tagSize = 16; 2086 2087 param.type = siBuffer; 2088 param.len = sizeof(aeadParams); 2089 param.data = (unsigned char *) &aeadParams; 2090 memset(&aeadParams, 0, sizeof(aeadParams)); 2091 aeadParams.pIv = (unsigned char *) additionalData; 2092 aeadParams.ulIvLen = 8; 2093 aeadParams.pAAD = (unsigned char *) additionalData; 2094 aeadParams.ulAADLen = additionalDataLen; 2095 aeadParams.ulTagLen = tagSize; 2096 2097 if (doDecrypt) { 2098 rv = pk11_decrypt(keys->write_key, CKM_NSS_CHACHA20_POLY1305, ¶m, 2099 out, &uOutLen, maxout, in, inlen); 2100 } else { 2101 rv = pk11_encrypt(keys->write_key, CKM_NSS_CHACHA20_POLY1305, ¶m, 2102 out, &uOutLen, maxout, in, inlen); 2103 } 2104 *outlen = (int) uOutLen; 2105 2106 return rv; 2107 } 2108 2109 /* Initialize encryption and MAC contexts for pending spec. 2110 * Master Secret already is derived. 2111 * Caller holds Spec write lock. 2112 */ 2113 static SECStatus 2114 ssl3_InitPendingContextsPKCS11(sslSocket *ss) 2115 { 2116 ssl3CipherSpec * pwSpec; 2117 const ssl3BulkCipherDef *cipher_def; 2118 PK11Context * serverContext = NULL; 2119 PK11Context * clientContext = NULL; 2120 SECItem * param; 2121 CK_MECHANISM_TYPE mechanism; 2122 CK_MECHANISM_TYPE mac_mech; 2123 CK_ULONG macLength; 2124 CK_ULONG effKeyBits; 2125 SECItem iv; 2126 SECItem mac_param; 2127 SSLCipherAlgorithm calg; 2128 2129 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 2130 PORT_Assert( ss->opt.noLocks || ssl_HaveSpecWriteLock(ss)); 2131 PORT_Assert(ss->ssl3.prSpec == ss->ssl3.pwSpec); 2132 2133 pwSpec = ss->ssl3.pwSpec; 2134 cipher_def = pwSpec->cipher_def; 2135 macLength = pwSpec->mac_size; 2136 calg = cipher_def->calg; 2137 PORT_Assert(alg2Mech[calg].calg == calg); 2138 2139 pwSpec->client.write_mac_context = NULL; 2140 pwSpec->server.write_mac_context = NULL; 2141 2142 if (calg == calg_aes_gcm || calg == calg_chacha20) { 2143 pwSpec->encode = NULL; 2144 pwSpec->decode = NULL; 2145 pwSpec->destroy = NULL; 2146 pwSpec->encodeContext = NULL; 2147 pwSpec->decodeContext = NULL; 2148 if (calg == calg_aes_gcm) { 2149 pwSpec->aead = ssl3_AESGCM; 2150 } else { 2151 pwSpec->aead = ssl3_ChaCha20Poly1305; 2152 } 2153 return SECSuccess; 2154 } 2155 2156 /* 2157 ** Now setup the MAC contexts, 2158 ** crypto contexts are setup below. 2159 */ 2160 2161 mac_mech = pwSpec->mac_def->mmech; 2162 mac_param.data = (unsigned char *)&macLength; 2163 mac_param.len = sizeof(macLength); 2164 mac_param.type = 0; 2165 2166 pwSpec->client.write_mac_context = PK11_CreateContextBySymKey( 2167 mac_mech, CKA_SIGN, pwSpec->client.write_mac_key, &mac_param); 2168 if (pwSpec->client.write_mac_context == NULL) { 2169 ssl_MapLowLevelError(SSL_ERROR_SYM_KEY_CONTEXT_FAILURE); 2170 goto fail; 2171 } 2172 pwSpec->server.write_mac_context = PK11_CreateContextBySymKey( 2173 mac_mech, CKA_SIGN, pwSpec->server.write_mac_key, &mac_param); 2174 if (pwSpec->server.write_mac_context == NULL) { 2175 ssl_MapLowLevelError(SSL_ERROR_SYM_KEY_CONTEXT_FAILURE); 2176 goto fail; 2177 } 2178 2179 /* 2180 ** Now setup the crypto contexts. 2181 */ 2182 2183 if (calg == calg_null) { 2184 pwSpec->encode = Null_Cipher; 2185 pwSpec->decode = Null_Cipher; 2186 pwSpec->destroy = NULL; 2187 return SECSuccess; 2188 } 2189 mechanism = alg2Mech[calg].cmech; 2190 effKeyBits = cipher_def->key_size * BPB; 2191 2192 /* 2193 * build the server context 2194 */ 2195 iv.data = pwSpec->server.write_iv; 2196 iv.len = cipher_def->iv_size; 2197 param = ssl3_ParamFromIV(mechanism, &iv, effKeyBits); 2198 if (param == NULL) { 2199 ssl_MapLowLevelError(SSL_ERROR_IV_PARAM_FAILURE); 2200 goto fail; 2201 } 2202 serverContext = PK11_CreateContextBySymKey(mechanism, 2203 (ss->sec.isServer ? CKA_ENCRYPT : CKA_DECRYPT), 2204 pwSpec->server.write_key, param); 2205 iv.data = PK11_IVFromParam(mechanism, param, (int *)&iv.len); 2206 if (iv.data) 2207 PORT_Memcpy(pwSpec->server.write_iv, iv.data, iv.len); 2208 SECITEM_FreeItem(param, PR_TRUE); 2209 if (serverContext == NULL) { 2210 ssl_MapLowLevelError(SSL_ERROR_SYM_KEY_CONTEXT_FAILURE); 2211 goto fail; 2212 } 2213 2214 /* 2215 * build the client context 2216 */ 2217 iv.data = pwSpec->client.write_iv; 2218 iv.len = cipher_def->iv_size; 2219 2220 param = ssl3_ParamFromIV(mechanism, &iv, effKeyBits); 2221 if (param == NULL) { 2222 ssl_MapLowLevelError(SSL_ERROR_IV_PARAM_FAILURE); 2223 goto fail; 2224 } 2225 clientContext = PK11_CreateContextBySymKey(mechanism, 2226 (ss->sec.isServer ? CKA_DECRYPT : CKA_ENCRYPT), 2227 pwSpec->client.write_key, param); 2228 iv.data = PK11_IVFromParam(mechanism, param, (int *)&iv.len); 2229 if (iv.data) 2230 PORT_Memcpy(pwSpec->client.write_iv, iv.data, iv.len); 2231 SECITEM_FreeItem(param,PR_TRUE); 2232 if (clientContext == NULL) { 2233 ssl_MapLowLevelError(SSL_ERROR_SYM_KEY_CONTEXT_FAILURE); 2234 goto fail; 2235 } 2236 pwSpec->encode = (SSLCipher) PK11_CipherOp; 2237 pwSpec->decode = (SSLCipher) PK11_CipherOp; 2238 pwSpec->destroy = (SSLDestroy) PK11_DestroyContext; 2239 2240 pwSpec->encodeContext = (ss->sec.isServer) ? serverContext : clientContext; 2241 pwSpec->decodeContext = (ss->sec.isServer) ? clientContext : serverContext; 2242 2243 serverContext = NULL; 2244 clientContext = NULL; 2245 2246 ssl3_InitCompressionContext(pwSpec); 2247 2248 return SECSuccess; 2249 2250 fail: 2251 if (serverContext != NULL) PK11_DestroyContext(serverContext, PR_TRUE); 2252 if (clientContext != NULL) PK11_DestroyContext(clientContext, PR_TRUE); 2253 if (pwSpec->client.write_mac_context != NULL) { 2254 PK11_DestroyContext(pwSpec->client.write_mac_context,PR_TRUE); 2255 pwSpec->client.write_mac_context = NULL; 2256 } 2257 if (pwSpec->server.write_mac_context != NULL) { 2258 PK11_DestroyContext(pwSpec->server.write_mac_context,PR_TRUE); 2259 pwSpec->server.write_mac_context = NULL; 2260 } 2261 2262 return SECFailure; 2263 } 2264 2265 /* Complete the initialization of all keys, ciphers, MACs and their contexts 2266 * for the pending Cipher Spec. 2267 * Called from: ssl3_SendClientKeyExchange (for Full handshake) 2268 * ssl3_HandleRSAClientKeyExchange (for Full handshake) 2269 * ssl3_HandleServerHello (for session restart) 2270 * ssl3_HandleClientHello (for session restart) 2271 * Sets error code, but caller probably should override to disambiguate. 2272 * NULL pms means re-use old master_secret. 2273 * 2274 * This code is common to the bypass and PKCS11 execution paths. 2275 * For the bypass case, pms is NULL. 2276 */ 2277 SECStatus 2278 ssl3_InitPendingCipherSpec(sslSocket *ss, PK11SymKey *pms) 2279 { 2280 ssl3CipherSpec * pwSpec; 2281 ssl3CipherSpec * cwSpec; 2282 SECStatus rv; 2283 2284 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 2285 2286 ssl_GetSpecWriteLock(ss); /**************************************/ 2287 2288 PORT_Assert(ss->ssl3.prSpec == ss->ssl3.pwSpec); 2289 2290 pwSpec = ss->ssl3.pwSpec; 2291 cwSpec = ss->ssl3.cwSpec; 2292 2293 if (pms || (!pwSpec->msItem.len && !pwSpec->master_secret)) { 2294 rv = ssl3_DeriveMasterSecret(ss, pms); 2295 if (rv != SECSuccess) { 2296 goto done; /* err code set by ssl3_DeriveMasterSecret */ 2297 } 2298 } 2299 #ifndef NO_PKCS11_BYPASS 2300 if (ss->opt.bypassPKCS11 && pwSpec->msItem.len && pwSpec->msItem.data) { 2301 /* Double Bypass succeeded in extracting the master_secret */ 2302 const ssl3KEADef * kea_def = ss->ssl3.hs.kea_def; 2303 PRBool isTLS = (PRBool)(kea_def->tls_keygen || 2304 (pwSpec->version > SSL_LIBRARY_VERSION_3_0)); 2305 pwSpec->bypassCiphers = PR_TRUE; 2306 rv = ssl3_KeyAndMacDeriveBypass( pwSpec, 2307 (const unsigned char *)&ss->ssl3.hs.client_random, 2308 (const unsigned char *)&ss->ssl3.hs.server_random, 2309 isTLS, 2310 (PRBool)(kea_def->is_limited)); 2311 if (rv == SECSuccess) { 2312 rv = ssl3_InitPendingContextsBypass(ss); 2313 } 2314 } else 2315 #endif 2316 if (pwSpec->master_secret) { 2317 rv = ssl3_DeriveConnectionKeysPKCS11(ss); 2318 if (rv == SECSuccess) { 2319 rv = ssl3_InitPendingContextsPKCS11(ss); 2320 } 2321 } else { 2322 PORT_Assert(pwSpec->master_secret); 2323 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 2324 rv = SECFailure; 2325 } 2326 if (rv != SECSuccess) { 2327 goto done; 2328 } 2329 2330 /* Generic behaviors -- common to all crypto methods */ 2331 if (!IS_DTLS(ss)) { 2332 pwSpec->read_seq_num.high = pwSpec->write_seq_num.high = 0; 2333 } else { 2334 if (cwSpec->epoch == PR_UINT16_MAX) { 2335 /* The problem here is that we have rehandshaked too many 2336 * times (you are not allowed to wrap the epoch). The 2337 * spec says you should be discarding the connection 2338 * and start over, so not much we can do here. */ 2339 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 2340 rv = SECFailure; 2341 goto done; 2342 } 2343 /* The sequence number has the high 16 bits as the epoch. */ 2344 pwSpec->epoch = cwSpec->epoch + 1; 2345 pwSpec->read_seq_num.high = pwSpec->write_seq_num.high = 2346 pwSpec->epoch << 16; 2347 2348 dtls_InitRecvdRecords(&pwSpec->recvdRecords); 2349 } 2350 pwSpec->read_seq_num.low = pwSpec->write_seq_num.low = 0; 2351 2352 done: 2353 ssl_ReleaseSpecWriteLock(ss); /******************************/ 2354 if (rv != SECSuccess) 2355 ssl_MapLowLevelError(SSL_ERROR_SESSION_KEY_GEN_FAILURE); 2356 return rv; 2357 } 2358 2359 /* 2360 * 60 bytes is 3 times the maximum length MAC size that is supported. 2361 */ 2362 static const unsigned char mac_pad_1 [60] = { 2363 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 2364 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 2365 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 2366 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 2367 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 2368 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 2369 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 2370 0x36, 0x36, 0x36, 0x36 2371 }; 2372 static const unsigned char mac_pad_2 [60] = { 2373 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 2374 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 2375 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 2376 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 2377 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 2378 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 2379 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 2380 0x5c, 0x5c, 0x5c, 0x5c 2381 }; 2382 2383 /* Called from: ssl3_SendRecord() 2384 ** Caller must already hold the SpecReadLock. (wish we could assert that!) 2385 */ 2386 static SECStatus 2387 ssl3_ComputeRecordMAC( 2388 ssl3CipherSpec * spec, 2389 PRBool useServerMacKey, 2390 const unsigned char *header, 2391 unsigned int headerLen, 2392 const SSL3Opaque * input, 2393 int inputLength, 2394 unsigned char * outbuf, 2395 unsigned int * outLength) 2396 { 2397 const ssl3MACDef * mac_def; 2398 SECStatus rv; 2399 2400 PRINT_BUF(95, (NULL, "frag hash1: header", header, headerLen)); 2401 PRINT_BUF(95, (NULL, "frag hash1: input", input, inputLength)); 2402 2403 mac_def = spec->mac_def; 2404 if (mac_def->mac == mac_null) { 2405 *outLength = 0; 2406 return SECSuccess; 2407 } 2408 #ifndef NO_PKCS11_BYPASS 2409 if (spec->bypassCiphers) { 2410 /* bypass version */ 2411 const SECHashObject *hashObj = NULL; 2412 unsigned int pad_bytes = 0; 2413 PRUint64 write_mac_context[MAX_MAC_CONTEXT_LLONGS]; 2414 2415 switch (mac_def->mac) { 2416 case ssl_mac_null: 2417 *outLength = 0; 2418 return SECSuccess; 2419 case ssl_mac_md5: 2420 pad_bytes = 48; 2421 hashObj = HASH_GetRawHashObject(HASH_AlgMD5); 2422 break; 2423 case ssl_mac_sha: 2424 pad_bytes = 40; 2425 hashObj = HASH_GetRawHashObject(HASH_AlgSHA1); 2426 break; 2427 case ssl_hmac_md5: /* used with TLS */ 2428 hashObj = HASH_GetRawHashObject(HASH_AlgMD5); 2429 break; 2430 case ssl_hmac_sha: /* used with TLS */ 2431 hashObj = HASH_GetRawHashObject(HASH_AlgSHA1); 2432 break; 2433 case ssl_hmac_sha256: /* used with TLS */ 2434 hashObj = HASH_GetRawHashObject(HASH_AlgSHA256); 2435 break; 2436 default: 2437 break; 2438 } 2439 if (!hashObj) { 2440 PORT_Assert(0); 2441 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 2442 return SECFailure; 2443 } 2444 2445 if (spec->version <= SSL_LIBRARY_VERSION_3_0) { 2446 unsigned int tempLen; 2447 unsigned char temp[MAX_MAC_LENGTH]; 2448 2449 /* compute "inner" part of SSL3 MAC */ 2450 hashObj->begin(write_mac_context); 2451 if (useServerMacKey) 2452 hashObj->update(write_mac_context, 2453 spec->server.write_mac_key_item.data, 2454 spec->server.write_mac_key_item.len); 2455 else 2456 hashObj->update(write_mac_context, 2457 spec->client.write_mac_key_item.data, 2458 spec->client.write_mac_key_item.len); 2459 hashObj->update(write_mac_context, mac_pad_1, pad_bytes); 2460 hashObj->update(write_mac_context, header, headerLen); 2461 hashObj->update(write_mac_context, input, inputLength); 2462 hashObj->end(write_mac_context, temp, &tempLen, sizeof temp); 2463 2464 /* compute "outer" part of SSL3 MAC */ 2465 hashObj->begin(write_mac_context); 2466 if (useServerMacKey) 2467 hashObj->update(write_mac_context, 2468 spec->server.write_mac_key_item.data, 2469 spec->server.write_mac_key_item.len); 2470 else 2471 hashObj->update(write_mac_context, 2472 spec->client.write_mac_key_item.data, 2473 spec->client.write_mac_key_item.len); 2474 hashObj->update(write_mac_context, mac_pad_2, pad_bytes); 2475 hashObj->update(write_mac_context, temp, tempLen); 2476 hashObj->end(write_mac_context, outbuf, outLength, spec->mac_size); 2477 rv = SECSuccess; 2478 } else { /* is TLS */ 2479 #define cx ((HMACContext *)write_mac_context) 2480 if (useServerMacKey) { 2481 rv = HMAC_Init(cx, hashObj, 2482 spec->server.write_mac_key_item.data, 2483 spec->server.write_mac_key_item.len, PR_FALSE); 2484 } else { 2485 rv = HMAC_Init(cx, hashObj, 2486 spec->client.write_mac_key_item.data, 2487 spec->client.write_mac_key_item.len, PR_FALSE); 2488 } 2489 if (rv == SECSuccess) { 2490 HMAC_Begin(cx); 2491 HMAC_Update(cx, header, headerLen); 2492 HMAC_Update(cx, input, inputLength); 2493 rv = HMAC_Finish(cx, outbuf, outLength, spec->mac_size); 2494 HMAC_Destroy(cx, PR_FALSE); 2495 } 2496 #undef cx 2497 } 2498 } else 2499 #endif 2500 { 2501 PK11Context *mac_context = 2502 (useServerMacKey ? spec->server.write_mac_context 2503 : spec->client.write_mac_context); 2504 rv = PK11_DigestBegin(mac_context); 2505 rv |= PK11_DigestOp(mac_context, header, headerLen); 2506 rv |= PK11_DigestOp(mac_context, input, inputLength); 2507 rv |= PK11_DigestFinal(mac_context, outbuf, outLength, spec->mac_size); 2508 } 2509 2510 PORT_Assert(rv != SECSuccess || *outLength == (unsigned)spec->mac_size); 2511 2512 PRINT_BUF(95, (NULL, "frag hash2: result", outbuf, *outLength)); 2513 2514 if (rv != SECSuccess) { 2515 rv = SECFailure; 2516 ssl_MapLowLevelError(SSL_ERROR_MAC_COMPUTATION_FAILURE); 2517 } 2518 return rv; 2519 } 2520 2521 /* Called from: ssl3_HandleRecord() 2522 * Caller must already hold the SpecReadLock. (wish we could assert that!) 2523 * 2524 * On entry: 2525 * originalLen >= inputLen >= MAC size 2526 */ 2527 static SECStatus 2528 ssl3_ComputeRecordMACConstantTime( 2529 ssl3CipherSpec * spec, 2530 PRBool useServerMacKey, 2531 const unsigned char *header, 2532 unsigned int headerLen, 2533 const SSL3Opaque * input, 2534 int inputLen, 2535 int originalLen, 2536 unsigned char * outbuf, 2537 unsigned int * outLen) 2538 { 2539 CK_MECHANISM_TYPE macType; 2540 CK_NSS_MAC_CONSTANT_TIME_PARAMS params; 2541 SECItem param, inputItem, outputItem; 2542 SECStatus rv; 2543 PK11SymKey * key; 2544 2545 PORT_Assert(inputLen >= spec->mac_size); 2546 PORT_Assert(originalLen >= inputLen); 2547 2548 if (spec->bypassCiphers) { 2549 /* This function doesn't support PKCS#11 bypass. We fallback on the 2550 * non-constant time version. */ 2551 goto fallback; 2552 } 2553 2554 if (spec->mac_def->mac == mac_null) { 2555 *outLen = 0; 2556 return SECSuccess; 2557 } 2558 2559 macType = CKM_NSS_HMAC_CONSTANT_TIME; 2560 if (spec->version <= SSL_LIBRARY_VERSION_3_0) { 2561 macType = CKM_NSS_SSL3_MAC_CONSTANT_TIME; 2562 } 2563 2564 params.macAlg = spec->mac_def->mmech; 2565 params.ulBodyTotalLen = originalLen; 2566 params.pHeader = (unsigned char *) header; /* const cast */ 2567 params.ulHeaderLen = headerLen; 2568 2569 param.data = (unsigned char*) ¶ms; 2570 param.len = sizeof(params); 2571 param.type = 0; 2572 2573 inputItem.data = (unsigned char *) input; 2574 inputItem.len = inputLen; 2575 inputItem.type = 0; 2576 2577 outputItem.data = outbuf; 2578 outputItem.len = *outLen; 2579 outputItem.type = 0; 2580 2581 key = spec->server.write_mac_key; 2582 if (!useServerMacKey) { 2583 key = spec->client.write_mac_key; 2584 } 2585 2586 rv = PK11_SignWithSymKey(key, macType, ¶m, &outputItem, &inputItem); 2587 if (rv != SECSuccess) { 2588 if (PORT_GetError() == SEC_ERROR_INVALID_ALGORITHM) { 2589 goto fallback; 2590 } 2591 2592 *outLen = 0; 2593 rv = SECFailure; 2594 ssl_MapLowLevelError(SSL_ERROR_MAC_COMPUTATION_FAILURE); 2595 return rv; 2596 } 2597 2598 PORT_Assert(outputItem.len == (unsigned)spec->mac_size); 2599 *outLen = outputItem.len; 2600 2601 return rv; 2602 2603 fallback: 2604 /* ssl3_ComputeRecordMAC expects the MAC to have been removed from the 2605 * length already. */ 2606 inputLen -= spec->mac_size; 2607 return ssl3_ComputeRecordMAC(spec, useServerMacKey, header, headerLen, 2608 input, inputLen, outbuf, outLen); 2609 } 2610 2611 static PRBool 2612 ssl3_ClientAuthTokenPresent(sslSessionID *sid) { 2613 PK11SlotInfo *slot = NULL; 2614 PRBool isPresent = PR_TRUE; 2615 2616 /* we only care if we are doing client auth */ 2617 /* If NSS_PLATFORM_CLIENT_AUTH is defined and a platformClientKey is being 2618 * used, u.ssl3.clAuthValid will be false and this function will always 2619 * return PR_TRUE. */ 2620 if (!sid || !sid->u.ssl3.clAuthValid) { 2621 return PR_TRUE; 2622 } 2623 2624 /* get the slot */ 2625 slot = SECMOD_LookupSlot(sid->u.ssl3.clAuthModuleID, 2626 sid->u.ssl3.clAuthSlotID); 2627 if (slot == NULL || 2628 !PK11_IsPresent(slot) || 2629 sid->u.ssl3.clAuthSeries != PK11_GetSlotSeries(slot) || 2630 sid->u.ssl3.clAuthSlotID != PK11_GetSlotID(slot) || 2631 sid->u.ssl3.clAuthModuleID != PK11_GetModuleID(slot) || 2632 (PK11_NeedLogin(slot) && !PK11_IsLoggedIn(slot, NULL))) { 2633 isPresent = PR_FALSE; 2634 } 2635 if (slot) { 2636 PK11_FreeSlot(slot); 2637 } 2638 return isPresent; 2639 } 2640 2641 /* Caller must hold the spec read lock. */ 2642 SECStatus 2643 ssl3_CompressMACEncryptRecord(ssl3CipherSpec * cwSpec, 2644 PRBool isServer, 2645 PRBool isDTLS, 2646 PRBool capRecordVersion, 2647 SSL3ContentType type, 2648 const SSL3Opaque * pIn, 2649 PRUint32 contentLen, 2650 sslBuffer * wrBuf) 2651 { 2652 const ssl3BulkCipherDef * cipher_def; 2653 SECStatus rv; 2654 PRUint32 macLen = 0; 2655 PRUint32 fragLen; 2656 PRUint32 p1Len, p2Len, oddLen = 0; 2657 PRUint16 headerLen; 2658 int ivLen = 0; 2659 int cipherBytes = 0; 2660 unsigned char pseudoHeader[13]; 2661 unsigned int pseudoHeaderLen; 2662 2663 cipher_def = cwSpec->cipher_def; 2664 headerLen = isDTLS ? DTLS_RECORD_HEADER_LENGTH : SSL3_RECORD_HEADER_LENGTH; 2665 2666 if (cipher_def->type == type_block && 2667 cwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_1) { 2668 /* Prepend the per-record explicit IV using technique 2b from 2669 * RFC 4346 section 6.2.3.2: The IV is a cryptographically 2670 * strong random number XORed with the CBC residue from the previous 2671 * record. 2672 */ 2673 ivLen = cipher_def->iv_size; 2674 if (ivLen > wrBuf->space - headerLen) { 2675 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 2676 return SECFailure; 2677 } 2678 rv = PK11_GenerateRandom(wrBuf->buf + headerLen, ivLen); 2679 if (rv != SECSuccess) { 2680 ssl_MapLowLevelError(SSL_ERROR_GENERATE_RANDOM_FAILURE); 2681 return rv; 2682 } 2683 rv = cwSpec->encode( cwSpec->encodeContext, 2684 wrBuf->buf + headerLen, 2685 &cipherBytes, /* output and actual outLen */ 2686 ivLen, /* max outlen */ 2687 wrBuf->buf + headerLen, 2688 ivLen); /* input and inputLen*/ 2689 if (rv != SECSuccess || cipherBytes != ivLen) { 2690 PORT_SetError(SSL_ERROR_ENCRYPTION_FAILURE); 2691 return SECFailure; 2692 } 2693 } 2694 2695 if (cwSpec->compressor) { 2696 int outlen; 2697 rv = cwSpec->compressor( 2698 cwSpec->compressContext, 2699 wrBuf->buf + headerLen + ivLen, &outlen, 2700 wrBuf->space - headerLen - ivLen, pIn, contentLen); 2701 if (rv != SECSuccess) 2702 return rv; 2703 pIn = wrBuf->buf + headerLen + ivLen; 2704 contentLen = outlen; 2705 } 2706 2707 pseudoHeaderLen = ssl3_BuildRecordPseudoHeader( 2708 pseudoHeader, cwSpec->write_seq_num, type, 2709 cwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_0, cwSpec->version, 2710 isDTLS, contentLen); 2711 PORT_Assert(pseudoHeaderLen <= sizeof(pseudoHeader)); 2712 if (cipher_def->type == type_aead) { 2713 const int nonceLen = cipher_def->explicit_nonce_size; 2714 const int tagLen = cipher_def->tag_size; 2715 2716 if (headerLen + nonceLen + contentLen + tagLen > wrBuf->space) { 2717 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 2718 return SECFailure; 2719 } 2720 2721 cipherBytes = contentLen; 2722 rv = cwSpec->aead( 2723 isServer ? &cwSpec->server : &cwSpec->client, 2724 PR_FALSE, /* do encrypt */ 2725 wrBuf->buf + headerLen, /* output */ 2726 &cipherBytes, /* out len */ 2727 wrBuf->space - headerLen, /* max out */ 2728 pIn, contentLen, /* input */ 2729 pseudoHeader, pseudoHeaderLen); 2730 if (rv != SECSuccess) { 2731 PORT_SetError(SSL_ERROR_ENCRYPTION_FAILURE); 2732 return SECFailure; 2733 } 2734 } else { 2735 /* 2736 * Add the MAC 2737 */ 2738 rv = ssl3_ComputeRecordMAC(cwSpec, isServer, 2739 pseudoHeader, pseudoHeaderLen, pIn, contentLen, 2740 wrBuf->buf + headerLen + ivLen + contentLen, &macLen); 2741 if (rv != SECSuccess) { 2742 ssl_MapLowLevelError(SSL_ERROR_MAC_COMPUTATION_FAILURE); 2743 return SECFailure; 2744 } 2745 p1Len = contentLen; 2746 p2Len = macLen; 2747 fragLen = contentLen + macLen; /* needs to be encrypted */ 2748 PORT_Assert(fragLen <= MAX_FRAGMENT_LENGTH + 1024); 2749 2750 /* 2751 * Pad the text (if we're doing a block cipher) 2752 * then Encrypt it 2753 */ 2754 if (cipher_def->type == type_block) { 2755 unsigned char * pBuf; 2756 int padding_length; 2757 int i; 2758 2759 oddLen = contentLen % cipher_def->block_size; 2760 /* Assume blockSize is a power of two */ 2761 padding_length = cipher_def->block_size - 1 - 2762 ((fragLen) & (cipher_def->block_size - 1)); 2763 fragLen += padding_length + 1; 2764 PORT_Assert((fragLen % cipher_def->block_size) == 0); 2765 2766 /* Pad according to TLS rules (also acceptable to SSL3). */ 2767 pBuf = &wrBuf->buf[headerLen + ivLen + fragLen - 1]; 2768 for (i = padding_length + 1; i > 0; --i) { 2769 *pBuf-- = padding_length; 2770 } 2771 /* now, if contentLen is not a multiple of block size, fix it */ 2772 p2Len = fragLen - p1Len; 2773 } 2774 if (p1Len < 256) { 2775 oddLen = p1Len; 2776 p1Len = 0; 2777 } else { 2778 p1Len -= oddLen; 2779 } 2780 if (oddLen) { 2781 p2Len += oddLen; 2782 PORT_Assert( (cipher_def->block_size < 2) || \ 2783 (p2Len % cipher_def->block_size) == 0); 2784 memmove(wrBuf->buf + headerLen + ivLen + p1Len, pIn + p1Len, 2785 oddLen); 2786 } 2787 if (p1Len > 0) { 2788 int cipherBytesPart1 = -1; 2789 rv = cwSpec->encode( cwSpec->encodeContext, 2790 wrBuf->buf + headerLen + ivLen, /* output */ 2791 &cipherBytesPart1, /* actual outlen */ 2792 p1Len, /* max outlen */ 2793 pIn, p1Len); /* input, and inputlen */ 2794 PORT_Assert(rv == SECSuccess && cipherBytesPart1 == (int) p1Len); 2795 if (rv != SECSuccess || cipherBytesPart1 != (int) p1Len) { 2796 PORT_SetError(SSL_ERROR_ENCRYPTION_FAILURE); 2797 return SECFailure; 2798 } 2799 cipherBytes += cipherBytesPart1; 2800 } 2801 if (p2Len > 0) { 2802 int cipherBytesPart2 = -1; 2803 rv = cwSpec->encode( cwSpec->encodeContext, 2804 wrBuf->buf + headerLen + ivLen + p1Len, 2805 &cipherBytesPart2, /* output and actual outLen */ 2806 p2Len, /* max outlen */ 2807 wrBuf->buf + headerLen + ivLen + p1Len, 2808 p2Len); /* input and inputLen*/ 2809 PORT_Assert(rv == SECSuccess && cipherBytesPart2 == (int) p2Len); 2810 if (rv != SECSuccess || cipherBytesPart2 != (int) p2Len) { 2811 PORT_SetError(SSL_ERROR_ENCRYPTION_FAILURE); 2812 return SECFailure; 2813 } 2814 cipherBytes += cipherBytesPart2; 2815 } 2816 } 2817 2818 PORT_Assert(cipherBytes <= MAX_FRAGMENT_LENGTH + 1024); 2819 2820 wrBuf->len = cipherBytes + headerLen; 2821 wrBuf->buf[0] = type; 2822 if (isDTLS) { 2823 SSL3ProtocolVersion version; 2824 2825 version = dtls_TLSVersionToDTLSVersion(cwSpec->version); 2826 wrBuf->buf[1] = MSB(version); 2827 wrBuf->buf[2] = LSB(version); 2828 wrBuf->buf[3] = (unsigned char)(cwSpec->write_seq_num.high >> 24); 2829 wrBuf->buf[4] = (unsigned char)(cwSpec->write_seq_num.high >> 16); 2830 wrBuf->buf[5] = (unsigned char)(cwSpec->write_seq_num.high >> 8); 2831 wrBuf->buf[6] = (unsigned char)(cwSpec->write_seq_num.high >> 0); 2832 wrBuf->buf[7] = (unsigned char)(cwSpec->write_seq_num.low >> 24); 2833 wrBuf->buf[8] = (unsigned char)(cwSpec->write_seq_num.low >> 16); 2834 wrBuf->buf[9] = (unsigned char)(cwSpec->write_seq_num.low >> 8); 2835 wrBuf->buf[10] = (unsigned char)(cwSpec->write_seq_num.low >> 0); 2836 wrBuf->buf[11] = MSB(cipherBytes); 2837 wrBuf->buf[12] = LSB(cipherBytes); 2838 } else { 2839 SSL3ProtocolVersion version = cwSpec->version; 2840 2841 if (capRecordVersion) { 2842 version = PR_MIN(SSL_LIBRARY_VERSION_TLS_1_0, version); 2843 } 2844 wrBuf->buf[1] = MSB(version); 2845 wrBuf->buf[2] = LSB(version); 2846 wrBuf->buf[3] = MSB(cipherBytes); 2847 wrBuf->buf[4] = LSB(cipherBytes); 2848 } 2849 2850 ssl3_BumpSequenceNumber(&cwSpec->write_seq_num); 2851 2852 return SECSuccess; 2853 } 2854 2855 /* Process the plain text before sending it. 2856 * Returns the number of bytes of plaintext that were successfully sent 2857 * plus the number of bytes of plaintext that were copied into the 2858 * output (write) buffer. 2859 * Returns SECFailure on a hard IO error, memory error, or crypto error. 2860 * Does NOT return SECWouldBlock. 2861 * 2862 * Notes on the use of the private ssl flags: 2863 * (no private SSL flags) 2864 * Attempt to make and send SSL records for all plaintext 2865 * If non-blocking and a send gets WOULD_BLOCK, 2866 * or if the pending (ciphertext) buffer is not empty, 2867 * then buffer remaining bytes of ciphertext into pending buf, 2868 * and continue to do that for all succssive records until all 2869 * bytes are used. 2870 * ssl_SEND_FLAG_FORCE_INTO_BUFFER 2871 * As above, except this suppresses all write attempts, and forces 2872 * all ciphertext into the pending ciphertext buffer. 2873 * ssl_SEND_FLAG_USE_EPOCH (for DTLS) 2874 * Forces the use of the provided epoch 2875 * ssl_SEND_FLAG_CAP_RECORD_VERSION 2876 * Caps the record layer version number of TLS ClientHello to { 3, 1 } 2877 * (TLS 1.0). Some TLS 1.0 servers (which seem to use F5 BIG-IP) ignore 2878 * ClientHello.client_version and use the record layer version number 2879 * (TLSPlaintext.version) instead when negotiating protocol versions. In 2880 * addition, if the record layer version number of ClientHello is { 3, 2 } 2881 * (TLS 1.1) or higher, these servers reset the TCP connections. Lastly, 2882 * some F5 BIG-IP servers hang if a record containing a ClientHello has a 2883 * version greater than { 3, 1 } and a length greater than 255. Set this 2884 * flag to work around such servers. 2885 */ 2886 PRInt32 2887 ssl3_SendRecord( sslSocket * ss, 2888 DTLSEpoch epoch, /* DTLS only */ 2889 SSL3ContentType type, 2890 const SSL3Opaque * pIn, /* input buffer */ 2891 PRInt32 nIn, /* bytes of input */ 2892 PRInt32 flags) 2893 { 2894 sslBuffer * wrBuf = &ss->sec.writeBuf; 2895 SECStatus rv; 2896 PRInt32 totalSent = 0; 2897 PRBool capRecordVersion; 2898 2899 SSL_TRC(3, ("%d: SSL3[%d] SendRecord type: %s nIn=%d", 2900 SSL_GETPID(), ss->fd, ssl3_DecodeContentType(type), 2901 nIn)); 2902 PRINT_BUF(50, (ss, "Send record (plain text)", pIn, nIn)); 2903 2904 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss) ); 2905 2906 capRecordVersion = ((flags & ssl_SEND_FLAG_CAP_RECORD_VERSION) != 0); 2907 2908 if (capRecordVersion) { 2909 /* ssl_SEND_FLAG_CAP_RECORD_VERSION can only be used with the 2910 * TLS initial ClientHello. */ 2911 PORT_Assert(!IS_DTLS(ss)); 2912 PORT_Assert(!ss->firstHsDone); 2913 PORT_Assert(type == content_handshake); 2914 PORT_Assert(ss->ssl3.hs.ws == wait_server_hello); 2915 } 2916 2917 if (ss->ssl3.initialized == PR_FALSE) { 2918 /* This can happen on a server if the very first incoming record 2919 ** looks like a defective ssl3 record (e.g. too long), and we're 2920 ** trying to send an alert. 2921 */ 2922 PR_ASSERT(type == content_alert); 2923 rv = ssl3_InitState(ss); 2924 if (rv != SECSuccess) { 2925 return SECFailure; /* ssl3_InitState has set the error code. */ 2926 } 2927 } 2928 2929 /* check for Token Presence */ 2930 if (!ssl3_ClientAuthTokenPresent(ss->sec.ci.sid)) { 2931 PORT_SetError(SSL_ERROR_TOKEN_INSERTION_REMOVAL); 2932 return SECFailure; 2933 } 2934 2935 while (nIn > 0) { 2936 PRUint32 contentLen = PR_MIN(nIn, MAX_FRAGMENT_LENGTH); 2937 unsigned int spaceNeeded; 2938 unsigned int numRecords; 2939 2940 ssl_GetSpecReadLock(ss); /********************************/ 2941 2942 if (nIn > 1 && ss->opt.cbcRandomIV && 2943 ss->ssl3.cwSpec->version < SSL_LIBRARY_VERSION_TLS_1_1 && 2944 type == content_application_data && 2945 ss->ssl3.cwSpec->cipher_def->type == type_block /* CBC mode */) { 2946 /* We will split the first byte of the record into its own record, 2947 * as explained in the documentation for SSL_CBC_RANDOM_IV in ssl.h 2948 */ 2949 numRecords = 2; 2950 } else { 2951 numRecords = 1; 2952 } 2953 2954 spaceNeeded = contentLen + (numRecords * SSL3_BUFFER_FUDGE); 2955 if (ss->ssl3.cwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_1 && 2956 ss->ssl3.cwSpec->cipher_def->type == type_block) { 2957 spaceNeeded += ss->ssl3.cwSpec->cipher_def->iv_size; 2958 } 2959 if (spaceNeeded > wrBuf->space) { 2960 rv = sslBuffer_Grow(wrBuf, spaceNeeded); 2961 if (rv != SECSuccess) { 2962 SSL_DBG(("%d: SSL3[%d]: SendRecord, tried to get %d bytes", 2963 SSL_GETPID(), ss->fd, spaceNeeded)); 2964 goto spec_locked_loser; /* sslBuffer_Grow set error code. */ 2965 } 2966 } 2967 2968 if (numRecords == 2) { 2969 sslBuffer secondRecord; 2970 2971 rv = ssl3_CompressMACEncryptRecord(ss->ssl3.cwSpec, 2972 ss->sec.isServer, IS_DTLS(ss), 2973 capRecordVersion, type, pIn, 2974 1, wrBuf); 2975 if (rv != SECSuccess) 2976 goto spec_locked_loser; 2977 2978 PRINT_BUF(50, (ss, "send (encrypted) record data [1/2]:", 2979 wrBuf->buf, wrBuf->len)); 2980 2981 secondRecord.buf = wrBuf->buf + wrBuf->len; 2982 secondRecord.len = 0; 2983 secondRecord.space = wrBuf->space - wrBuf->len; 2984 2985 rv = ssl3_CompressMACEncryptRecord(ss->ssl3.cwSpec, 2986 ss->sec.isServer, IS_DTLS(ss), 2987 capRecordVersion, type, 2988 pIn + 1, contentLen - 1, 2989 &secondRecord); 2990 if (rv == SECSuccess) { 2991 PRINT_BUF(50, (ss, "send (encrypted) record data [2/2]:", 2992 secondRecord.buf, secondRecord.len)); 2993 wrBuf->len += secondRecord.len; 2994 } 2995 } else { 2996 if (!IS_DTLS(ss)) { 2997 rv = ssl3_CompressMACEncryptRecord(ss->ssl3.cwSpec, 2998 ss->sec.isServer, 2999 IS_DTLS(ss), 3000 capRecordVersion, 3001 type, pIn, 3002 contentLen, wrBuf); 3003 } else { 3004 rv = dtls_CompressMACEncryptRecord(ss, epoch, 3005 !!(flags & ssl_SEND_FLAG_USE_EPOCH), 3006 type, pIn, 3007 contentLen, wrBuf); 3008 } 3009 3010 if (rv == SECSuccess) { 3011 PRINT_BUF(50, (ss, "send (encrypted) record data:", 3012 wrBuf->buf, wrBuf->len)); 3013 } 3014 } 3015 3016 spec_locked_loser: 3017 ssl_ReleaseSpecReadLock(ss); /************************************/ 3018 3019 if (rv != SECSuccess) 3020 return SECFailure; 3021 3022 pIn += contentLen; 3023 nIn -= contentLen; 3024 PORT_Assert( nIn >= 0 ); 3025 3026 /* If there's still some previously saved ciphertext, 3027 * or the caller doesn't want us to send the data yet, 3028 * then add all our new ciphertext to the amount previously saved. 3029 */ 3030 if ((ss->pendingBuf.len > 0) || 3031 (flags & ssl_SEND_FLAG_FORCE_INTO_BUFFER)) { 3032 3033 rv = ssl_SaveWriteData(ss, wrBuf->buf, wrBuf->len); 3034 if (rv != SECSuccess) { 3035 /* presumably a memory error, SEC_ERROR_NO_MEMORY */ 3036 return SECFailure; 3037 } 3038 wrBuf->len = 0; /* All cipher text is saved away. */ 3039 3040 if (!(flags & ssl_SEND_FLAG_FORCE_INTO_BUFFER)) { 3041 PRInt32 sent; 3042 ss->handshakeBegun = 1; 3043 sent = ssl_SendSavedWriteData(ss); 3044 if (sent < 0 && PR_GetError() != PR_WOULD_BLOCK_ERROR) { 3045 ssl_MapLowLevelError(SSL_ERROR_SOCKET_WRITE_FAILURE); 3046 return SECFailure; 3047 } 3048 if (ss->pendingBuf.len) { 3049 flags |= ssl_SEND_FLAG_FORCE_INTO_BUFFER; 3050 } 3051 } 3052 } else if (wrBuf->len > 0) { 3053 PRInt32 sent; 3054 ss->handshakeBegun = 1; 3055 sent = ssl_DefSend(ss, wrBuf->buf, wrBuf->len, 3056 flags & ~ssl_SEND_FLAG_MASK); 3057 if (sent < 0) { 3058 if (PR_GetError() != PR_WOULD_BLOCK_ERROR) { 3059 ssl_MapLowLevelError(SSL_ERROR_SOCKET_WRITE_FAILURE); 3060 return SECFailure; 3061 } 3062 /* we got PR_WOULD_BLOCK_ERROR, which means none was sent. */ 3063 sent = 0; 3064 } 3065 wrBuf->len -= sent; 3066 if (wrBuf->len) { 3067 if (IS_DTLS(ss)) { 3068 /* DTLS just says no in this case. No buffering */ 3069 PR_SetError(PR_WOULD_BLOCK_ERROR, 0); 3070 return SECFailure; 3071 } 3072 /* now take all the remaining unsent new ciphertext and 3073 * append it to the buffer of previously unsent ciphertext. 3074 */ 3075 rv = ssl_SaveWriteData(ss, wrBuf->buf + sent, wrBuf->len); 3076 if (rv != SECSuccess) { 3077 /* presumably a memory error, SEC_ERROR_NO_MEMORY */ 3078 return SECFailure; 3079 } 3080 } 3081 } 3082 totalSent += contentLen; 3083 } 3084 return totalSent; 3085 } 3086 3087 #define SSL3_PENDING_HIGH_WATER 1024 3088 3089 /* Attempt to send the content of "in" in an SSL application_data record. 3090 * Returns "len" or SECFailure, never SECWouldBlock, nor SECSuccess. 3091 */ 3092 int 3093 ssl3_SendApplicationData(sslSocket *ss, const unsigned char *in, 3094 PRInt32 len, PRInt32 flags) 3095 { 3096 PRInt32 totalSent = 0; 3097 PRInt32 discarded = 0; 3098 3099 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss) ); 3100 /* These flags for internal use only */ 3101 PORT_Assert(!(flags & (ssl_SEND_FLAG_USE_EPOCH | 3102 ssl_SEND_FLAG_NO_RETRANSMIT))); 3103 if (len < 0 || !in) { 3104 PORT_SetError(PR_INVALID_ARGUMENT_ERROR); 3105 return SECFailure; 3106 } 3107 3108 if (ss->pendingBuf.len > SSL3_PENDING_HIGH_WATER && 3109 !ssl_SocketIsBlocking(ss)) { 3110 PORT_Assert(!ssl_SocketIsBlocking(ss)); 3111 PORT_SetError(PR_WOULD_BLOCK_ERROR); 3112 return SECFailure; 3113 } 3114 3115 if (ss->appDataBuffered && len) { 3116 PORT_Assert (in[0] == (unsigned char)(ss->appDataBuffered)); 3117 if (in[0] != (unsigned char)(ss->appDataBuffered)) { 3118 PORT_SetError(PR_INVALID_ARGUMENT_ERROR); 3119 return SECFailure; 3120 } 3121 in++; 3122 len--; 3123 discarded = 1; 3124 } 3125 while (len > totalSent) { 3126 PRInt32 sent, toSend; 3127 3128 if (totalSent > 0) { 3129 /* 3130 * The thread yield is intended to give the reader thread a 3131 * chance to get some cycles while the writer thread is in 3132 * the middle of a large application data write. (See 3133 * Bugzilla bug 127740, comment #1.) 3134 */ 3135 ssl_ReleaseXmitBufLock(ss); 3136 PR_Sleep(PR_INTERVAL_NO_WAIT); /* PR_Yield(); */ 3137 ssl_GetXmitBufLock(ss); 3138 } 3139 toSend = PR_MIN(len - totalSent, MAX_FRAGMENT_LENGTH); 3140 /* 3141 * Note that the 0 epoch is OK because flags will never require 3142 * its use, as guaranteed by the PORT_Assert above. 3143 */ 3144 sent = ssl3_SendRecord(ss, 0, content_application_data, 3145 in + totalSent, toSend, flags); 3146 if (sent < 0) { 3147 if (totalSent > 0 && PR_GetError() == PR_WOULD_BLOCK_ERROR) { 3148 PORT_Assert(ss->lastWriteBlocked); 3149 break; 3150 } 3151 return SECFailure; /* error code set by ssl3_SendRecord */ 3152 } 3153 totalSent += sent; 3154 if (ss->pendingBuf.len) { 3155 /* must be a non-blocking socket */ 3156 PORT_Assert(!ssl_SocketIsBlocking(ss)); 3157 PORT_Assert(ss->lastWriteBlocked); 3158 break; 3159 } 3160 } 3161 if (ss->pendingBuf.len) { 3162 /* Must be non-blocking. */ 3163 PORT_Assert(!ssl_SocketIsBlocking(ss)); 3164 if (totalSent > 0) { 3165 ss->appDataBuffered = 0x100 | in[totalSent - 1]; 3166 } 3167 3168 totalSent = totalSent + discarded - 1; 3169 if (totalSent <= 0) { 3170 PORT_SetError(PR_WOULD_BLOCK_ERROR); 3171 totalSent = SECFailure; 3172 } 3173 return totalSent; 3174 } 3175 ss->appDataBuffered = 0; 3176 return totalSent + discarded; 3177 } 3178 3179 /* Attempt to send buffered handshake messages. 3180 * This function returns SECSuccess or SECFailure, never SECWouldBlock. 3181 * Always set sendBuf.len to 0, even when returning SECFailure. 3182 * 3183 * Depending on whether we are doing DTLS or not, this either calls 3184 * 3185 * - ssl3_FlushHandshakeMessages if non-DTLS 3186 * - dtls_FlushHandshakeMessages if DTLS 3187 * 3188 * Called from SSL3_SendAlert(), ssl3_SendChangeCipherSpecs(), 3189 * ssl3_AppendHandshake(), ssl3_SendClientHello(), 3190 * ssl3_SendHelloRequest(), ssl3_SendServerHelloDone(), 3191 * ssl3_SendFinished(), 3192 */ 3193 static SECStatus 3194 ssl3_FlushHandshake(sslSocket *ss, PRInt32 flags) 3195 { 3196 if (IS_DTLS(ss)) { 3197 return dtls_FlushHandshakeMessages(ss, flags); 3198 } else { 3199 return ssl3_FlushHandshakeMessages(ss, flags); 3200 } 3201 } 3202 3203 /* Attempt to send the content of sendBuf buffer in an SSL handshake record. 3204 * This function returns SECSuccess or SECFailure, never SECWouldBlock. 3205 * Always set sendBuf.len to 0, even when returning SECFailure. 3206 * 3207 * Called from ssl3_FlushHandshake 3208 */ 3209 static SECStatus 3210 ssl3_FlushHandshakeMessages(sslSocket *ss, PRInt32 flags) 3211 { 3212 static const PRInt32 allowedFlags = ssl_SEND_FLAG_FORCE_INTO_BUFFER | 3213 ssl_SEND_FLAG_CAP_RECORD_VERSION; 3214 PRInt32 rv = SECSuccess; 3215 3216 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 3217 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss) ); 3218 3219 if (!ss->sec.ci.sendBuf.buf || !ss->sec.ci.sendBuf.len) 3220 return rv; 3221 3222 /* only these flags are allowed */ 3223 PORT_Assert(!(flags & ~allowedFlags)); 3224 if ((flags & ~allowedFlags) != 0) { 3225 PORT_SetError(SEC_ERROR_INVALID_ARGS); 3226 rv = SECFailure; 3227 } else { 3228 rv = ssl3_SendRecord(ss, 0, content_handshake, ss->sec.ci.sendBuf.buf, 3229 ss->sec.ci.sendBuf.len, flags); 3230 } 3231 if (rv < 0) { 3232 int err = PORT_GetError(); 3233 PORT_Assert(err != PR_WOULD_BLOCK_ERROR); 3234 if (err == PR_WOULD_BLOCK_ERROR) { 3235 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 3236 } 3237 } else if (rv < ss->sec.ci.sendBuf.len) { 3238 /* short write should never happen */ 3239 PORT_Assert(rv >= ss->sec.ci.sendBuf.len); 3240 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 3241 rv = SECFailure; 3242 } else { 3243 rv = SECSuccess; 3244 } 3245 3246 /* Whether we succeeded or failed, toss the old handshake data. */ 3247 ss->sec.ci.sendBuf.len = 0; 3248 return rv; 3249 } 3250 3251 /* 3252 * Called from ssl3_HandleAlert and from ssl3_HandleCertificate when 3253 * the remote client sends a negative response to our certificate request. 3254 * Returns SECFailure if the application has required client auth. 3255 * SECSuccess otherwise. 3256 */ 3257 static SECStatus 3258 ssl3_HandleNoCertificate(sslSocket *ss) 3259 { 3260 if (ss->sec.peerCert != NULL) { 3261 if (ss->sec.peerKey != NULL) { 3262 SECKEY_DestroyPublicKey(ss->sec.peerKey); 3263 ss->sec.peerKey = NULL; 3264 } 3265 CERT_DestroyCertificate(ss->sec.peerCert); 3266 ss->sec.peerCert = NULL; 3267 } 3268 ssl3_CleanupPeerCerts(ss); 3269 3270 /* If the server has required client-auth blindly but doesn't 3271 * actually look at the certificate it won't know that no 3272 * certificate was presented so we shutdown the socket to ensure 3273 * an error. We only do this if we haven't already completed the 3274 * first handshake because if we're redoing the handshake we 3275 * know the server is paying attention to the certificate. 3276 */ 3277 if ((ss->opt.requireCertificate == SSL_REQUIRE_ALWAYS) || 3278 (!ss->firstHsDone && 3279 (ss->opt.requireCertificate == SSL_REQUIRE_FIRST_HANDSHAKE))) { 3280 PRFileDesc * lower; 3281 3282 if (ss->sec.uncache) 3283 ss->sec.uncache(ss->sec.ci.sid); 3284 SSL3_SendAlert(ss, alert_fatal, bad_certificate); 3285 3286 lower = ss->fd->lower; 3287 #ifdef _WIN32 3288 lower->methods->shutdown(lower, PR_SHUTDOWN_SEND); 3289 #else 3290 lower->methods->shutdown(lower, PR_SHUTDOWN_BOTH); 3291 #endif 3292 PORT_SetError(SSL_ERROR_NO_CERTIFICATE); 3293 return SECFailure; 3294 } 3295 return SECSuccess; 3296 } 3297 3298 /************************************************************************ 3299 * Alerts 3300 */ 3301 3302 /* 3303 ** Acquires both handshake and XmitBuf locks. 3304 ** Called from: ssl3_IllegalParameter <- 3305 ** ssl3_HandshakeFailure <- 3306 ** ssl3_HandleAlert <- ssl3_HandleRecord. 3307 ** ssl3_HandleChangeCipherSpecs <- ssl3_HandleRecord 3308 ** ssl3_ConsumeHandshakeVariable <- 3309 ** ssl3_HandleHelloRequest <- 3310 ** ssl3_HandleServerHello <- 3311 ** ssl3_HandleServerKeyExchange <- 3312 ** ssl3_HandleCertificateRequest <- 3313 ** ssl3_HandleServerHelloDone <- 3314 ** ssl3_HandleClientHello <- 3315 ** ssl3_HandleV2ClientHello <- 3316 ** ssl3_HandleCertificateVerify <- 3317 ** ssl3_HandleClientKeyExchange <- 3318 ** ssl3_HandleCertificate <- 3319 ** ssl3_HandleFinished <- 3320 ** ssl3_HandleHandshakeMessage <- 3321 ** ssl3_HandleRecord <- 3322 ** 3323 */ 3324 SECStatus 3325 SSL3_SendAlert(sslSocket *ss, SSL3AlertLevel level, SSL3AlertDescription desc) 3326 { 3327 PRUint8 bytes[2]; 3328 SECStatus rv; 3329 3330 SSL_TRC(3, ("%d: SSL3[%d]: send alert record, level=%d desc=%d", 3331 SSL_GETPID(), ss->fd, level, desc)); 3332 3333 bytes[0] = level; 3334 bytes[1] = desc; 3335 3336 ssl_GetSSL3HandshakeLock(ss); 3337 if (level == alert_fatal) { 3338 if (!ss->opt.noCache && ss->sec.ci.sid && ss->sec.uncache) { 3339 ss->sec.uncache(ss->sec.ci.sid); 3340 } 3341 } 3342 ssl_GetXmitBufLock(ss); 3343 rv = ssl3_FlushHandshake(ss, ssl_SEND_FLAG_FORCE_INTO_BUFFER); 3344 if (rv == SECSuccess) { 3345 PRInt32 sent; 3346 sent = ssl3_SendRecord(ss, 0, content_alert, bytes, 2, 3347 desc == no_certificate 3348 ? ssl_SEND_FLAG_FORCE_INTO_BUFFER : 0); 3349 rv = (sent >= 0) ? SECSuccess : (SECStatus)sent; 3350 } 3351 ssl_ReleaseXmitBufLock(ss); 3352 ssl_ReleaseSSL3HandshakeLock(ss); 3353 return rv; /* error set by ssl3_FlushHandshake or ssl3_SendRecord */ 3354 } 3355 3356 /* 3357 * Send illegal_parameter alert. Set generic error number. 3358 */ 3359 static SECStatus 3360 ssl3_IllegalParameter(sslSocket *ss) 3361 { 3362 (void)SSL3_SendAlert(ss, alert_fatal, illegal_parameter); 3363 PORT_SetError(ss->sec.isServer ? SSL_ERROR_BAD_CLIENT 3364 : SSL_ERROR_BAD_SERVER ); 3365 return SECFailure; 3366 } 3367 3368 /* 3369 * Send handshake_Failure alert. Set generic error number. 3370 */ 3371 static SECStatus 3372 ssl3_HandshakeFailure(sslSocket *ss) 3373 { 3374 (void)SSL3_SendAlert(ss, alert_fatal, handshake_failure); 3375 PORT_SetError( ss->sec.isServer ? SSL_ERROR_BAD_CLIENT 3376 : SSL_ERROR_BAD_SERVER ); 3377 return SECFailure; 3378 } 3379 3380 static void 3381 ssl3_SendAlertForCertError(sslSocket * ss, PRErrorCode errCode) 3382 { 3383 SSL3AlertDescription desc = bad_certificate; 3384 PRBool isTLS = ss->version >= SSL_LIBRARY_VERSION_3_1_TLS; 3385 3386 switch (errCode) { 3387 case SEC_ERROR_LIBRARY_FAILURE: desc = unsupported_certificate; break; 3388 case SEC_ERROR_EXPIRED_CERTIFICATE: desc = certificate_expired; break; 3389 case SEC_ERROR_REVOKED_CERTIFICATE: desc = certificate_revoked; break; 3390 case SEC_ERROR_INADEQUATE_KEY_USAGE: 3391 case SEC_ERROR_INADEQUATE_CERT_TYPE: 3392 desc = certificate_unknown; break; 3393 case SEC_ERROR_UNTRUSTED_CERT: 3394 desc = isTLS ? access_denied : certificate_unknown; break; 3395 case SEC_ERROR_UNKNOWN_ISSUER: 3396 case SEC_ERROR_UNTRUSTED_ISSUER: 3397 desc = isTLS ? unknown_ca : certificate_unknown; break; 3398 case SEC_ERROR_EXPIRED_ISSUER_CERTIFICATE: 3399 desc = isTLS ? unknown_ca : certificate_expired; break; 3400 3401 case SEC_ERROR_CERT_NOT_IN_NAME_SPACE: 3402 case SEC_ERROR_PATH_LEN_CONSTRAINT_INVALID: 3403 case SEC_ERROR_CA_CERT_INVALID: 3404 case SEC_ERROR_BAD_SIGNATURE: 3405 default: desc = bad_certificate; break; 3406 } 3407 SSL_DBG(("%d: SSL3[%d]: peer certificate is no good: error=%d", 3408 SSL_GETPID(), ss->fd, errCode)); 3409 3410 (void) SSL3_SendAlert(ss, alert_fatal, desc); 3411 } 3412 3413 3414 /* 3415 * Send decode_error alert. Set generic error number. 3416 */ 3417 SECStatus 3418 ssl3_DecodeError(sslSocket *ss) 3419 { 3420 (void)SSL3_SendAlert(ss, alert_fatal, 3421 ss->version > SSL_LIBRARY_VERSION_3_0 ? decode_error 3422 : illegal_parameter); 3423 PORT_SetError( ss->sec.isServer ? SSL_ERROR_BAD_CLIENT 3424 : SSL_ERROR_BAD_SERVER ); 3425 return SECFailure; 3426 } 3427 3428 /* Called from ssl3_HandleRecord. 3429 ** Caller must hold both RecvBuf and Handshake locks. 3430 */ 3431 static SECStatus 3432 ssl3_HandleAlert(sslSocket *ss, sslBuffer *buf) 3433 { 3434 SSL3AlertLevel level; 3435 SSL3AlertDescription desc; 3436 int error; 3437 3438 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 3439 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 3440 3441 SSL_TRC(3, ("%d: SSL3[%d]: handle alert record", SSL_GETPID(), ss->fd)); 3442 3443 if (buf->len != 2) { 3444 (void)ssl3_DecodeError(ss); 3445 PORT_SetError(SSL_ERROR_RX_MALFORMED_ALERT); 3446 return SECFailure; 3447 } 3448 level = (SSL3AlertLevel)buf->buf[0]; 3449 desc = (SSL3AlertDescription)buf->buf[1]; 3450 buf->len = 0; 3451 SSL_TRC(5, ("%d: SSL3[%d] received alert, level = %d, description = %d", 3452 SSL_GETPID(), ss->fd, level, desc)); 3453 3454 switch (desc) { 3455 case close_notify: ss->recvdCloseNotify = 1; 3456 error = SSL_ERROR_CLOSE_NOTIFY_ALERT; break; 3457 case unexpected_message: error = SSL_ERROR_HANDSHAKE_UNEXPECTED_ALERT; 3458 break; 3459 case bad_record_mac: error = SSL_ERROR_BAD_MAC_ALERT; break; 3460 case decryption_failed_RESERVED: 3461 error = SSL_ERROR_DECRYPTION_FAILED_ALERT; 3462 break; 3463 case record_overflow: error = SSL_ERROR_RECORD_OVERFLOW_ALERT; break; 3464 case decompression_failure: error = SSL_ERROR_DECOMPRESSION_FAILURE_ALERT; 3465 break; 3466 case handshake_failure: error = SSL_ERROR_HANDSHAKE_FAILURE_ALERT; 3467 break; 3468 case no_certificate: error = SSL_ERROR_NO_CERTIFICATE; break; 3469 case bad_certificate: error = SSL_ERROR_BAD_CERT_ALERT; break; 3470 case unsupported_certificate:error = SSL_ERROR_UNSUPPORTED_CERT_ALERT;break; 3471 case certificate_revoked: error = SSL_ERROR_REVOKED_CERT_ALERT; break; 3472 case certificate_expired: error = SSL_ERROR_EXPIRED_CERT_ALERT; break; 3473 case certificate_unknown: error = SSL_ERROR_CERTIFICATE_UNKNOWN_ALERT; 3474 break; 3475 case illegal_parameter: error = SSL_ERROR_ILLEGAL_PARAMETER_ALERT;break; 3476 case inappropriate_fallback: 3477 error = SSL_ERROR_INAPPROPRIATE_FALLBACK_ALERT; 3478 break; 3479 3480 /* All alerts below are TLS only. */ 3481 case unknown_ca: error = SSL_ERROR_UNKNOWN_CA_ALERT; break; 3482 case access_denied: error = SSL_ERROR_ACCESS_DENIED_ALERT; break; 3483 case decode_error: error = SSL_ERROR_DECODE_ERROR_ALERT; break; 3484 case decrypt_error: error = SSL_ERROR_DECRYPT_ERROR_ALERT; break; 3485 case export_restriction: error = SSL_ERROR_EXPORT_RESTRICTION_ALERT; 3486 break; 3487 case protocol_version: error = SSL_ERROR_PROTOCOL_VERSION_ALERT; break; 3488 case insufficient_security: error = SSL_ERROR_INSUFFICIENT_SECURITY_ALERT; 3489 break; 3490 case internal_error: error = SSL_ERROR_INTERNAL_ERROR_ALERT; break; 3491 case user_canceled: error = SSL_ERROR_USER_CANCELED_ALERT; break; 3492 case no_renegotiation: error = SSL_ERROR_NO_RENEGOTIATION_ALERT; break; 3493 3494 /* Alerts for TLS client hello extensions */ 3495 case unsupported_extension: 3496 error = SSL_ERROR_UNSUPPORTED_EXTENSION_ALERT; break; 3497 case certificate_unobtainable: 3498 error = SSL_ERROR_CERTIFICATE_UNOBTAINABLE_ALERT; break; 3499 case unrecognized_name: 3500 error = SSL_ERROR_UNRECOGNIZED_NAME_ALERT; break; 3501 case bad_certificate_status_response: 3502 error = SSL_ERROR_BAD_CERT_STATUS_RESPONSE_ALERT; break; 3503 case bad_certificate_hash_value: 3504 error = SSL_ERROR_BAD_CERT_HASH_VALUE_ALERT; break; 3505 default: error = SSL_ERROR_RX_UNKNOWN_ALERT; break; 3506 } 3507 if (level == alert_fatal) { 3508 if (!ss->opt.noCache) { 3509 if (ss->sec.uncache) 3510 ss->sec.uncache(ss->sec.ci.sid); 3511 } 3512 if ((ss->ssl3.hs.ws == wait_server_hello) && 3513 (desc == handshake_failure)) { 3514 /* XXX This is a hack. We're assuming that any handshake failure 3515 * XXX on the client hello is a failure to match ciphers. 3516 */ 3517 error = SSL_ERROR_NO_CYPHER_OVERLAP; 3518 } 3519 PORT_SetError(error); 3520 return SECFailure; 3521 } 3522 if ((desc == no_certificate) && (ss->ssl3.hs.ws == wait_client_cert)) { 3523 /* I'm a server. I've requested a client cert. He hasn't got one. */ 3524 SECStatus rv; 3525 3526 PORT_Assert(ss->sec.isServer); 3527 ss->ssl3.hs.ws = wait_client_key; 3528 rv = ssl3_HandleNoCertificate(ss); 3529 return rv; 3530 } 3531 return SECSuccess; 3532 } 3533 3534 /* 3535 * Change Cipher Specs 3536 * Called from ssl3_HandleServerHelloDone, 3537 * ssl3_HandleClientHello, 3538 * and ssl3_HandleFinished 3539 * 3540 * Acquires and releases spec write lock, to protect switching the current 3541 * and pending write spec pointers. 3542 */ 3543 3544 static SECStatus 3545 ssl3_SendChangeCipherSpecs(sslSocket *ss) 3546 { 3547 PRUint8 change = change_cipher_spec_choice; 3548 ssl3CipherSpec * pwSpec; 3549 SECStatus rv; 3550 PRInt32 sent; 3551 3552 SSL_TRC(3, ("%d: SSL3[%d]: send change_cipher_spec record", 3553 SSL_GETPID(), ss->fd)); 3554 3555 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss) ); 3556 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 3557 3558 rv = ssl3_FlushHandshake(ss, ssl_SEND_FLAG_FORCE_INTO_BUFFER); 3559 if (rv != SECSuccess) { 3560 return rv; /* error code set by ssl3_FlushHandshake */ 3561 } 3562 if (!IS_DTLS(ss)) { 3563 sent = ssl3_SendRecord(ss, 0, content_change_cipher_spec, &change, 1, 3564 ssl_SEND_FLAG_FORCE_INTO_BUFFER); 3565 if (sent < 0) { 3566 return (SECStatus)sent; /* error code set by ssl3_SendRecord */ 3567 } 3568 } else { 3569 rv = dtls_QueueMessage(ss, content_change_cipher_spec, &change, 1); 3570 if (rv != SECSuccess) { 3571 return rv; 3572 } 3573 } 3574 3575 /* swap the pending and current write specs. */ 3576 ssl_GetSpecWriteLock(ss); /**************************************/ 3577 pwSpec = ss->ssl3.pwSpec; 3578 3579 ss->ssl3.pwSpec = ss->ssl3.cwSpec; 3580 ss->ssl3.cwSpec = pwSpec; 3581 3582 SSL_TRC(3, ("%d: SSL3[%d] Set Current Write Cipher Suite to Pending", 3583 SSL_GETPID(), ss->fd )); 3584 3585 /* We need to free up the contexts, keys and certs ! */ 3586 /* If we are really through with the old cipher spec 3587 * (Both the read and write sides have changed) destroy it. 3588 */ 3589 if (ss->ssl3.prSpec == ss->ssl3.pwSpec) { 3590 if (!IS_DTLS(ss)) { 3591 ssl3_DestroyCipherSpec(ss->ssl3.pwSpec, PR_FALSE/*freeSrvName*/); 3592 } else { 3593 /* With DTLS, we need to set a holddown timer in case the final 3594 * message got lost */ 3595 ss->ssl3.hs.rtTimeoutMs = DTLS_FINISHED_TIMER_MS; 3596 dtls_StartTimer(ss, dtls_FinishedTimerCb); 3597 } 3598 } 3599 ssl_ReleaseSpecWriteLock(ss); /**************************************/ 3600 3601 return SECSuccess; 3602 } 3603 3604 /* Called from ssl3_HandleRecord. 3605 ** Caller must hold both RecvBuf and Handshake locks. 3606 * 3607 * Acquires and releases spec write lock, to protect switching the current 3608 * and pending write spec pointers. 3609 */ 3610 static SECStatus 3611 ssl3_HandleChangeCipherSpecs(sslSocket *ss, sslBuffer *buf) 3612 { 3613 ssl3CipherSpec * prSpec; 3614 SSL3WaitState ws = ss->ssl3.hs.ws; 3615 SSL3ChangeCipherSpecChoice change; 3616 3617 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 3618 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 3619 3620 SSL_TRC(3, ("%d: SSL3[%d]: handle change_cipher_spec record", 3621 SSL_GETPID(), ss->fd)); 3622 3623 if (ws != wait_change_cipher) { 3624 if (IS_DTLS(ss)) { 3625 /* Ignore this because it's out of order. */ 3626 SSL_TRC(3, ("%d: SSL3[%d]: discard out of order " 3627 "DTLS change_cipher_spec", 3628 SSL_GETPID(), ss->fd)); 3629 buf->len = 0; 3630 return SECSuccess; 3631 } 3632 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 3633 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_CHANGE_CIPHER); 3634 return SECFailure; 3635 } 3636 3637 if(buf->len != 1) { 3638 (void)ssl3_DecodeError(ss); 3639 PORT_SetError(SSL_ERROR_RX_MALFORMED_CHANGE_CIPHER); 3640 return SECFailure; 3641 } 3642 change = (SSL3ChangeCipherSpecChoice)buf->buf[0]; 3643 if (change != change_cipher_spec_choice) { 3644 /* illegal_parameter is correct here for both SSL3 and TLS. */ 3645 (void)ssl3_IllegalParameter(ss); 3646 PORT_SetError(SSL_ERROR_RX_MALFORMED_CHANGE_CIPHER); 3647 return SECFailure; 3648 } 3649 buf->len = 0; 3650 3651 /* Swap the pending and current read specs. */ 3652 ssl_GetSpecWriteLock(ss); /*************************************/ 3653 prSpec = ss->ssl3.prSpec; 3654 3655 ss->ssl3.prSpec = ss->ssl3.crSpec; 3656 ss->ssl3.crSpec = prSpec; 3657 ss->ssl3.hs.ws = wait_finished; 3658 3659 SSL_TRC(3, ("%d: SSL3[%d] Set Current Read Cipher Suite to Pending", 3660 SSL_GETPID(), ss->fd )); 3661 3662 /* If we are really through with the old cipher prSpec 3663 * (Both the read and write sides have changed) destroy it. 3664 */ 3665 if (ss->ssl3.prSpec == ss->ssl3.pwSpec) { 3666 ssl3_DestroyCipherSpec(ss->ssl3.prSpec, PR_FALSE/*freeSrvName*/); 3667 } 3668 ssl_ReleaseSpecWriteLock(ss); /*************************************/ 3669 return SECSuccess; 3670 } 3671 3672 /* This method uses PKCS11 to derive the MS from the PMS, where PMS 3673 ** is a PKCS11 symkey. This is used in all cases except the 3674 ** "triple bypass" with RSA key exchange. 3675 ** Called from ssl3_InitPendingCipherSpec. prSpec is pwSpec. 3676 */ 3677 static SECStatus 3678 ssl3_DeriveMasterSecret(sslSocket *ss, PK11SymKey *pms) 3679 { 3680 ssl3CipherSpec * pwSpec = ss->ssl3.pwSpec; 3681 const ssl3KEADef *kea_def= ss->ssl3.hs.kea_def; 3682 unsigned char * cr = (unsigned char *)&ss->ssl3.hs.client_random; 3683 unsigned char * sr = (unsigned char *)&ss->ssl3.hs.server_random; 3684 PRBool isTLS = (PRBool)(kea_def->tls_keygen || 3685 (pwSpec->version > SSL_LIBRARY_VERSION_3_0)); 3686 PRBool isTLS12= 3687 (PRBool)(isTLS && pwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_2); 3688 /* 3689 * Whenever isDH is true, we need to use CKM_TLS_MASTER_KEY_DERIVE_DH 3690 * which, unlike CKM_TLS_MASTER_KEY_DERIVE, converts arbitrary size 3691 * data into a 48-byte value. 3692 */ 3693 PRBool isDH = (PRBool) ((ss->ssl3.hs.kea_def->exchKeyType == kt_dh) || 3694 (ss->ssl3.hs.kea_def->exchKeyType == kt_ecdh)); 3695 SECStatus rv = SECFailure; 3696 CK_MECHANISM_TYPE master_derive; 3697 CK_MECHANISM_TYPE key_derive; 3698 SECItem params; 3699 CK_FLAGS keyFlags; 3700 CK_VERSION pms_version; 3701 CK_SSL3_MASTER_KEY_DERIVE_PARAMS master_params; 3702 3703 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 3704 PORT_Assert( ss->opt.noLocks || ssl_HaveSpecWriteLock(ss)); 3705 PORT_Assert(ss->ssl3.prSpec == ss->ssl3.pwSpec); 3706 if (isTLS12) { 3707 if(isDH) master_derive = CKM_NSS_TLS_MASTER_KEY_DERIVE_DH_SHA256; 3708 else master_derive = CKM_NSS_TLS_MASTER_KEY_DERIVE_SHA256; 3709 key_derive = CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256; 3710 keyFlags = CKF_SIGN | CKF_VERIFY; 3711 } else if (isTLS) { 3712 if(isDH) master_derive = CKM_TLS_MASTER_KEY_DERIVE_DH; 3713 else master_derive = CKM_TLS_MASTER_KEY_DERIVE; 3714 key_derive = CKM_TLS_KEY_AND_MAC_DERIVE; 3715 keyFlags = CKF_SIGN | CKF_VERIFY; 3716 } else { 3717 if (isDH) master_derive = CKM_SSL3_MASTER_KEY_DERIVE_DH; 3718 else master_derive = CKM_SSL3_MASTER_KEY_DERIVE; 3719 key_derive = CKM_SSL3_KEY_AND_MAC_DERIVE; 3720 keyFlags = 0; 3721 } 3722 3723 if (pms || !pwSpec->master_secret) { 3724 if (isDH) { 3725 master_params.pVersion = NULL; 3726 } else { 3727 master_params.pVersion = &pms_version; 3728 } 3729 master_params.RandomInfo.pClientRandom = cr; 3730 master_params.RandomInfo.ulClientRandomLen = SSL3_RANDOM_LENGTH; 3731 master_params.RandomInfo.pServerRandom = sr; 3732 master_params.RandomInfo.ulServerRandomLen = SSL3_RANDOM_LENGTH; 3733 3734 params.data = (unsigned char *) &master_params; 3735 params.len = sizeof master_params; 3736 } 3737 3738 if (pms != NULL) { 3739 #if defined(TRACE) 3740 if (ssl_trace >= 100) { 3741 SECStatus extractRV = PK11_ExtractKeyValue(pms); 3742 if (extractRV == SECSuccess) { 3743 SECItem * keyData = PK11_GetKeyData(pms); 3744 if (keyData && keyData->data && keyData->len) { 3745 ssl_PrintBuf(ss, "Pre-Master Secret", 3746 keyData->data, keyData->len); 3747 } 3748 } 3749 } 3750 #endif 3751 pwSpec->master_secret = PK11_DeriveWithFlags(pms, master_derive, 3752 ¶ms, key_derive, CKA_DERIVE, 0, keyFlags); 3753 if (!isDH && pwSpec->master_secret && ss->opt.detectRollBack) { 3754 SSL3ProtocolVersion client_version; 3755 client_version = pms_version.major << 8 | pms_version.minor; 3756 3757 if (IS_DTLS(ss)) { 3758 client_version = dtls_DTLSVersionToTLSVersion(client_version); 3759 } 3760 3761 if (client_version != ss->clientHelloVersion) { 3762 /* Destroy it. Version roll-back detected. */ 3763 PK11_FreeSymKey(pwSpec->master_secret); 3764 pwSpec->master_secret = NULL; 3765 } 3766 } 3767 if (pwSpec->master_secret == NULL) { 3768 /* Generate a faux master secret in the same slot as the old one. */ 3769 PK11SlotInfo * slot = PK11_GetSlotFromKey((PK11SymKey *)pms); 3770 PK11SymKey * fpms = ssl3_GenerateRSAPMS(ss, pwSpec, slot); 3771 3772 PK11_FreeSlot(slot); 3773 if (fpms != NULL) { 3774 pwSpec->master_secret = PK11_DeriveWithFlags(fpms, 3775 master_derive, ¶ms, key_derive, 3776 CKA_DERIVE, 0, keyFlags); 3777 PK11_FreeSymKey(fpms); 3778 } 3779 } 3780 } 3781 if (pwSpec->master_secret == NULL) { 3782 /* Generate a faux master secret from the internal slot. */ 3783 PK11SlotInfo * slot = PK11_GetInternalSlot(); 3784 PK11SymKey * fpms = ssl3_GenerateRSAPMS(ss, pwSpec, slot); 3785 3786 PK11_FreeSlot(slot); 3787 if (fpms != NULL) { 3788 pwSpec->master_secret = PK11_DeriveWithFlags(fpms, 3789 master_derive, ¶ms, key_derive, 3790 CKA_DERIVE, 0, keyFlags); 3791 if (pwSpec->master_secret == NULL) { 3792 pwSpec->master_secret = fpms; /* use the fpms as the master. */ 3793 fpms = NULL; 3794 } 3795 } 3796 if (fpms) { 3797 PK11_FreeSymKey(fpms); 3798 } 3799 } 3800 if (pwSpec->master_secret == NULL) { 3801 ssl_MapLowLevelError(SSL_ERROR_SESSION_KEY_GEN_FAILURE); 3802 return rv; 3803 } 3804 #ifndef NO_PKCS11_BYPASS 3805 if (ss->opt.bypassPKCS11) { 3806 SECItem * keydata; 3807 /* In hope of doing a "double bypass", 3808 * need to extract the master secret's value from the key object 3809 * and store it raw in the sslSocket struct. 3810 */ 3811 rv = PK11_ExtractKeyValue(pwSpec->master_secret); 3812 if (rv != SECSuccess) { 3813 return rv; 3814 } 3815 /* This returns the address of the secItem inside the key struct, 3816 * not a copy or a reference. So, there's no need to free it. 3817 */ 3818 keydata = PK11_GetKeyData(pwSpec->master_secret); 3819 if (keydata && keydata->len <= sizeof pwSpec->raw_master_secret) { 3820 memcpy(pwSpec->raw_master_secret, keydata->data, keydata->len); 3821 pwSpec->msItem.data = pwSpec->raw_master_secret; 3822 pwSpec->msItem.len = keydata->len; 3823 } else { 3824 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 3825 return SECFailure; 3826 } 3827 } 3828 #endif 3829 return SECSuccess; 3830 } 3831 3832 3833 /* 3834 * Derive encryption and MAC Keys (and IVs) from master secret 3835 * Sets a useful error code when returning SECFailure. 3836 * 3837 * Called only from ssl3_InitPendingCipherSpec(), 3838 * which in turn is called from 3839 * sendRSAClientKeyExchange (for Full handshake) 3840 * sendDHClientKeyExchange (for Full handshake) 3841 * ssl3_HandleClientKeyExchange (for Full handshake) 3842 * ssl3_HandleServerHello (for session restart) 3843 * ssl3_HandleClientHello (for session restart) 3844 * Caller MUST hold the specWriteLock, and SSL3HandshakeLock. 3845 * ssl3_InitPendingCipherSpec does that. 3846 * 3847 */ 3848 static SECStatus 3849 ssl3_DeriveConnectionKeysPKCS11(sslSocket *ss) 3850 { 3851 ssl3CipherSpec * pwSpec = ss->ssl3.pwSpec; 3852 const ssl3KEADef * kea_def = ss->ssl3.hs.kea_def; 3853 unsigned char * cr = (unsigned char *)&ss->ssl3.hs.client_random; 3854 unsigned char * sr = (unsigned char *)&ss->ssl3.hs.server_random; 3855 PRBool isTLS = (PRBool)(kea_def->tls_keygen || 3856 (pwSpec->version > SSL_LIBRARY_VERSION_3_0)); 3857 PRBool isTLS12= 3858 (PRBool)(isTLS && pwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_2); 3859 /* following variables used in PKCS11 path */ 3860 const ssl3BulkCipherDef *cipher_def = pwSpec->cipher_def; 3861 PK11SlotInfo * slot = NULL; 3862 PK11SymKey * symKey = NULL; 3863 void * pwArg = ss->pkcs11PinArg; 3864 int keySize; 3865 CK_SSL3_KEY_MAT_PARAMS key_material_params; 3866 CK_SSL3_KEY_MAT_OUT returnedKeys; 3867 CK_MECHANISM_TYPE key_derive; 3868 CK_MECHANISM_TYPE bulk_mechanism; 3869 SSLCipherAlgorithm calg; 3870 SECItem params; 3871 PRBool skipKeysAndIVs = (PRBool)(cipher_def->calg == calg_null); 3872 3873 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 3874 PORT_Assert( ss->opt.noLocks || ssl_HaveSpecWriteLock(ss)); 3875 PORT_Assert(ss->ssl3.prSpec == ss->ssl3.pwSpec); 3876 3877 if (!pwSpec->master_secret) { 3878 PORT_SetError(SSL_ERROR_SESSION_KEY_GEN_FAILURE); 3879 return SECFailure; 3880 } 3881 /* 3882 * generate the key material 3883 */ 3884 key_material_params.ulMacSizeInBits = pwSpec->mac_size * BPB; 3885 key_material_params.ulKeySizeInBits = cipher_def->secret_key_size* BPB; 3886 key_material_params.ulIVSizeInBits = cipher_def->iv_size * BPB; 3887 if (cipher_def->type == type_block && 3888 pwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_1) { 3889 /* Block ciphers in >= TLS 1.1 use a per-record, explicit IV. */ 3890 key_material_params.ulIVSizeInBits = 0; 3891 memset(pwSpec->client.write_iv, 0, cipher_def->iv_size); 3892 memset(pwSpec->server.write_iv, 0, cipher_def->iv_size); 3893 } 3894 3895 key_material_params.bIsExport = (CK_BBOOL)(kea_def->is_limited); 3896 3897 key_material_params.RandomInfo.pClientRandom = cr; 3898 key_material_params.RandomInfo.ulClientRandomLen = SSL3_RANDOM_LENGTH; 3899 key_material_params.RandomInfo.pServerRandom = sr; 3900 key_material_params.RandomInfo.ulServerRandomLen = SSL3_RANDOM_LENGTH; 3901 key_material_params.pReturnedKeyMaterial = &returnedKeys; 3902 3903 returnedKeys.pIVClient = pwSpec->client.write_iv; 3904 returnedKeys.pIVServer = pwSpec->server.write_iv; 3905 keySize = cipher_def->key_size; 3906 3907 if (skipKeysAndIVs) { 3908 keySize = 0; 3909 key_material_params.ulKeySizeInBits = 0; 3910 key_material_params.ulIVSizeInBits = 0; 3911 returnedKeys.pIVClient = NULL; 3912 returnedKeys.pIVServer = NULL; 3913 } 3914 3915 calg = cipher_def->calg; 3916 PORT_Assert( alg2Mech[calg].calg == calg); 3917 bulk_mechanism = alg2Mech[calg].cmech; 3918 3919 params.data = (unsigned char *)&key_material_params; 3920 params.len = sizeof(key_material_params); 3921 3922 if (isTLS12) { 3923 key_derive = CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256; 3924 } else if (isTLS) { 3925 key_derive = CKM_TLS_KEY_AND_MAC_DERIVE; 3926 } else { 3927 key_derive = CKM_SSL3_KEY_AND_MAC_DERIVE; 3928 } 3929 3930 /* CKM_SSL3_KEY_AND_MAC_DERIVE is defined to set ENCRYPT, DECRYPT, and 3931 * DERIVE by DEFAULT */ 3932 symKey = PK11_Derive(pwSpec->master_secret, key_derive, ¶ms, 3933 bulk_mechanism, CKA_ENCRYPT, keySize); 3934 if (!symKey) { 3935 ssl_MapLowLevelError(SSL_ERROR_SESSION_KEY_GEN_FAILURE); 3936 return SECFailure; 3937 } 3938 /* we really should use the actual mac'ing mechanism here, but we 3939 * don't because these types are used to map keytype anyway and both 3940 * mac's map to the same keytype. 3941 */ 3942 slot = PK11_GetSlotFromKey(symKey); 3943 3944 PK11_FreeSlot(slot); /* slot is held until the key is freed */ 3945 pwSpec->client.write_mac_key = 3946 PK11_SymKeyFromHandle(slot, symKey, PK11_OriginDerive, 3947 CKM_SSL3_SHA1_MAC, returnedKeys.hClientMacSecret, PR_TRUE, pwArg); 3948 if (pwSpec->client.write_mac_key == NULL ) { 3949 goto loser; /* loser sets err */ 3950 } 3951 pwSpec->server.write_mac_key = 3952 PK11_SymKeyFromHandle(slot, symKey, PK11_OriginDerive, 3953 CKM_SSL3_SHA1_MAC, returnedKeys.hServerMacSecret, PR_TRUE, pwArg); 3954 if (pwSpec->server.write_mac_key == NULL ) { 3955 goto loser; /* loser sets err */ 3956 } 3957 if (!skipKeysAndIVs) { 3958 pwSpec->client.write_key = 3959 PK11_SymKeyFromHandle(slot, symKey, PK11_OriginDerive, 3960 bulk_mechanism, returnedKeys.hClientKey, PR_TRUE, pwArg); 3961 if (pwSpec->client.write_key == NULL ) { 3962 goto loser; /* loser sets err */ 3963 } 3964 pwSpec->server.write_key = 3965 PK11_SymKeyFromHandle(slot, symKey, PK11_OriginDerive, 3966 bulk_mechanism, returnedKeys.hServerKey, PR_TRUE, pwArg); 3967 if (pwSpec->server.write_key == NULL ) { 3968 goto loser; /* loser sets err */ 3969 } 3970 } 3971 PK11_FreeSymKey(symKey); 3972 return SECSuccess; 3973 3974 3975 loser: 3976 if (symKey) PK11_FreeSymKey(symKey); 3977 ssl_MapLowLevelError(SSL_ERROR_SESSION_KEY_GEN_FAILURE); 3978 return SECFailure; 3979 } 3980 3981 /* ssl3_InitHandshakeHashes creates handshake hash contexts and hashes in 3982 * buffered messages in ss->ssl3.hs.messages. */ 3983 static SECStatus 3984 ssl3_InitHandshakeHashes(sslSocket *ss) 3985 { 3986 SSL_TRC(30,("%d: SSL3[%d]: start handshake hashes", SSL_GETPID(), ss->fd)); 3987 3988 PORT_Assert(ss->ssl3.hs.hashType == handshake_hash_unknown); 3989 #ifndef NO_PKCS11_BYPASS 3990 if (ss->opt.bypassPKCS11) { 3991 PORT_Assert(!ss->ssl3.hs.sha_obj && !ss->ssl3.hs.sha_clone); 3992 if (ss->version >= SSL_LIBRARY_VERSION_TLS_1_2) { 3993 /* If we ever support ciphersuites where the PRF hash isn't SHA-256 3994 * then this will need to be updated. */ 3995 ss->ssl3.hs.sha_obj = HASH_GetRawHashObject(HASH_AlgSHA256); 3996 if (!ss->ssl3.hs.sha_obj) { 3997 ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE); 3998 return SECFailure; 3999 } 4000 ss->ssl3.hs.sha_clone = (void (*)(void *, void *))SHA256_Clone; 4001 ss->ssl3.hs.hashType = handshake_hash_single; 4002 ss->ssl3.hs.sha_obj->begin(ss->ssl3.hs.sha_cx); 4003 } else { 4004 ss->ssl3.hs.hashType = handshake_hash_combo; 4005 MD5_Begin((MD5Context *)ss->ssl3.hs.md5_cx); 4006 SHA1_Begin((SHA1Context *)ss->ssl3.hs.sha_cx); 4007 } 4008 } else 4009 #endif 4010 { 4011 PORT_Assert(!ss->ssl3.hs.md5 && !ss->ssl3.hs.sha); 4012 /* 4013 * note: We should probably lookup an SSL3 slot for these 4014 * handshake hashes in hopes that we wind up with the same slots 4015 * that the master secret will wind up in ... 4016 */ 4017 if (ss->version >= SSL_LIBRARY_VERSION_TLS_1_2) { 4018 /* If we ever support ciphersuites where the PRF hash isn't SHA-256 4019 * then this will need to be updated. */ 4020 ss->ssl3.hs.sha = PK11_CreateDigestContext(SEC_OID_SHA256); 4021 if (ss->ssl3.hs.sha == NULL) { 4022 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4023 return SECFailure; 4024 } 4025 ss->ssl3.hs.hashType = handshake_hash_single; 4026 4027 if (PK11_DigestBegin(ss->ssl3.hs.sha) != SECSuccess) { 4028 ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE); 4029 return SECFailure; 4030 } 4031 4032 /* Create a backup SHA-1 hash for a potential client auth 4033 * signature. 4034 * 4035 * In TLS 1.2, ssl3_ComputeHandshakeHashes always uses the 4036 * handshake hash function (SHA-256). If the server or the client 4037 * does not support SHA-256 as a signature hash, we can either 4038 * maintain a backup SHA-1 handshake hash or buffer all handshake 4039 * messages. 4040 */ 4041 if (!ss->sec.isServer) { 4042 ss->ssl3.hs.backupHash = PK11_CreateDigestContext(SEC_OID_SHA1); 4043 if (ss->ssl3.hs.backupHash == NULL) { 4044 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4045 return SECFailure; 4046 } 4047 4048 if (PK11_DigestBegin(ss->ssl3.hs.backupHash) != SECSuccess) { 4049 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4050 return SECFailure; 4051 } 4052 } 4053 } else { 4054 /* Both ss->ssl3.hs.md5 and ss->ssl3.hs.sha should be NULL or 4055 * created successfully. */ 4056 ss->ssl3.hs.md5 = PK11_CreateDigestContext(SEC_OID_MD5); 4057 if (ss->ssl3.hs.md5 == NULL) { 4058 ssl_MapLowLevelError(SSL_ERROR_MD5_DIGEST_FAILURE); 4059 return SECFailure; 4060 } 4061 ss->ssl3.hs.sha = PK11_CreateDigestContext(SEC_OID_SHA1); 4062 if (ss->ssl3.hs.sha == NULL) { 4063 PK11_DestroyContext(ss->ssl3.hs.md5, PR_TRUE); 4064 ss->ssl3.hs.md5 = NULL; 4065 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4066 return SECFailure; 4067 } 4068 ss->ssl3.hs.hashType = handshake_hash_combo; 4069 4070 if (PK11_DigestBegin(ss->ssl3.hs.md5) != SECSuccess) { 4071 ssl_MapLowLevelError(SSL_ERROR_MD5_DIGEST_FAILURE); 4072 return SECFailure; 4073 } 4074 if (PK11_DigestBegin(ss->ssl3.hs.sha) != SECSuccess) { 4075 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4076 return SECFailure; 4077 } 4078 } 4079 } 4080 4081 if (ss->ssl3.hs.messages.len > 0) { 4082 if (ssl3_UpdateHandshakeHashes(ss, ss->ssl3.hs.messages.buf, 4083 ss->ssl3.hs.messages.len) != 4084 SECSuccess) { 4085 return SECFailure; 4086 } 4087 PORT_Free(ss->ssl3.hs.messages.buf); 4088 ss->ssl3.hs.messages.buf = NULL; 4089 ss->ssl3.hs.messages.len = 0; 4090 ss->ssl3.hs.messages.space = 0; 4091 } 4092 4093 return SECSuccess; 4094 } 4095 4096 static SECStatus 4097 ssl3_RestartHandshakeHashes(sslSocket *ss) 4098 { 4099 SECStatus rv = SECSuccess; 4100 4101 SSL_TRC(30,("%d: SSL3[%d]: reset handshake hashes", 4102 SSL_GETPID(), ss->fd )); 4103 ss->ssl3.hs.hashType = handshake_hash_unknown; 4104 ss->ssl3.hs.messages.len = 0; 4105 #ifndef NO_PKCS11_BYPASS 4106 ss->ssl3.hs.sha_obj = NULL; 4107 ss->ssl3.hs.sha_clone = NULL; 4108 #endif 4109 if (ss->ssl3.hs.md5) { 4110 PK11_DestroyContext(ss->ssl3.hs.md5,PR_TRUE); 4111 ss->ssl3.hs.md5 = NULL; 4112 } 4113 if (ss->ssl3.hs.sha) { 4114 PK11_DestroyContext(ss->ssl3.hs.sha,PR_TRUE); 4115 ss->ssl3.hs.sha = NULL; 4116 } 4117 return rv; 4118 } 4119 4120 /* 4121 * Handshake messages 4122 */ 4123 /* Called from ssl3_InitHandshakeHashes() 4124 ** ssl3_AppendHandshake() 4125 ** ssl3_StartHandshakeHash() 4126 ** ssl3_HandleV2ClientHello() 4127 ** ssl3_HandleHandshakeMessage() 4128 ** Caller must hold the ssl3Handshake lock. 4129 */ 4130 static SECStatus 4131 ssl3_UpdateHandshakeHashes(sslSocket *ss, const unsigned char *b, 4132 unsigned int l) 4133 { 4134 SECStatus rv = SECSuccess; 4135 4136 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 4137 4138 /* We need to buffer the handshake messages until we have established 4139 * which handshake hash function to use. */ 4140 if (ss->ssl3.hs.hashType == handshake_hash_unknown) { 4141 return sslBuffer_Append(&ss->ssl3.hs.messages, b, l); 4142 } 4143 4144 PRINT_BUF(90, (NULL, "handshake hash input:", b, l)); 4145 4146 #ifndef NO_PKCS11_BYPASS 4147 if (ss->opt.bypassPKCS11) { 4148 if (ss->ssl3.hs.hashType == handshake_hash_single) { 4149 ss->ssl3.hs.sha_obj->update(ss->ssl3.hs.sha_cx, b, l); 4150 } else { 4151 MD5_Update((MD5Context *)ss->ssl3.hs.md5_cx, b, l); 4152 SHA1_Update((SHA1Context *)ss->ssl3.hs.sha_cx, b, l); 4153 } 4154 return rv; 4155 } 4156 #endif 4157 if (ss->ssl3.hs.hashType == handshake_hash_single) { 4158 rv = PK11_DigestOp(ss->ssl3.hs.sha, b, l); 4159 if (rv != SECSuccess) { 4160 ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE); 4161 return rv; 4162 } 4163 if (ss->ssl3.hs.backupHash) { 4164 rv = PK11_DigestOp(ss->ssl3.hs.backupHash, b, l); 4165 if (rv != SECSuccess) { 4166 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4167 return rv; 4168 } 4169 } 4170 } else { 4171 rv = PK11_DigestOp(ss->ssl3.hs.md5, b, l); 4172 if (rv != SECSuccess) { 4173 ssl_MapLowLevelError(SSL_ERROR_MD5_DIGEST_FAILURE); 4174 return rv; 4175 } 4176 rv = PK11_DigestOp(ss->ssl3.hs.sha, b, l); 4177 if (rv != SECSuccess) { 4178 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4179 return rv; 4180 } 4181 } 4182 return rv; 4183 } 4184 4185 /************************************************************************** 4186 * Append Handshake functions. 4187 * All these functions set appropriate error codes. 4188 * Most rely on ssl3_AppendHandshake to set the error code. 4189 **************************************************************************/ 4190 SECStatus 4191 ssl3_AppendHandshake(sslSocket *ss, const void *void_src, PRInt32 bytes) 4192 { 4193 unsigned char * src = (unsigned char *)void_src; 4194 int room = ss->sec.ci.sendBuf.space - ss->sec.ci.sendBuf.len; 4195 SECStatus rv; 4196 4197 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); /* protects sendBuf. */ 4198 4199 if (!bytes) 4200 return SECSuccess; 4201 if (ss->sec.ci.sendBuf.space < MAX_SEND_BUF_LENGTH && room < bytes) { 4202 rv = sslBuffer_Grow(&ss->sec.ci.sendBuf, PR_MAX(MIN_SEND_BUF_LENGTH, 4203 PR_MIN(MAX_SEND_BUF_LENGTH, ss->sec.ci.sendBuf.len + bytes))); 4204 if (rv != SECSuccess) 4205 return rv; /* sslBuffer_Grow has set a memory error code. */ 4206 room = ss->sec.ci.sendBuf.space - ss->sec.ci.sendBuf.len; 4207 } 4208 4209 PRINT_BUF(60, (ss, "Append to Handshake", (unsigned char*)void_src, bytes)); 4210 rv = ssl3_UpdateHandshakeHashes(ss, src, bytes); 4211 if (rv != SECSuccess) 4212 return rv; /* error code set by ssl3_UpdateHandshakeHashes */ 4213 4214 while (bytes > room) { 4215 if (room > 0) 4216 PORT_Memcpy(ss->sec.ci.sendBuf.buf + ss->sec.ci.sendBuf.len, src, 4217 room); 4218 ss->sec.ci.sendBuf.len += room; 4219 rv = ssl3_FlushHandshake(ss, ssl_SEND_FLAG_FORCE_INTO_BUFFER); 4220 if (rv != SECSuccess) { 4221 return rv; /* error code set by ssl3_FlushHandshake */ 4222 } 4223 bytes -= room; 4224 src += room; 4225 room = ss->sec.ci.sendBuf.space; 4226 PORT_Assert(ss->sec.ci.sendBuf.len == 0); 4227 } 4228 PORT_Memcpy(ss->sec.ci.sendBuf.buf + ss->sec.ci.sendBuf.len, src, bytes); 4229 ss->sec.ci.sendBuf.len += bytes; 4230 return SECSuccess; 4231 } 4232 4233 SECStatus 4234 ssl3_AppendHandshakeNumber(sslSocket *ss, PRInt32 num, PRInt32 lenSize) 4235 { 4236 SECStatus rv; 4237 PRUint8 b[4]; 4238 PRUint8 * p = b; 4239 4240 switch (lenSize) { 4241 case 4: 4242 *p++ = (num >> 24) & 0xff; 4243 case 3: 4244 *p++ = (num >> 16) & 0xff; 4245 case 2: 4246 *p++ = (num >> 8) & 0xff; 4247 case 1: 4248 *p = num & 0xff; 4249 } 4250 SSL_TRC(60, ("%d: number:", SSL_GETPID())); 4251 rv = ssl3_AppendHandshake(ss, &b[0], lenSize); 4252 return rv; /* error code set by AppendHandshake, if applicable. */ 4253 } 4254 4255 SECStatus 4256 ssl3_AppendHandshakeVariable( 4257 sslSocket *ss, const SSL3Opaque *src, PRInt32 bytes, PRInt32 lenSize) 4258 { 4259 SECStatus rv; 4260 4261 PORT_Assert((bytes < (1<<8) && lenSize == 1) || 4262 (bytes < (1L<<16) && lenSize == 2) || 4263 (bytes < (1L<<24) && lenSize == 3)); 4264 4265 SSL_TRC(60,("%d: append variable:", SSL_GETPID())); 4266 rv = ssl3_AppendHandshakeNumber(ss, bytes, lenSize); 4267 if (rv != SECSuccess) { 4268 return rv; /* error code set by AppendHandshake, if applicable. */ 4269 } 4270 SSL_TRC(60, ("data:")); 4271 rv = ssl3_AppendHandshake(ss, src, bytes); 4272 return rv; /* error code set by AppendHandshake, if applicable. */ 4273 } 4274 4275 SECStatus 4276 ssl3_AppendHandshakeHeader(sslSocket *ss, SSL3HandshakeType t, PRUint32 length) 4277 { 4278 SECStatus rv; 4279 4280 /* If we already have a message in place, we need to enqueue it. 4281 * This empties the buffer. This is a convenient place to call 4282 * dtls_StageHandshakeMessage to mark the message boundary. 4283 */ 4284 if (IS_DTLS(ss)) { 4285 rv = dtls_StageHandshakeMessage(ss); 4286 if (rv != SECSuccess) { 4287 return rv; 4288 } 4289 } 4290 4291 SSL_TRC(30,("%d: SSL3[%d]: append handshake header: type %s", 4292 SSL_GETPID(), ss->fd, ssl3_DecodeHandshakeType(t))); 4293 4294 rv = ssl3_AppendHandshakeNumber(ss, t, 1); 4295 if (rv != SECSuccess) { 4296 return rv; /* error code set by AppendHandshake, if applicable. */ 4297 } 4298 rv = ssl3_AppendHandshakeNumber(ss, length, 3); 4299 if (rv != SECSuccess) { 4300 return rv; /* error code set by AppendHandshake, if applicable. */ 4301 } 4302 4303 if (IS_DTLS(ss)) { 4304 /* Note that we make an unfragmented message here. We fragment in the 4305 * transmission code, if necessary */ 4306 rv = ssl3_AppendHandshakeNumber(ss, ss->ssl3.hs.sendMessageSeq, 2); 4307 if (rv != SECSuccess) { 4308 return rv; /* error code set by AppendHandshake, if applicable. */ 4309 } 4310 ss->ssl3.hs.sendMessageSeq++; 4311 4312 /* 0 is the fragment offset, because it's not fragmented yet */ 4313 rv = ssl3_AppendHandshakeNumber(ss, 0, 3); 4314 if (rv != SECSuccess) { 4315 return rv; /* error code set by AppendHandshake, if applicable. */ 4316 } 4317 4318 /* Fragment length -- set to the packet length because not fragmented */ 4319 rv = ssl3_AppendHandshakeNumber(ss, length, 3); 4320 if (rv != SECSuccess) { 4321 return rv; /* error code set by AppendHandshake, if applicable. */ 4322 } 4323 } 4324 4325 return rv; /* error code set by AppendHandshake, if applicable. */ 4326 } 4327 4328 /* ssl3_AppendSignatureAndHashAlgorithm appends the serialisation of 4329 * |sigAndHash| to the current handshake message. */ 4330 SECStatus 4331 ssl3_AppendSignatureAndHashAlgorithm( 4332 sslSocket *ss, const SSL3SignatureAndHashAlgorithm* sigAndHash) 4333 { 4334 unsigned char serialized[2]; 4335 4336 serialized[0] = ssl3_OIDToTLSHashAlgorithm(sigAndHash->hashAlg); 4337 if (serialized[0] == 0) { 4338 PORT_SetError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM); 4339 return SECFailure; 4340 } 4341 4342 serialized[1] = sigAndHash->sigAlg; 4343 4344 return ssl3_AppendHandshake(ss, serialized, sizeof(serialized)); 4345 } 4346 4347 /************************************************************************** 4348 * Consume Handshake functions. 4349 * 4350 * All data used in these functions is protected by two locks, 4351 * the RecvBufLock and the SSL3HandshakeLock 4352 **************************************************************************/ 4353 4354 /* Read up the next "bytes" number of bytes from the (decrypted) input 4355 * stream "b" (which is *length bytes long). Copy them into buffer "v". 4356 * Reduces *length by bytes. Advances *b by bytes. 4357 * 4358 * If this function returns SECFailure, it has already sent an alert, 4359 * and has set a generic error code. The caller should probably 4360 * override the generic error code by setting another. 4361 */ 4362 SECStatus 4363 ssl3_ConsumeHandshake(sslSocket *ss, void *v, PRInt32 bytes, SSL3Opaque **b, 4364 PRUint32 *length) 4365 { 4366 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 4367 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 4368 4369 if ((PRUint32)bytes > *length) { 4370 return ssl3_DecodeError(ss); 4371 } 4372 PORT_Memcpy(v, *b, bytes); 4373 PRINT_BUF(60, (ss, "consume bytes:", *b, bytes)); 4374 *b += bytes; 4375 *length -= bytes; 4376 return SECSuccess; 4377 } 4378 4379 /* Read up the next "bytes" number of bytes from the (decrypted) input 4380 * stream "b" (which is *length bytes long), and interpret them as an 4381 * integer in network byte order. Returns the received value. 4382 * Reduces *length by bytes. Advances *b by bytes. 4383 * 4384 * Returns SECFailure (-1) on failure. 4385 * This value is indistinguishable from the equivalent received value. 4386 * Only positive numbers are to be received this way. 4387 * Thus, the largest value that may be sent this way is 0x7fffffff. 4388 * On error, an alert has been sent, and a generic error code has been set. 4389 */ 4390 PRInt32 4391 ssl3_ConsumeHandshakeNumber(sslSocket *ss, PRInt32 bytes, SSL3Opaque **b, 4392 PRUint32 *length) 4393 { 4394 PRUint8 *buf = *b; 4395 int i; 4396 PRInt32 num = 0; 4397 4398 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 4399 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 4400 PORT_Assert( bytes <= sizeof num); 4401 4402 if ((PRUint32)bytes > *length) { 4403 return ssl3_DecodeError(ss); 4404 } 4405 PRINT_BUF(60, (ss, "consume bytes:", *b, bytes)); 4406 4407 for (i = 0; i < bytes; i++) 4408 num = (num << 8) + buf[i]; 4409 *b += bytes; 4410 *length -= bytes; 4411 return num; 4412 } 4413 4414 /* Read in two values from the incoming decrypted byte stream "b", which is 4415 * *length bytes long. The first value is a number whose size is "bytes" 4416 * bytes long. The second value is a byte-string whose size is the value 4417 * of the first number received. The latter byte-string, and its length, 4418 * is returned in the SECItem i. 4419 * 4420 * Returns SECFailure (-1) on failure. 4421 * On error, an alert has been sent, and a generic error code has been set. 4422 * 4423 * RADICAL CHANGE for NSS 3.11. All callers of this function make copies 4424 * of the data returned in the SECItem *i, so making a copy of it here 4425 * is simply wasteful. So, This function now just sets SECItem *i to 4426 * point to the values in the buffer **b. 4427 */ 4428 SECStatus 4429 ssl3_ConsumeHandshakeVariable(sslSocket *ss, SECItem *i, PRInt32 bytes, 4430 SSL3Opaque **b, PRUint32 *length) 4431 { 4432 PRInt32 count; 4433 4434 PORT_Assert(bytes <= 3); 4435 i->len = 0; 4436 i->data = NULL; 4437 count = ssl3_ConsumeHandshakeNumber(ss, bytes, b, length); 4438 if (count < 0) { /* Can't test for SECSuccess here. */ 4439 return SECFailure; 4440 } 4441 if (count > 0) { 4442 if ((PRUint32)count > *length) { 4443 return ssl3_DecodeError(ss); 4444 } 4445 i->data = *b; 4446 i->len = count; 4447 *b += count; 4448 *length -= count; 4449 } 4450 return SECSuccess; 4451 } 4452 4453 /* tlsHashOIDMap contains the mapping between TLS hash identifiers and the 4454 * SECOidTag used internally by NSS. */ 4455 static const struct { 4456 int tlsHash; 4457 SECOidTag oid; 4458 } tlsHashOIDMap[] = { 4459 { tls_hash_md5, SEC_OID_MD5 }, 4460 { tls_hash_sha1, SEC_OID_SHA1 }, 4461 { tls_hash_sha224, SEC_OID_SHA224 }, 4462 { tls_hash_sha256, SEC_OID_SHA256 }, 4463 { tls_hash_sha384, SEC_OID_SHA384 }, 4464 { tls_hash_sha512, SEC_OID_SHA512 } 4465 }; 4466 4467 /* ssl3_TLSHashAlgorithmToOID converts a TLS hash identifier into an OID value. 4468 * If the hash is not recognised, SEC_OID_UNKNOWN is returned. 4469 * 4470 * See https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1 */ 4471 SECOidTag 4472 ssl3_TLSHashAlgorithmToOID(int hashFunc) 4473 { 4474 unsigned int i; 4475 4476 for (i = 0; i < PR_ARRAY_SIZE(tlsHashOIDMap); i++) { 4477 if (hashFunc == tlsHashOIDMap[i].tlsHash) { 4478 return tlsHashOIDMap[i].oid; 4479 } 4480 } 4481 return SEC_OID_UNKNOWN; 4482 } 4483 4484 /* ssl3_OIDToTLSHashAlgorithm converts an OID to a TLS hash algorithm 4485 * identifier. If the hash is not recognised, zero is returned. 4486 * 4487 * See https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1 */ 4488 static int 4489 ssl3_OIDToTLSHashAlgorithm(SECOidTag oid) 4490 { 4491 unsigned int i; 4492 4493 for (i = 0; i < PR_ARRAY_SIZE(tlsHashOIDMap); i++) { 4494 if (oid == tlsHashOIDMap[i].oid) { 4495 return tlsHashOIDMap[i].tlsHash; 4496 } 4497 } 4498 return 0; 4499 } 4500 4501 /* ssl3_TLSSignatureAlgorithmForKeyType returns the TLS 1.2 signature algorithm 4502 * identifier for a given KeyType. */ 4503 static SECStatus 4504 ssl3_TLSSignatureAlgorithmForKeyType(KeyType keyType, 4505 TLSSignatureAlgorithm *out) 4506 { 4507 switch (keyType) { 4508 case rsaKey: 4509 *out = tls_sig_rsa; 4510 return SECSuccess; 4511 case dsaKey: 4512 *out = tls_sig_dsa; 4513 return SECSuccess; 4514 case ecKey: 4515 *out = tls_sig_ecdsa; 4516 return SECSuccess; 4517 default: 4518 PORT_SetError(SEC_ERROR_INVALID_KEY); 4519 return SECFailure; 4520 } 4521 } 4522 4523 /* ssl3_TLSSignatureAlgorithmForCertificate returns the TLS 1.2 signature 4524 * algorithm identifier for the given certificate. */ 4525 static SECStatus 4526 ssl3_TLSSignatureAlgorithmForCertificate(CERTCertificate *cert, 4527 TLSSignatureAlgorithm *out) 4528 { 4529 SECKEYPublicKey *key; 4530 KeyType keyType; 4531 4532 key = CERT_ExtractPublicKey(cert); 4533 if (key == NULL) { 4534 ssl_MapLowLevelError(SSL_ERROR_EXTRACT_PUBLIC_KEY_FAILURE); 4535 return SECFailure; 4536 } 4537 4538 keyType = key->keyType; 4539 SECKEY_DestroyPublicKey(key); 4540 return ssl3_TLSSignatureAlgorithmForKeyType(keyType, out); 4541 } 4542 4543 /* ssl3_CheckSignatureAndHashAlgorithmConsistency checks that the signature 4544 * algorithm identifier in |sigAndHash| is consistent with the public key in 4545 * |cert|. If so, SECSuccess is returned. Otherwise, PORT_SetError is called 4546 * and SECFailure is returned. */ 4547 SECStatus 4548 ssl3_CheckSignatureAndHashAlgorithmConsistency( 4549 const SSL3SignatureAndHashAlgorithm *sigAndHash, CERTCertificate* cert) 4550 { 4551 SECStatus rv; 4552 TLSSignatureAlgorithm sigAlg; 4553 4554 rv = ssl3_TLSSignatureAlgorithmForCertificate(cert, &sigAlg); 4555 if (rv != SECSuccess) { 4556 return rv; 4557 } 4558 if (sigAlg != sigAndHash->sigAlg) { 4559 PORT_SetError(SSL_ERROR_INCORRECT_SIGNATURE_ALGORITHM); 4560 return SECFailure; 4561 } 4562 return SECSuccess; 4563 } 4564 4565 /* ssl3_ConsumeSignatureAndHashAlgorithm reads a SignatureAndHashAlgorithm 4566 * structure from |b| and puts the resulting value into |out|. |b| and |length| 4567 * are updated accordingly. 4568 * 4569 * See https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1 */ 4570 SECStatus 4571 ssl3_ConsumeSignatureAndHashAlgorithm(sslSocket *ss, 4572 SSL3Opaque **b, 4573 PRUint32 *length, 4574 SSL3SignatureAndHashAlgorithm *out) 4575 { 4576 unsigned char bytes[2]; 4577 SECStatus rv; 4578 4579 rv = ssl3_ConsumeHandshake(ss, bytes, sizeof(bytes), b, length); 4580 if (rv != SECSuccess) { 4581 return rv; 4582 } 4583 4584 out->hashAlg = ssl3_TLSHashAlgorithmToOID(bytes[0]); 4585 if (out->hashAlg == SEC_OID_UNKNOWN) { 4586 PORT_SetError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM); 4587 return SECFailure; 4588 } 4589 4590 out->sigAlg = bytes[1]; 4591 return SECSuccess; 4592 } 4593 4594 /************************************************************************** 4595 * end of Consume Handshake functions. 4596 **************************************************************************/ 4597 4598 /* Extract the hashes of handshake messages to this point. 4599 * Called from ssl3_SendCertificateVerify 4600 * ssl3_SendFinished 4601 * ssl3_HandleHandshakeMessage 4602 * 4603 * Caller must hold the SSL3HandshakeLock. 4604 * Caller must hold a read or write lock on the Spec R/W lock. 4605 * (There is presently no way to assert on a Read lock.) 4606 */ 4607 static SECStatus 4608 ssl3_ComputeHandshakeHashes(sslSocket * ss, 4609 ssl3CipherSpec *spec, /* uses ->master_secret */ 4610 SSL3Hashes * hashes, /* output goes here. */ 4611 PRUint32 sender) 4612 { 4613 SECStatus rv = SECSuccess; 4614 PRBool isTLS = (PRBool)(spec->version > SSL_LIBRARY_VERSION_3_0); 4615 unsigned int outLength; 4616 SSL3Opaque md5_inner[MAX_MAC_LENGTH]; 4617 SSL3Opaque sha_inner[MAX_MAC_LENGTH]; 4618 4619 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 4620 hashes->hashAlg = SEC_OID_UNKNOWN; 4621 4622 #ifndef NO_PKCS11_BYPASS 4623 if (ss->opt.bypassPKCS11 && 4624 ss->ssl3.hs.hashType == handshake_hash_single) { 4625 /* compute them without PKCS11 */ 4626 PRUint64 sha_cx[MAX_MAC_CONTEXT_LLONGS]; 4627 4628 if (!spec->msItem.data) { 4629 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HANDSHAKE); 4630 return SECFailure; 4631 } 4632 4633 ss->ssl3.hs.sha_clone(sha_cx, ss->ssl3.hs.sha_cx); 4634 ss->ssl3.hs.sha_obj->end(sha_cx, hashes->u.raw, &hashes->len, 4635 sizeof(hashes->u.raw)); 4636 4637 PRINT_BUF(60, (NULL, "SHA-256: result", hashes->u.raw, hashes->len)); 4638 4639 /* If we ever support ciphersuites where the PRF hash isn't SHA-256 4640 * then this will need to be updated. */ 4641 hashes->hashAlg = SEC_OID_SHA256; 4642 rv = SECSuccess; 4643 } else if (ss->opt.bypassPKCS11) { 4644 /* compute them without PKCS11 */ 4645 PRUint64 md5_cx[MAX_MAC_CONTEXT_LLONGS]; 4646 PRUint64 sha_cx[MAX_MAC_CONTEXT_LLONGS]; 4647 4648 #define md5cx ((MD5Context *)md5_cx) 4649 #define shacx ((SHA1Context *)sha_cx) 4650 4651 if (!spec->msItem.data) { 4652 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HANDSHAKE); 4653 return SECFailure; 4654 } 4655 4656 MD5_Clone (md5cx, (MD5Context *)ss->ssl3.hs.md5_cx); 4657 SHA1_Clone(shacx, (SHA1Context *)ss->ssl3.hs.sha_cx); 4658 4659 if (!isTLS) { 4660 /* compute hashes for SSL3. */ 4661 unsigned char s[4]; 4662 4663 s[0] = (unsigned char)(sender >> 24); 4664 s[1] = (unsigned char)(sender >> 16); 4665 s[2] = (unsigned char)(sender >> 8); 4666 s[3] = (unsigned char)sender; 4667 4668 if (sender != 0) { 4669 MD5_Update(md5cx, s, 4); 4670 PRINT_BUF(95, (NULL, "MD5 inner: sender", s, 4)); 4671 } 4672 4673 PRINT_BUF(95, (NULL, "MD5 inner: MAC Pad 1", mac_pad_1, 4674 mac_defs[mac_md5].pad_size)); 4675 4676 MD5_Update(md5cx, spec->msItem.data, spec->msItem.len); 4677 MD5_Update(md5cx, mac_pad_1, mac_defs[mac_md5].pad_size); 4678 MD5_End(md5cx, md5_inner, &outLength, MD5_LENGTH); 4679 4680 PRINT_BUF(95, (NULL, "MD5 inner: result", md5_inner, outLength)); 4681 4682 if (sender != 0) { 4683 SHA1_Update(shacx, s, 4); 4684 PRINT_BUF(95, (NULL, "SHA inner: sender", s, 4)); 4685 } 4686 4687 PRINT_BUF(95, (NULL, "SHA inner: MAC Pad 1", mac_pad_1, 4688 mac_defs[mac_sha].pad_size)); 4689 4690 SHA1_Update(shacx, spec->msItem.data, spec->msItem.len); 4691 SHA1_Update(shacx, mac_pad_1, mac_defs[mac_sha].pad_size); 4692 SHA1_End(shacx, sha_inner, &outLength, SHA1_LENGTH); 4693 4694 PRINT_BUF(95, (NULL, "SHA inner: result", sha_inner, outLength)); 4695 PRINT_BUF(95, (NULL, "MD5 outer: MAC Pad 2", mac_pad_2, 4696 mac_defs[mac_md5].pad_size)); 4697 PRINT_BUF(95, (NULL, "MD5 outer: MD5 inner", md5_inner, MD5_LENGTH)); 4698 4699 MD5_Begin(md5cx); 4700 MD5_Update(md5cx, spec->msItem.data, spec->msItem.len); 4701 MD5_Update(md5cx, mac_pad_2, mac_defs[mac_md5].pad_size); 4702 MD5_Update(md5cx, md5_inner, MD5_LENGTH); 4703 } 4704 MD5_End(md5cx, hashes->u.s.md5, &outLength, MD5_LENGTH); 4705 4706 PRINT_BUF(60, (NULL, "MD5 outer: result", hashes->u.s.md5, MD5_LENGTH)); 4707 4708 if (!isTLS) { 4709 PRINT_BUF(95, (NULL, "SHA outer: MAC Pad 2", mac_pad_2, 4710 mac_defs[mac_sha].pad_size)); 4711 PRINT_BUF(95, (NULL, "SHA outer: SHA inner", sha_inner, SHA1_LENGTH)); 4712 4713 SHA1_Begin(shacx); 4714 SHA1_Update(shacx, spec->msItem.data, spec->msItem.len); 4715 SHA1_Update(shacx, mac_pad_2, mac_defs[mac_sha].pad_size); 4716 SHA1_Update(shacx, sha_inner, SHA1_LENGTH); 4717 } 4718 SHA1_End(shacx, hashes->u.s.sha, &outLength, SHA1_LENGTH); 4719 4720 PRINT_BUF(60, (NULL, "SHA outer: result", hashes->u.s.sha, SHA1_LENGTH)); 4721 4722 hashes->len = MD5_LENGTH + SHA1_LENGTH; 4723 rv = SECSuccess; 4724 #undef md5cx 4725 #undef shacx 4726 } else 4727 #endif 4728 if (ss->ssl3.hs.hashType == handshake_hash_single) { 4729 /* compute hashes with PKCS11 */ 4730 PK11Context *h; 4731 unsigned int stateLen; 4732 unsigned char stackBuf[1024]; 4733 unsigned char *stateBuf = NULL; 4734 4735 if (!spec->master_secret) { 4736 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HANDSHAKE); 4737 return SECFailure; 4738 } 4739 4740 h = ss->ssl3.hs.sha; 4741 stateBuf = PK11_SaveContextAlloc(h, stackBuf, 4742 sizeof(stackBuf), &stateLen); 4743 if (stateBuf == NULL) { 4744 ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE); 4745 goto tls12_loser; 4746 } 4747 rv |= PK11_DigestFinal(h, hashes->u.raw, &hashes->len, 4748 sizeof(hashes->u.raw)); 4749 if (rv != SECSuccess) { 4750 ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE); 4751 rv = SECFailure; 4752 goto tls12_loser; 4753 } 4754 /* If we ever support ciphersuites where the PRF hash isn't SHA-256 4755 * then this will need to be updated. */ 4756 hashes->hashAlg = SEC_OID_SHA256; 4757 rv = SECSuccess; 4758 4759 tls12_loser: 4760 if (stateBuf) { 4761 if (PK11_RestoreContext(h, stateBuf, stateLen) != SECSuccess) { 4762 ssl_MapLowLevelError(SSL_ERROR_DIGEST_FAILURE); 4763 rv = SECFailure; 4764 } 4765 if (stateBuf != stackBuf) { 4766 PORT_ZFree(stateBuf, stateLen); 4767 } 4768 } 4769 } else { 4770 /* compute hashes with PKCS11 */ 4771 PK11Context * md5; 4772 PK11Context * sha = NULL; 4773 unsigned char *md5StateBuf = NULL; 4774 unsigned char *shaStateBuf = NULL; 4775 unsigned int md5StateLen, shaStateLen; 4776 unsigned char md5StackBuf[256]; 4777 unsigned char shaStackBuf[512]; 4778 4779 if (!spec->master_secret) { 4780 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HANDSHAKE); 4781 return SECFailure; 4782 } 4783 4784 md5StateBuf = PK11_SaveContextAlloc(ss->ssl3.hs.md5, md5StackBuf, 4785 sizeof md5StackBuf, &md5StateLen); 4786 if (md5StateBuf == NULL) { 4787 ssl_MapLowLevelError(SSL_ERROR_MD5_DIGEST_FAILURE); 4788 goto loser; 4789 } 4790 md5 = ss->ssl3.hs.md5; 4791 4792 shaStateBuf = PK11_SaveContextAlloc(ss->ssl3.hs.sha, shaStackBuf, 4793 sizeof shaStackBuf, &shaStateLen); 4794 if (shaStateBuf == NULL) { 4795 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4796 goto loser; 4797 } 4798 sha = ss->ssl3.hs.sha; 4799 4800 if (!isTLS) { 4801 /* compute hashes for SSL3. */ 4802 unsigned char s[4]; 4803 4804 s[0] = (unsigned char)(sender >> 24); 4805 s[1] = (unsigned char)(sender >> 16); 4806 s[2] = (unsigned char)(sender >> 8); 4807 s[3] = (unsigned char)sender; 4808 4809 if (sender != 0) { 4810 rv |= PK11_DigestOp(md5, s, 4); 4811 PRINT_BUF(95, (NULL, "MD5 inner: sender", s, 4)); 4812 } 4813 4814 PRINT_BUF(95, (NULL, "MD5 inner: MAC Pad 1", mac_pad_1, 4815 mac_defs[mac_md5].pad_size)); 4816 4817 rv |= PK11_DigestKey(md5,spec->master_secret); 4818 rv |= PK11_DigestOp(md5, mac_pad_1, mac_defs[mac_md5].pad_size); 4819 rv |= PK11_DigestFinal(md5, md5_inner, &outLength, MD5_LENGTH); 4820 PORT_Assert(rv != SECSuccess || outLength == MD5_LENGTH); 4821 if (rv != SECSuccess) { 4822 ssl_MapLowLevelError(SSL_ERROR_MD5_DIGEST_FAILURE); 4823 rv = SECFailure; 4824 goto loser; 4825 } 4826 4827 PRINT_BUF(95, (NULL, "MD5 inner: result", md5_inner, outLength)); 4828 4829 if (sender != 0) { 4830 rv |= PK11_DigestOp(sha, s, 4); 4831 PRINT_BUF(95, (NULL, "SHA inner: sender", s, 4)); 4832 } 4833 4834 PRINT_BUF(95, (NULL, "SHA inner: MAC Pad 1", mac_pad_1, 4835 mac_defs[mac_sha].pad_size)); 4836 4837 rv |= PK11_DigestKey(sha, spec->master_secret); 4838 rv |= PK11_DigestOp(sha, mac_pad_1, mac_defs[mac_sha].pad_size); 4839 rv |= PK11_DigestFinal(sha, sha_inner, &outLength, SHA1_LENGTH); 4840 PORT_Assert(rv != SECSuccess || outLength == SHA1_LENGTH); 4841 if (rv != SECSuccess) { 4842 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4843 rv = SECFailure; 4844 goto loser; 4845 } 4846 4847 PRINT_BUF(95, (NULL, "SHA inner: result", sha_inner, outLength)); 4848 4849 PRINT_BUF(95, (NULL, "MD5 outer: MAC Pad 2", mac_pad_2, 4850 mac_defs[mac_md5].pad_size)); 4851 PRINT_BUF(95, (NULL, "MD5 outer: MD5 inner", md5_inner, MD5_LENGTH)); 4852 4853 rv |= PK11_DigestBegin(md5); 4854 rv |= PK11_DigestKey(md5, spec->master_secret); 4855 rv |= PK11_DigestOp(md5, mac_pad_2, mac_defs[mac_md5].pad_size); 4856 rv |= PK11_DigestOp(md5, md5_inner, MD5_LENGTH); 4857 } 4858 rv |= PK11_DigestFinal(md5, hashes->u.s.md5, &outLength, MD5_LENGTH); 4859 PORT_Assert(rv != SECSuccess || outLength == MD5_LENGTH); 4860 if (rv != SECSuccess) { 4861 ssl_MapLowLevelError(SSL_ERROR_MD5_DIGEST_FAILURE); 4862 rv = SECFailure; 4863 goto loser; 4864 } 4865 4866 PRINT_BUF(60, (NULL, "MD5 outer: result", hashes->u.s.md5, MD5_LENGTH)); 4867 4868 if (!isTLS) { 4869 PRINT_BUF(95, (NULL, "SHA outer: MAC Pad 2", mac_pad_2, 4870 mac_defs[mac_sha].pad_size)); 4871 PRINT_BUF(95, (NULL, "SHA outer: SHA inner", sha_inner, SHA1_LENGTH)); 4872 4873 rv |= PK11_DigestBegin(sha); 4874 rv |= PK11_DigestKey(sha,spec->master_secret); 4875 rv |= PK11_DigestOp(sha, mac_pad_2, mac_defs[mac_sha].pad_size); 4876 rv |= PK11_DigestOp(sha, sha_inner, SHA1_LENGTH); 4877 } 4878 rv |= PK11_DigestFinal(sha, hashes->u.s.sha, &outLength, SHA1_LENGTH); 4879 PORT_Assert(rv != SECSuccess || outLength == SHA1_LENGTH); 4880 if (rv != SECSuccess) { 4881 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4882 rv = SECFailure; 4883 goto loser; 4884 } 4885 4886 PRINT_BUF(60, (NULL, "SHA outer: result", hashes->u.s.sha, SHA1_LENGTH)); 4887 4888 hashes->len = MD5_LENGTH + SHA1_LENGTH; 4889 rv = SECSuccess; 4890 4891 loser: 4892 if (md5StateBuf) { 4893 if (PK11_RestoreContext(ss->ssl3.hs.md5, md5StateBuf, md5StateLen) 4894 != SECSuccess) 4895 { 4896 ssl_MapLowLevelError(SSL_ERROR_MD5_DIGEST_FAILURE); 4897 rv = SECFailure; 4898 } 4899 if (md5StateBuf != md5StackBuf) { 4900 PORT_ZFree(md5StateBuf, md5StateLen); 4901 } 4902 } 4903 if (shaStateBuf) { 4904 if (PK11_RestoreContext(ss->ssl3.hs.sha, shaStateBuf, shaStateLen) 4905 != SECSuccess) 4906 { 4907 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4908 rv = SECFailure; 4909 } 4910 if (shaStateBuf != shaStackBuf) { 4911 PORT_ZFree(shaStateBuf, shaStateLen); 4912 } 4913 } 4914 } 4915 return rv; 4916 } 4917 4918 static SECStatus 4919 ssl3_ComputeBackupHandshakeHashes(sslSocket * ss, 4920 SSL3Hashes * hashes) /* output goes here. */ 4921 { 4922 SECStatus rv = SECSuccess; 4923 4924 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 4925 PORT_Assert( !ss->sec.isServer ); 4926 PORT_Assert( ss->ssl3.hs.hashType == handshake_hash_single ); 4927 4928 rv = PK11_DigestFinal(ss->ssl3.hs.backupHash, hashes->u.raw, &hashes->len, 4929 sizeof(hashes->u.raw)); 4930 if (rv != SECSuccess) { 4931 ssl_MapLowLevelError(SSL_ERROR_SHA_DIGEST_FAILURE); 4932 rv = SECFailure; 4933 goto loser; 4934 } 4935 hashes->hashAlg = SEC_OID_SHA1; 4936 4937 loser: 4938 PK11_DestroyContext(ss->ssl3.hs.backupHash, PR_TRUE); 4939 ss->ssl3.hs.backupHash = NULL; 4940 return rv; 4941 } 4942 4943 /* 4944 * SSL 2 based implementations pass in the initial outbound buffer 4945 * so that the handshake hash can contain the included information. 4946 * 4947 * Called from ssl2_BeginClientHandshake() in sslcon.c 4948 */ 4949 SECStatus 4950 ssl3_StartHandshakeHash(sslSocket *ss, unsigned char * buf, int length) 4951 { 4952 SECStatus rv; 4953 4954 ssl_GetSSL3HandshakeLock(ss); /**************************************/ 4955 4956 rv = ssl3_InitState(ss); 4957 if (rv != SECSuccess) { 4958 goto done; /* ssl3_InitState has set the error code. */ 4959 } 4960 rv = ssl3_RestartHandshakeHashes(ss); 4961 if (rv != SECSuccess) { 4962 goto done; 4963 } 4964 4965 PORT_Memset(&ss->ssl3.hs.client_random, 0, SSL3_RANDOM_LENGTH); 4966 PORT_Memcpy( 4967 &ss->ssl3.hs.client_random.rand[SSL3_RANDOM_LENGTH - SSL_CHALLENGE_BYTES], 4968 &ss->sec.ci.clientChallenge, 4969 SSL_CHALLENGE_BYTES); 4970 4971 rv = ssl3_UpdateHandshakeHashes(ss, buf, length); 4972 /* if it failed, ssl3_UpdateHandshakeHashes has set the error code. */ 4973 4974 done: 4975 ssl_ReleaseSSL3HandshakeLock(ss); /**************************************/ 4976 return rv; 4977 } 4978 4979 /************************************************************************** 4980 * end of Handshake Hash functions. 4981 * Begin Send and Handle functions for handshakes. 4982 **************************************************************************/ 4983 4984 /* Called from ssl3_HandleHelloRequest(), 4985 * ssl3_RedoHandshake() 4986 * ssl2_BeginClientHandshake (when resuming ssl3 session) 4987 * dtls_HandleHelloVerifyRequest(with resending=PR_TRUE) 4988 */ 4989 SECStatus 4990 ssl3_SendClientHello(sslSocket *ss, PRBool resending) 4991 { 4992 sslSessionID * sid; 4993 ssl3CipherSpec * cwSpec; 4994 SECStatus rv; 4995 int i; 4996 int length; 4997 int num_suites; 4998 int actual_count = 0; 4999 PRBool isTLS = PR_FALSE; 5000 PRBool requestingResume = PR_FALSE, fallbackSCSV = PR_FALSE; 5001 PRInt32 total_exten_len = 0; 5002 unsigned paddingExtensionLen; 5003 unsigned numCompressionMethods; 5004 PRInt32 flags; 5005 5006 SSL_TRC(3, ("%d: SSL3[%d]: send client_hello handshake", SSL_GETPID(), 5007 ss->fd)); 5008 5009 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 5010 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss) ); 5011 5012 rv = ssl3_InitState(ss); 5013 if (rv != SECSuccess) { 5014 return rv; /* ssl3_InitState has set the error code. */ 5015 } 5016 ss->ssl3.hs.sendingSCSV = PR_FALSE; /* Must be reset every handshake */ 5017 PORT_Assert(IS_DTLS(ss) || !resending); 5018 5019 SECITEM_FreeItem(&ss->ssl3.hs.newSessionTicket.ticket, PR_FALSE); 5020 ss->ssl3.hs.receivedNewSessionTicket = PR_FALSE; 5021 5022 /* We might be starting a session renegotiation in which case we should 5023 * clear previous state. 5024 */ 5025 PORT_Memset(&ss->xtnData, 0, sizeof(TLSExtensionData)); 5026 5027 rv = ssl3_RestartHandshakeHashes(ss); 5028 if (rv != SECSuccess) { 5029 return rv; 5030 } 5031 5032 /* 5033 * During a renegotiation, ss->clientHelloVersion will be used again to 5034 * work around a Windows SChannel bug. Ensure that it is still enabled. 5035 */ 5036 if (ss->firstHsDone) { 5037 if (SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) { 5038 PORT_SetError(SSL_ERROR_SSL_DISABLED); 5039 return SECFailure; 5040 } 5041 5042 if (ss->clientHelloVersion < ss->vrange.min || 5043 ss->clientHelloVersion > ss->vrange.max) { 5044 PORT_SetError(SSL_ERROR_NO_CYPHER_OVERLAP); 5045 return SECFailure; 5046 } 5047 } 5048 5049 /* We ignore ss->sec.ci.sid here, and use ssl_Lookup because Lookup 5050 * handles expired entries and other details. 5051 * XXX If we've been called from ssl2_BeginClientHandshake, then 5052 * this lookup is duplicative and wasteful. 5053 */ 5054 sid = (ss->opt.noCache) ? NULL 5055 : ssl_LookupSID(&ss->sec.ci.peer, ss->sec.ci.port, ss->peerID, ss->url); 5056 5057 /* We can't resume based on a different token. If the sid exists, 5058 * make sure the token that holds the master secret still exists ... 5059 * If we previously did client-auth, make sure that the token that holds 5060 * the private key still exists, is logged in, hasn't been removed, etc. 5061 */ 5062 if (sid) { 5063 PRBool sidOK = PR_TRUE; 5064 if (sid->u.ssl3.keys.msIsWrapped) { 5065 /* Session key was wrapped, which means it was using PKCS11, */ 5066 PK11SlotInfo *slot = NULL; 5067 if (sid->u.ssl3.masterValid && !ss->opt.bypassPKCS11) { 5068 slot = SECMOD_LookupSlot(sid->u.ssl3.masterModuleID, 5069 sid->u.ssl3.masterSlotID); 5070 } 5071 if (slot == NULL) { 5072 sidOK = PR_FALSE; 5073 } else { 5074 PK11SymKey *wrapKey = NULL; 5075 if (!PK11_IsPresent(slot) || 5076 ((wrapKey = PK11_GetWrapKey(slot, 5077 sid->u.ssl3.masterWrapIndex, 5078 sid->u.ssl3.masterWrapMech, 5079 sid->u.ssl3.masterWrapSeries, 5080 ss->pkcs11PinArg)) == NULL) ) { 5081 sidOK = PR_FALSE; 5082 } 5083 if (wrapKey) PK11_FreeSymKey(wrapKey); 5084 PK11_FreeSlot(slot); 5085 slot = NULL; 5086 } 5087 } 5088 /* If we previously did client-auth, make sure that the token that 5089 ** holds the private key still exists, is logged in, hasn't been 5090 ** removed, etc. 5091 */ 5092 if (sidOK && !ssl3_ClientAuthTokenPresent(sid)) { 5093 sidOK = PR_FALSE; 5094 } 5095 5096 /* TLS 1.0 (RFC 2246) Appendix E says: 5097 * Whenever a client already knows the highest protocol known to 5098 * a server (for example, when resuming a session), it should 5099 * initiate the connection in that native protocol. 5100 * So we pass sid->version to ssl3_NegotiateVersion() here, except 5101 * when renegotiating. 5102 * 5103 * Windows SChannel compares the client_version inside the RSA 5104 * EncryptedPreMasterSecret of a renegotiation with the 5105 * client_version of the initial ClientHello rather than the 5106 * ClientHello in the renegotiation. To work around this bug, we 5107 * continue to use the client_version used in the initial 5108 * ClientHello when renegotiating. 5109 */ 5110 if (sidOK) { 5111 if (ss->firstHsDone) { 5112 /* 5113 * The client_version of the initial ClientHello is still 5114 * available in ss->clientHelloVersion. Ensure that 5115 * sid->version is bounded within 5116 * [ss->vrange.min, ss->clientHelloVersion], otherwise we 5117 * can't use sid. 5118 */ 5119 if (sid->version >= ss->vrange.min && 5120 sid->version <= ss->clientHelloVersion) { 5121 ss->version = ss->clientHelloVersion; 5122 } else { 5123 sidOK = PR_FALSE; 5124 } 5125 } else { 5126 if (ssl3_NegotiateVersion(ss, sid->version, 5127 PR_FALSE) != SECSuccess) { 5128 sidOK = PR_FALSE; 5129 } 5130 } 5131 } 5132 5133 if (!sidOK) { 5134 SSL_AtomicIncrementLong(& ssl3stats.sch_sid_cache_not_ok ); 5135 if (ss->sec.uncache) 5136 (*ss->sec.uncache)(sid); 5137 ssl_FreeSID(sid); 5138 sid = NULL; 5139 } 5140 } 5141 5142 if (sid) { 5143 requestingResume = PR_TRUE; 5144 SSL_AtomicIncrementLong(& ssl3stats.sch_sid_cache_hits ); 5145 5146 PRINT_BUF(4, (ss, "client, found session-id:", sid->u.ssl3.sessionID, 5147 sid->u.ssl3.sessionIDLength)); 5148 5149 ss->ssl3.policy = sid->u.ssl3.policy; 5150 } else { 5151 SSL_AtomicIncrementLong(& ssl3stats.sch_sid_cache_misses ); 5152 5153 /* 5154 * Windows SChannel compares the client_version inside the RSA 5155 * EncryptedPreMasterSecret of a renegotiation with the 5156 * client_version of the initial ClientHello rather than the 5157 * ClientHello in the renegotiation. To work around this bug, we 5158 * continue to use the client_version used in the initial 5159 * ClientHello when renegotiating. 5160 */ 5161 if (ss->firstHsDone) { 5162 ss->version = ss->clientHelloVersion; 5163 } else { 5164 rv = ssl3_NegotiateVersion(ss, SSL_LIBRARY_VERSION_MAX_SUPPORTED, 5165 PR_TRUE); 5166 if (rv != SECSuccess) 5167 return rv; /* error code was set */ 5168 } 5169 5170 sid = ssl3_NewSessionID(ss, PR_FALSE); 5171 if (!sid) { 5172 return SECFailure; /* memory error is set */ 5173 } 5174 } 5175 5176 isTLS = (ss->version > SSL_LIBRARY_VERSION_3_0); 5177 ssl_GetSpecWriteLock(ss); 5178 cwSpec = ss->ssl3.cwSpec; 5179 if (cwSpec->mac_def->mac == mac_null) { 5180 /* SSL records are not being MACed. */ 5181 cwSpec->version = ss->version; 5182 } 5183 ssl_ReleaseSpecWriteLock(ss); 5184 5185 if (ss->sec.ci.sid != NULL) { 5186 ssl_FreeSID(ss->sec.ci.sid); /* decrement ref count, free if zero */ 5187 } 5188 ss->sec.ci.sid = sid; 5189 5190 ss->sec.send = ssl3_SendApplicationData; 5191 5192 /* shouldn't get here if SSL3 is disabled, but ... */ 5193 if (SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) { 5194 PR_NOT_REACHED("No versions of SSL 3.0 or later are enabled"); 5195 PORT_SetError(SSL_ERROR_SSL_DISABLED); 5196 return SECFailure; 5197 } 5198 5199 /* how many suites does our PKCS11 support (regardless of policy)? */ 5200 num_suites = ssl3_config_match_init(ss); 5201 if (!num_suites) 5202 return SECFailure; /* ssl3_config_match_init has set error code. */ 5203 5204 /* HACK for SCSV in SSL 3.0. On initial handshake, prepend SCSV, 5205 * only if TLS is disabled. 5206 */ 5207 if (!ss->firstHsDone && !isTLS) { 5208 /* Must set this before calling Hello Extension Senders, 5209 * to suppress sending of empty RI extension. 5210 */ 5211 ss->ssl3.hs.sendingSCSV = PR_TRUE; 5212 } 5213 5214 /* When we attempt session resumption (only), we must lock the sid to 5215 * prevent races with other resumption connections that receive a 5216 * NewSessionTicket that will cause the ticket in the sid to be replaced. 5217 * Once we've copied the session ticket into our ClientHello message, it 5218 * is OK for the ticket to change, so we just need to make sure we hold 5219 * the lock across the calls to ssl3_CallHelloExtensionSenders. 5220 */ 5221 if (sid->u.ssl3.lock) { 5222 NSSRWLock_LockRead(sid->u.ssl3.lock); 5223 } 5224 5225 if (isTLS || (ss->firstHsDone && ss->peerRequestedProtection)) { 5226 PRUint32 maxBytes = 65535; /* 2^16 - 1 */ 5227 PRInt32 extLen; 5228 5229 extLen = ssl3_CallHelloExtensionSenders(ss, PR_FALSE, maxBytes, NULL); 5230 if (extLen < 0) { 5231 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5232 return SECFailure; 5233 } 5234 maxBytes -= extLen; 5235 total_exten_len += extLen; 5236 5237 if (total_exten_len > 0) 5238 total_exten_len += 2; 5239 } 5240 5241 #if defined(NSS_ENABLE_ECC) 5242 if (!total_exten_len || !isTLS) { 5243 /* not sending the elliptic_curves and ec_point_formats extensions */ 5244 ssl3_DisableECCSuites(ss, NULL); /* disable all ECC suites */ 5245 } 5246 #endif 5247 5248 if (IS_DTLS(ss)) { 5249 ssl3_DisableNonDTLSSuites(ss); 5250 } 5251 5252 if (!ssl3_HasGCMSupport()) { 5253 ssl3_DisableGCMSuites(ss); 5254 } 5255 5256 /* how many suites are permitted by policy and user preference? */ 5257 num_suites = count_cipher_suites(ss, ss->ssl3.policy, PR_TRUE); 5258 if (!num_suites) { 5259 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5260 return SECFailure; /* count_cipher_suites has set error code. */ 5261 } 5262 5263 fallbackSCSV = ss->opt.enableFallbackSCSV && (!requestingResume || 5264 ss->version < sid->version); 5265 /* make room for SCSV */ 5266 if (ss->ssl3.hs.sendingSCSV) { 5267 ++num_suites; 5268 } 5269 if (fallbackSCSV) { 5270 ++num_suites; 5271 } 5272 5273 /* count compression methods */ 5274 numCompressionMethods = 0; 5275 for (i = 0; i < compressionMethodsCount; i++) { 5276 if (compressionEnabled(ss, compressions[i])) 5277 numCompressionMethods++; 5278 } 5279 5280 length = sizeof(SSL3ProtocolVersion) + SSL3_RANDOM_LENGTH + 5281 1 + ((sid == NULL) ? 0 : sid->u.ssl3.sessionIDLength) + 5282 2 + num_suites*sizeof(ssl3CipherSuite) + 5283 1 + numCompressionMethods + total_exten_len; 5284 if (IS_DTLS(ss)) { 5285 length += 1 + ss->ssl3.hs.cookieLen; 5286 } 5287 5288 /* A padding extension may be included to ensure that the record containing 5289 * the ClientHello doesn't have a length between 256 and 511 bytes 5290 * (inclusive). Initial, ClientHello records with such lengths trigger bugs 5291 * in F5 devices. 5292 * 5293 * This is not done for DTLS nor for renegotiation. */ 5294 if (!IS_DTLS(ss) && isTLS && !ss->firstHsDone) { 5295 paddingExtensionLen = ssl3_CalculatePaddingExtensionLength(length); 5296 total_exten_len += paddingExtensionLen; 5297 length += paddingExtensionLen; 5298 } else { 5299 paddingExtensionLen = 0; 5300 } 5301 5302 rv = ssl3_AppendHandshakeHeader(ss, client_hello, length); 5303 if (rv != SECSuccess) { 5304 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5305 return rv; /* err set by ssl3_AppendHandshake* */ 5306 } 5307 5308 if (ss->firstHsDone) { 5309 /* The client hello version must stay unchanged to work around 5310 * the Windows SChannel bug described above. */ 5311 PORT_Assert(ss->version == ss->clientHelloVersion); 5312 } 5313 ss->clientHelloVersion = ss->version; 5314 if (IS_DTLS(ss)) { 5315 PRUint16 version; 5316 5317 version = dtls_TLSVersionToDTLSVersion(ss->clientHelloVersion); 5318 rv = ssl3_AppendHandshakeNumber(ss, version, 2); 5319 } else { 5320 rv = ssl3_AppendHandshakeNumber(ss, ss->clientHelloVersion, 2); 5321 } 5322 if (rv != SECSuccess) { 5323 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5324 return rv; /* err set by ssl3_AppendHandshake* */ 5325 } 5326 5327 if (!resending) { /* Don't re-generate if we are in DTLS re-sending mode */ 5328 rv = ssl3_GetNewRandom(&ss->ssl3.hs.client_random); 5329 if (rv != SECSuccess) { 5330 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5331 return rv; /* err set by GetNewRandom. */ 5332 } 5333 } 5334 rv = ssl3_AppendHandshake(ss, &ss->ssl3.hs.client_random, 5335 SSL3_RANDOM_LENGTH); 5336 if (rv != SECSuccess) { 5337 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5338 return rv; /* err set by ssl3_AppendHandshake* */ 5339 } 5340 5341 if (sid) 5342 rv = ssl3_AppendHandshakeVariable( 5343 ss, sid->u.ssl3.sessionID, sid->u.ssl3.sessionIDLength, 1); 5344 else 5345 rv = ssl3_AppendHandshakeVariable(ss, NULL, 0, 1); 5346 if (rv != SECSuccess) { 5347 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5348 return rv; /* err set by ssl3_AppendHandshake* */ 5349 } 5350 5351 if (IS_DTLS(ss)) { 5352 rv = ssl3_AppendHandshakeVariable( 5353 ss, ss->ssl3.hs.cookie, ss->ssl3.hs.cookieLen, 1); 5354 if (rv != SECSuccess) { 5355 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5356 return rv; /* err set by ssl3_AppendHandshake* */ 5357 } 5358 } 5359 5360 rv = ssl3_AppendHandshakeNumber(ss, num_suites*sizeof(ssl3CipherSuite), 2); 5361 if (rv != SECSuccess) { 5362 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5363 return rv; /* err set by ssl3_AppendHandshake* */ 5364 } 5365 5366 if (ss->ssl3.hs.sendingSCSV) { 5367 /* Add the actual SCSV */ 5368 rv = ssl3_AppendHandshakeNumber(ss, TLS_EMPTY_RENEGOTIATION_INFO_SCSV, 5369 sizeof(ssl3CipherSuite)); 5370 if (rv != SECSuccess) { 5371 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5372 return rv; /* err set by ssl3_AppendHandshake* */ 5373 } 5374 actual_count++; 5375 } 5376 if (fallbackSCSV) { 5377 rv = ssl3_AppendHandshakeNumber(ss, TLS_FALLBACK_SCSV, 5378 sizeof(ssl3CipherSuite)); 5379 if (rv != SECSuccess) { 5380 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5381 return rv; /* err set by ssl3_AppendHandshake* */ 5382 } 5383 actual_count++; 5384 } 5385 for (i = 0; i < ssl_V3_SUITES_IMPLEMENTED; i++) { 5386 ssl3CipherSuiteCfg *suite = &ss->cipherSuites[i]; 5387 if (config_match(suite, ss->ssl3.policy, PR_TRUE, &ss->vrange)) { 5388 actual_count++; 5389 if (actual_count > num_suites) { 5390 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5391 /* set error card removal/insertion error */ 5392 PORT_SetError(SSL_ERROR_TOKEN_INSERTION_REMOVAL); 5393 return SECFailure; 5394 } 5395 rv = ssl3_AppendHandshakeNumber(ss, suite->cipher_suite, 5396 sizeof(ssl3CipherSuite)); 5397 if (rv != SECSuccess) { 5398 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5399 return rv; /* err set by ssl3_AppendHandshake* */ 5400 } 5401 } 5402 } 5403 5404 /* if cards were removed or inserted between count_cipher_suites and 5405 * generating our list, detect the error here rather than send it off to 5406 * the server.. */ 5407 if (actual_count != num_suites) { 5408 /* Card removal/insertion error */ 5409 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5410 PORT_SetError(SSL_ERROR_TOKEN_INSERTION_REMOVAL); 5411 return SECFailure; 5412 } 5413 5414 rv = ssl3_AppendHandshakeNumber(ss, numCompressionMethods, 1); 5415 if (rv != SECSuccess) { 5416 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5417 return rv; /* err set by ssl3_AppendHandshake* */ 5418 } 5419 for (i = 0; i < compressionMethodsCount; i++) { 5420 if (!compressionEnabled(ss, compressions[i])) 5421 continue; 5422 rv = ssl3_AppendHandshakeNumber(ss, compressions[i], 1); 5423 if (rv != SECSuccess) { 5424 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5425 return rv; /* err set by ssl3_AppendHandshake* */ 5426 } 5427 } 5428 5429 if (total_exten_len) { 5430 PRUint32 maxBytes = total_exten_len - 2; 5431 PRInt32 extLen; 5432 5433 rv = ssl3_AppendHandshakeNumber(ss, maxBytes, 2); 5434 if (rv != SECSuccess) { 5435 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5436 return rv; /* err set by AppendHandshake. */ 5437 } 5438 5439 extLen = ssl3_CallHelloExtensionSenders(ss, PR_TRUE, maxBytes, NULL); 5440 if (extLen < 0) { 5441 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5442 return SECFailure; 5443 } 5444 maxBytes -= extLen; 5445 5446 extLen = ssl3_AppendPaddingExtension(ss, paddingExtensionLen, maxBytes); 5447 if (extLen < 0) { 5448 if (sid->u.ssl3.lock) { NSSRWLock_UnlockRead(sid->u.ssl3.lock); } 5449 return SECFailure; 5450 } 5451 maxBytes -= extLen; 5452 5453 PORT_Assert(!maxBytes); 5454 } 5455 5456 if (sid->u.ssl3.lock) { 5457 NSSRWLock_UnlockRead(sid->u.ssl3.lock); 5458 } 5459 5460 if (ss->xtnData.sentSessionTicketInClientHello) { 5461 SSL_AtomicIncrementLong(&ssl3stats.sch_sid_stateless_resumes); 5462 } 5463 5464 if (ss->ssl3.hs.sendingSCSV) { 5465 /* Since we sent the SCSV, pretend we sent empty RI extension. */ 5466 TLSExtensionData *xtnData = &ss->xtnData; 5467 xtnData->advertised[xtnData->numAdvertised++] = 5468 ssl_renegotiation_info_xtn; 5469 } 5470 5471 flags = 0; 5472 if (!ss->firstHsDone && !IS_DTLS(ss)) { 5473 flags |= ssl_SEND_FLAG_CAP_RECORD_VERSION; 5474 } 5475 rv = ssl3_FlushHandshake(ss, flags); 5476 if (rv != SECSuccess) { 5477 return rv; /* error code set by ssl3_FlushHandshake */ 5478 } 5479 5480 ss->ssl3.hs.ws = wait_server_hello; 5481 return rv; 5482 } 5483 5484 5485 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 5486 * ssl3 Hello Request. 5487 * Caller must hold Handshake and RecvBuf locks. 5488 */ 5489 static SECStatus 5490 ssl3_HandleHelloRequest(sslSocket *ss) 5491 { 5492 sslSessionID *sid = ss->sec.ci.sid; 5493 SECStatus rv; 5494 5495 SSL_TRC(3, ("%d: SSL3[%d]: handle hello_request handshake", 5496 SSL_GETPID(), ss->fd)); 5497 5498 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 5499 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 5500 5501 if (ss->ssl3.hs.ws == wait_server_hello) 5502 return SECSuccess; 5503 if (ss->ssl3.hs.ws != idle_handshake || ss->sec.isServer) { 5504 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 5505 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HELLO_REQUEST); 5506 return SECFailure; 5507 } 5508 if (ss->opt.enableRenegotiation == SSL_RENEGOTIATE_NEVER) { 5509 ssl_GetXmitBufLock(ss); 5510 rv = SSL3_SendAlert(ss, alert_warning, no_renegotiation); 5511 ssl_ReleaseXmitBufLock(ss); 5512 PORT_SetError(SSL_ERROR_RENEGOTIATION_NOT_ALLOWED); 5513 return SECFailure; 5514 } 5515 5516 if (sid) { 5517 if (ss->sec.uncache) 5518 ss->sec.uncache(sid); 5519 ssl_FreeSID(sid); 5520 ss->sec.ci.sid = NULL; 5521 } 5522 5523 if (IS_DTLS(ss)) { 5524 dtls_RehandshakeCleanup(ss); 5525 } 5526 5527 ssl_GetXmitBufLock(ss); 5528 rv = ssl3_SendClientHello(ss, PR_FALSE); 5529 ssl_ReleaseXmitBufLock(ss); 5530 5531 return rv; 5532 } 5533 5534 #define UNKNOWN_WRAP_MECHANISM 0x7fffffff 5535 5536 static const CK_MECHANISM_TYPE wrapMechanismList[SSL_NUM_WRAP_MECHS] = { 5537 CKM_DES3_ECB, 5538 CKM_CAST5_ECB, 5539 CKM_DES_ECB, 5540 CKM_KEY_WRAP_LYNKS, 5541 CKM_IDEA_ECB, 5542 CKM_CAST3_ECB, 5543 CKM_CAST_ECB, 5544 CKM_RC5_ECB, 5545 CKM_RC2_ECB, 5546 CKM_CDMF_ECB, 5547 CKM_SKIPJACK_WRAP, 5548 CKM_SKIPJACK_CBC64, 5549 CKM_AES_ECB, 5550 CKM_CAMELLIA_ECB, 5551 CKM_SEED_ECB, 5552 UNKNOWN_WRAP_MECHANISM 5553 }; 5554 5555 static int 5556 ssl_FindIndexByWrapMechanism(CK_MECHANISM_TYPE mech) 5557 { 5558 const CK_MECHANISM_TYPE *pMech = wrapMechanismList; 5559 5560 while (mech != *pMech && *pMech != UNKNOWN_WRAP_MECHANISM) { 5561 ++pMech; 5562 } 5563 return (*pMech == UNKNOWN_WRAP_MECHANISM) ? -1 5564 : (pMech - wrapMechanismList); 5565 } 5566 5567 static PK11SymKey * 5568 ssl_UnwrapSymWrappingKey( 5569 SSLWrappedSymWrappingKey *pWswk, 5570 SECKEYPrivateKey * svrPrivKey, 5571 SSL3KEAType exchKeyType, 5572 CK_MECHANISM_TYPE masterWrapMech, 5573 void * pwArg) 5574 { 5575 PK11SymKey * unwrappedWrappingKey = NULL; 5576 SECItem wrappedKey; 5577 #ifdef NSS_ENABLE_ECC 5578 PK11SymKey * Ks; 5579 SECKEYPublicKey pubWrapKey; 5580 ECCWrappedKeyInfo *ecWrapped; 5581 #endif /* NSS_ENABLE_ECC */ 5582 5583 /* found the wrapping key on disk. */ 5584 PORT_Assert(pWswk->symWrapMechanism == masterWrapMech); 5585 PORT_Assert(pWswk->exchKeyType == exchKeyType); 5586 if (pWswk->symWrapMechanism != masterWrapMech || 5587 pWswk->exchKeyType != exchKeyType) { 5588 goto loser; 5589 } 5590 wrappedKey.type = siBuffer; 5591 wrappedKey.data = pWswk->wrappedSymmetricWrappingkey; 5592 wrappedKey.len = pWswk->wrappedSymKeyLen; 5593 PORT_Assert(wrappedKey.len <= sizeof pWswk->wrappedSymmetricWrappingkey); 5594 5595 switch (exchKeyType) { 5596 5597 case kt_rsa: 5598 unwrappedWrappingKey = 5599 PK11_PubUnwrapSymKey(svrPrivKey, &wrappedKey, 5600 masterWrapMech, CKA_UNWRAP, 0); 5601 break; 5602 5603 #ifdef NSS_ENABLE_ECC 5604 case kt_ecdh: 5605 /* 5606 * For kt_ecdh, we first create an EC public key based on 5607 * data stored with the wrappedSymmetricWrappingkey. Next, 5608 * we do an ECDH computation involving this public key and 5609 * the SSL server's (long-term) EC private key. The resulting 5610 * shared secret is treated the same way as Fortezza's Ks, i.e., 5611 * it is used to recover the symmetric wrapping key. 5612 * 5613 * The data in wrappedSymmetricWrappingkey is laid out as defined 5614 * in the ECCWrappedKeyInfo structure. 5615 */ 5616 ecWrapped = (ECCWrappedKeyInfo *) pWswk->wrappedSymmetricWrappingkey; 5617 5618 PORT_Assert(ecWrapped->encodedParamLen + ecWrapped->pubValueLen + 5619 ecWrapped->wrappedKeyLen <= MAX_EC_WRAPPED_KEY_BUFLEN); 5620 5621 if (ecWrapped->encodedParamLen + ecWrapped->pubValueLen + 5622 ecWrapped->wrappedKeyLen > MAX_EC_WRAPPED_KEY_BUFLEN) { 5623 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 5624 goto loser; 5625 } 5626 5627 pubWrapKey.keyType = ecKey; 5628 pubWrapKey.u.ec.size = ecWrapped->size; 5629 pubWrapKey.u.ec.DEREncodedParams.len = ecWrapped->encodedParamLen; 5630 pubWrapKey.u.ec.DEREncodedParams.data = ecWrapped->var; 5631 pubWrapKey.u.ec.publicValue.len = ecWrapped->pubValueLen; 5632 pubWrapKey.u.ec.publicValue.data = ecWrapped->var + 5633 ecWrapped->encodedParamLen; 5634 5635 wrappedKey.len = ecWrapped->wrappedKeyLen; 5636 wrappedKey.data = ecWrapped->var + ecWrapped->encodedParamLen + 5637 ecWrapped->pubValueLen; 5638 5639 /* Derive Ks using ECDH */ 5640 Ks = PK11_PubDeriveWithKDF(svrPrivKey, &pubWrapKey, PR_FALSE, NULL, 5641 NULL, CKM_ECDH1_DERIVE, masterWrapMech, 5642 CKA_DERIVE, 0, CKD_NULL, NULL, NULL); 5643 if (Ks == NULL) { 5644 goto loser; 5645 } 5646 5647 /* Use Ks to unwrap the wrapping key */ 5648 unwrappedWrappingKey = PK11_UnwrapSymKey(Ks, masterWrapMech, NULL, 5649 &wrappedKey, masterWrapMech, 5650 CKA_UNWRAP, 0); 5651 PK11_FreeSymKey(Ks); 5652 5653 break; 5654 #endif 5655 5656 default: 5657 /* Assert? */ 5658 SET_ERROR_CODE 5659 goto loser; 5660 } 5661 loser: 5662 return unwrappedWrappingKey; 5663 } 5664 5665 /* Each process sharing the server session ID cache has its own array of 5666 * SymKey pointers for the symmetric wrapping keys that are used to wrap 5667 * the master secrets. There is one key for each KEA type. These Symkeys 5668 * correspond to the wrapped SymKeys kept in the server session cache. 5669 */ 5670 5671 typedef struct { 5672 PK11SymKey * symWrapKey[kt_kea_size]; 5673 } ssl3SymWrapKey; 5674 5675 static PZLock * symWrapKeysLock = NULL; 5676 static ssl3SymWrapKey symWrapKeys[SSL_NUM_WRAP_MECHS]; 5677 5678 SECStatus ssl_FreeSymWrapKeysLock(void) 5679 { 5680 if (symWrapKeysLock) { 5681 PZ_DestroyLock(symWrapKeysLock); 5682 symWrapKeysLock = NULL; 5683 return SECSuccess; 5684 } 5685 PORT_SetError(SEC_ERROR_NOT_INITIALIZED); 5686 return SECFailure; 5687 } 5688 5689 SECStatus 5690 SSL3_ShutdownServerCache(void) 5691 { 5692 int i, j; 5693 5694 if (!symWrapKeysLock) 5695 return SECSuccess; /* lock was never initialized */ 5696 PZ_Lock(symWrapKeysLock); 5697 /* get rid of all symWrapKeys */ 5698 for (i = 0; i < SSL_NUM_WRAP_MECHS; ++i) { 5699 for (j = 0; j < kt_kea_size; ++j) { 5700 PK11SymKey ** pSymWrapKey; 5701 pSymWrapKey = &symWrapKeys[i].symWrapKey[j]; 5702 if (*pSymWrapKey) { 5703 PK11_FreeSymKey(*pSymWrapKey); 5704 *pSymWrapKey = NULL; 5705 } 5706 } 5707 } 5708 5709 PZ_Unlock(symWrapKeysLock); 5710 return SECSuccess; 5711 } 5712 5713 SECStatus ssl_InitSymWrapKeysLock(void) 5714 { 5715 symWrapKeysLock = PZ_NewLock(nssILockOther); 5716 return symWrapKeysLock ? SECSuccess : SECFailure; 5717 } 5718 5719 /* Try to get wrapping key for mechanism from in-memory array. 5720 * If that fails, look for one on disk. 5721 * If that fails, generate a new one, put the new one on disk, 5722 * Put the new key in the in-memory array. 5723 */ 5724 static PK11SymKey * 5725 getWrappingKey( sslSocket * ss, 5726 PK11SlotInfo * masterSecretSlot, 5727 SSL3KEAType exchKeyType, 5728 CK_MECHANISM_TYPE masterWrapMech, 5729 void * pwArg) 5730 { 5731 SECKEYPrivateKey * svrPrivKey; 5732 SECKEYPublicKey * svrPubKey = NULL; 5733 PK11SymKey * unwrappedWrappingKey = NULL; 5734 PK11SymKey ** pSymWrapKey; 5735 CK_MECHANISM_TYPE asymWrapMechanism = CKM_INVALID_MECHANISM; 5736 int length; 5737 int symWrapMechIndex; 5738 SECStatus rv; 5739 SECItem wrappedKey; 5740 SSLWrappedSymWrappingKey wswk; 5741 #ifdef NSS_ENABLE_ECC 5742 PK11SymKey * Ks = NULL; 5743 SECKEYPublicKey *pubWrapKey = NULL; 5744 SECKEYPrivateKey *privWrapKey = NULL; 5745 ECCWrappedKeyInfo *ecWrapped; 5746 #endif /* NSS_ENABLE_ECC */ 5747 5748 svrPrivKey = ss->serverCerts[exchKeyType].SERVERKEY; 5749 PORT_Assert(svrPrivKey != NULL); 5750 if (!svrPrivKey) { 5751 return NULL; /* why are we here?!? */ 5752 } 5753 5754 symWrapMechIndex = ssl_FindIndexByWrapMechanism(masterWrapMech); 5755 PORT_Assert(symWrapMechIndex >= 0); 5756 if (symWrapMechIndex < 0) 5757 return NULL; /* invalid masterWrapMech. */ 5758 5759 pSymWrapKey = &symWrapKeys[symWrapMechIndex].symWrapKey[exchKeyType]; 5760 5761 ssl_InitSessionCacheLocks(); 5762 5763 PZ_Lock(symWrapKeysLock); 5764 5765 unwrappedWrappingKey = *pSymWrapKey; 5766 if (unwrappedWrappingKey != NULL) { 5767 if (PK11_VerifyKeyOK(unwrappedWrappingKey)) { 5768 unwrappedWrappingKey = PK11_ReferenceSymKey(unwrappedWrappingKey); 5769 goto done; 5770 } 5771 /* slot series has changed, so this key is no good any more. */ 5772 PK11_FreeSymKey(unwrappedWrappingKey); 5773 *pSymWrapKey = unwrappedWrappingKey = NULL; 5774 } 5775 5776 /* Try to get wrapped SymWrapping key out of the (disk) cache. */ 5777 /* Following call fills in wswk on success. */ 5778 if (ssl_GetWrappingKey(symWrapMechIndex, exchKeyType, &wswk)) { 5779 /* found the wrapped sym wrapping key on disk. */ 5780 unwrappedWrappingKey = 5781 ssl_UnwrapSymWrappingKey(&wswk, svrPrivKey, exchKeyType, 5782 masterWrapMech, pwArg); 5783 if (unwrappedWrappingKey) { 5784 goto install; 5785 } 5786 } 5787 5788 if (!masterSecretSlot) /* caller doesn't want to create a new one. */ 5789 goto loser; 5790 5791 length = PK11_GetBestKeyLength(masterSecretSlot, masterWrapMech); 5792 /* Zero length means fixed key length algorithm, or error. 5793 * It's ambiguous. 5794 */ 5795 unwrappedWrappingKey = PK11_KeyGen(masterSecretSlot, masterWrapMech, NULL, 5796 length, pwArg); 5797 if (!unwrappedWrappingKey) { 5798 goto loser; 5799 } 5800 5801 /* Prepare the buffer to receive the wrappedWrappingKey, 5802 * the symmetric wrapping key wrapped using the server's pub key. 5803 */ 5804 PORT_Memset(&wswk, 0, sizeof wswk); /* eliminate UMRs. */ 5805 5806 if (ss->serverCerts[exchKeyType].serverKeyPair) { 5807 svrPubKey = ss->serverCerts[exchKeyType].serverKeyPair->pubKey; 5808 } 5809 if (svrPubKey == NULL) { 5810 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 5811 goto loser; 5812 } 5813 wrappedKey.type = siBuffer; 5814 wrappedKey.len = SECKEY_PublicKeyStrength(svrPubKey); 5815 wrappedKey.data = wswk.wrappedSymmetricWrappingkey; 5816 5817 PORT_Assert(wrappedKey.len <= sizeof wswk.wrappedSymmetricWrappingkey); 5818 if (wrappedKey.len > sizeof wswk.wrappedSymmetricWrappingkey) 5819 goto loser; 5820 5821 /* wrap symmetric wrapping key in server's public key. */ 5822 switch (exchKeyType) { 5823 case kt_rsa: 5824 asymWrapMechanism = CKM_RSA_PKCS; 5825 rv = PK11_PubWrapSymKey(asymWrapMechanism, svrPubKey, 5826 unwrappedWrappingKey, &wrappedKey); 5827 break; 5828 5829 #ifdef NSS_ENABLE_ECC 5830 case kt_ecdh: 5831 /* 5832 * We generate an ephemeral EC key pair. Perform an ECDH 5833 * computation involving this ephemeral EC public key and 5834 * the SSL server's (long-term) EC private key. The resulting 5835 * shared secret is treated in the same way as Fortezza's Ks, 5836 * i.e., it is used to wrap the wrapping key. To facilitate 5837 * unwrapping in ssl_UnwrapWrappingKey, we also store all 5838 * relevant info about the ephemeral EC public key in 5839 * wswk.wrappedSymmetricWrappingkey and lay it out as 5840 * described in the ECCWrappedKeyInfo structure. 5841 */ 5842 PORT_Assert(svrPubKey->keyType == ecKey); 5843 if (svrPubKey->keyType != ecKey) { 5844 /* something is wrong in sslsecur.c if this isn't an ecKey */ 5845 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 5846 rv = SECFailure; 5847 goto ec_cleanup; 5848 } 5849 5850 privWrapKey = SECKEY_CreateECPrivateKey( 5851 &svrPubKey->u.ec.DEREncodedParams, &pubWrapKey, NULL); 5852 if ((privWrapKey == NULL) || (pubWrapKey == NULL)) { 5853 rv = SECFailure; 5854 goto ec_cleanup; 5855 } 5856 5857 /* Set the key size in bits */ 5858 if (pubWrapKey->u.ec.size == 0) { 5859 pubWrapKey->u.ec.size = SECKEY_PublicKeyStrengthInBits(svrPubKey); 5860 } 5861 5862 PORT_Assert(pubWrapKey->u.ec.DEREncodedParams.len + 5863 pubWrapKey->u.ec.publicValue.len < MAX_EC_WRAPPED_KEY_BUFLEN); 5864 if (pubWrapKey->u.ec.DEREncodedParams.len + 5865 pubWrapKey->u.ec.publicValue.len >= MAX_EC_WRAPPED_KEY_BUFLEN) { 5866 PORT_SetError(SEC_ERROR_INVALID_KEY); 5867 rv = SECFailure; 5868 goto ec_cleanup; 5869 } 5870 5871 /* Derive Ks using ECDH */ 5872 Ks = PK11_PubDeriveWithKDF(svrPrivKey, pubWrapKey, PR_FALSE, NULL, 5873 NULL, CKM_ECDH1_DERIVE, masterWrapMech, 5874 CKA_DERIVE, 0, CKD_NULL, NULL, NULL); 5875 if (Ks == NULL) { 5876 rv = SECFailure; 5877 goto ec_cleanup; 5878 } 5879 5880 ecWrapped = (ECCWrappedKeyInfo *) (wswk.wrappedSymmetricWrappingkey); 5881 ecWrapped->size = pubWrapKey->u.ec.size; 5882 ecWrapped->encodedParamLen = pubWrapKey->u.ec.DEREncodedParams.len; 5883 PORT_Memcpy(ecWrapped->var, pubWrapKey->u.ec.DEREncodedParams.data, 5884 pubWrapKey->u.ec.DEREncodedParams.len); 5885 5886 ecWrapped->pubValueLen = pubWrapKey->u.ec.publicValue.len; 5887 PORT_Memcpy(ecWrapped->var + ecWrapped->encodedParamLen, 5888 pubWrapKey->u.ec.publicValue.data, 5889 pubWrapKey->u.ec.publicValue.len); 5890 5891 wrappedKey.len = MAX_EC_WRAPPED_KEY_BUFLEN - 5892 (ecWrapped->encodedParamLen + ecWrapped->pubValueLen); 5893 wrappedKey.data = ecWrapped->var + ecWrapped->encodedParamLen + 5894 ecWrapped->pubValueLen; 5895 5896 /* wrap symmetricWrapping key with the local Ks */ 5897 rv = PK11_WrapSymKey(masterWrapMech, NULL, Ks, 5898 unwrappedWrappingKey, &wrappedKey); 5899 5900 if (rv != SECSuccess) { 5901 goto ec_cleanup; 5902 } 5903 5904 /* Write down the length of wrapped key in the buffer 5905 * wswk.wrappedSymmetricWrappingkey at the appropriate offset 5906 */ 5907 ecWrapped->wrappedKeyLen = wrappedKey.len; 5908 5909 ec_cleanup: 5910 if (privWrapKey) SECKEY_DestroyPrivateKey(privWrapKey); 5911 if (pubWrapKey) SECKEY_DestroyPublicKey(pubWrapKey); 5912 if (Ks) PK11_FreeSymKey(Ks); 5913 asymWrapMechanism = masterWrapMech; 5914 break; 5915 #endif /* NSS_ENABLE_ECC */ 5916 5917 default: 5918 rv = SECFailure; 5919 break; 5920 } 5921 5922 if (rv != SECSuccess) { 5923 ssl_MapLowLevelError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 5924 goto loser; 5925 } 5926 5927 PORT_Assert(asymWrapMechanism != CKM_INVALID_MECHANISM); 5928 5929 wswk.symWrapMechanism = masterWrapMech; 5930 wswk.symWrapMechIndex = symWrapMechIndex; 5931 wswk.asymWrapMechanism = asymWrapMechanism; 5932 wswk.exchKeyType = exchKeyType; 5933 wswk.wrappedSymKeyLen = wrappedKey.len; 5934 5935 /* put it on disk. */ 5936 /* If the wrapping key for this KEA type has already been set, 5937 * then abandon the value we just computed and 5938 * use the one we got from the disk. 5939 */ 5940 if (ssl_SetWrappingKey(&wswk)) { 5941 /* somebody beat us to it. The original contents of our wswk 5942 * has been replaced with the content on disk. Now, discard 5943 * the key we just created and unwrap this new one. 5944 */ 5945 PK11_FreeSymKey(unwrappedWrappingKey); 5946 5947 unwrappedWrappingKey = 5948 ssl_UnwrapSymWrappingKey(&wswk, svrPrivKey, exchKeyType, 5949 masterWrapMech, pwArg); 5950 } 5951 5952 install: 5953 if (unwrappedWrappingKey) { 5954 *pSymWrapKey = PK11_ReferenceSymKey(unwrappedWrappingKey); 5955 } 5956 5957 loser: 5958 done: 5959 PZ_Unlock(symWrapKeysLock); 5960 return unwrappedWrappingKey; 5961 } 5962 5963 /* hexEncode hex encodes |length| bytes from |in| and writes it as |length*2| 5964 * bytes to |out|. */ 5965 static void 5966 hexEncode(char *out, const unsigned char *in, unsigned int length) 5967 { 5968 static const char hextable[] = "0123456789abcdef"; 5969 unsigned int i; 5970 5971 for (i = 0; i < length; i++) { 5972 *(out++) = hextable[in[i] >> 4]; 5973 *(out++) = hextable[in[i] & 15]; 5974 } 5975 } 5976 5977 /* Called from ssl3_SendClientKeyExchange(). */ 5978 /* Presently, this always uses PKCS11. There is no bypass for this. */ 5979 static SECStatus 5980 sendRSAClientKeyExchange(sslSocket * ss, SECKEYPublicKey * svrPubKey) 5981 { 5982 PK11SymKey * pms = NULL; 5983 SECStatus rv = SECFailure; 5984 SECItem enc_pms = {siBuffer, NULL, 0}; 5985 PRBool isTLS; 5986 5987 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 5988 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 5989 5990 /* Generate the pre-master secret ... */ 5991 ssl_GetSpecWriteLock(ss); 5992 isTLS = (PRBool)(ss->ssl3.pwSpec->version > SSL_LIBRARY_VERSION_3_0); 5993 5994 pms = ssl3_GenerateRSAPMS(ss, ss->ssl3.pwSpec, NULL); 5995 ssl_ReleaseSpecWriteLock(ss); 5996 if (pms == NULL) { 5997 ssl_MapLowLevelError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 5998 goto loser; 5999 } 6000 6001 /* Get the wrapped (encrypted) pre-master secret, enc_pms */ 6002 enc_pms.len = SECKEY_PublicKeyStrength(svrPubKey); 6003 enc_pms.data = (unsigned char*)PORT_Alloc(enc_pms.len); 6004 if (enc_pms.data == NULL) { 6005 goto loser; /* err set by PORT_Alloc */ 6006 } 6007 6008 /* wrap pre-master secret in server's public key. */ 6009 rv = PK11_PubWrapSymKey(CKM_RSA_PKCS, svrPubKey, pms, &enc_pms); 6010 if (rv != SECSuccess) { 6011 ssl_MapLowLevelError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 6012 goto loser; 6013 } 6014 6015 if (ssl_keylog_iob) { 6016 SECStatus extractRV = PK11_ExtractKeyValue(pms); 6017 if (extractRV == SECSuccess) { 6018 SECItem * keyData = PK11_GetKeyData(pms); 6019 if (keyData && keyData->data && keyData->len) { 6020 #ifdef TRACE 6021 if (ssl_trace >= 100) { 6022 ssl_PrintBuf(ss, "Pre-Master Secret", 6023 keyData->data, keyData->len); 6024 } 6025 #endif 6026 if (ssl_keylog_iob && enc_pms.len >= 8 && keyData->len == 48) { 6027 /* https://developer.mozilla.org/en/NSS_Key_Log_Format */ 6028 6029 /* There could be multiple, concurrent writers to the 6030 * keylog, so we have to do everything in a single call to 6031 * fwrite. */ 6032 char buf[4 + 8*2 + 1 + 48*2 + 1]; 6033 6034 strcpy(buf, "RSA "); 6035 hexEncode(buf + 4, enc_pms.data, 8); 6036 buf[20] = ' '; 6037 hexEncode(buf + 21, keyData->data, 48); 6038 buf[sizeof(buf) - 1] = '\n'; 6039 6040 fwrite(buf, sizeof(buf), 1, ssl_keylog_iob); 6041 fflush(ssl_keylog_iob); 6042 } 6043 } 6044 } 6045 } 6046 6047 rv = ssl3_InitPendingCipherSpec(ss, pms); 6048 PK11_FreeSymKey(pms); pms = NULL; 6049 6050 if (rv != SECSuccess) { 6051 ssl_MapLowLevelError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 6052 goto loser; 6053 } 6054 6055 rv = ssl3_AppendHandshakeHeader(ss, client_key_exchange, 6056 isTLS ? enc_pms.len + 2 : enc_pms.len); 6057 if (rv != SECSuccess) { 6058 goto loser; /* err set by ssl3_AppendHandshake* */ 6059 } 6060 if (isTLS) { 6061 rv = ssl3_AppendHandshakeVariable(ss, enc_pms.data, enc_pms.len, 2); 6062 } else { 6063 rv = ssl3_AppendHandshake(ss, enc_pms.data, enc_pms.len); 6064 } 6065 if (rv != SECSuccess) { 6066 goto loser; /* err set by ssl3_AppendHandshake* */ 6067 } 6068 6069 rv = SECSuccess; 6070 6071 loser: 6072 if (enc_pms.data != NULL) { 6073 PORT_Free(enc_pms.data); 6074 } 6075 if (pms != NULL) { 6076 PK11_FreeSymKey(pms); 6077 } 6078 return rv; 6079 } 6080 6081 /* Called from ssl3_SendClientKeyExchange(). */ 6082 /* Presently, this always uses PKCS11. There is no bypass for this. */ 6083 static SECStatus 6084 sendDHClientKeyExchange(sslSocket * ss, SECKEYPublicKey * svrPubKey) 6085 { 6086 PK11SymKey * pms = NULL; 6087 SECStatus rv = SECFailure; 6088 PRBool isTLS; 6089 CK_MECHANISM_TYPE target; 6090 6091 SECKEYDHParams dhParam; /* DH parameters */ 6092 SECKEYPublicKey *pubKey = NULL; /* Ephemeral DH key */ 6093 SECKEYPrivateKey *privKey = NULL; /* Ephemeral DH key */ 6094 6095 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 6096 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 6097 6098 isTLS = (PRBool)(ss->ssl3.pwSpec->version > SSL_LIBRARY_VERSION_3_0); 6099 6100 /* Copy DH parameters from server key */ 6101 6102 if (svrPubKey->keyType != dhKey) { 6103 PORT_SetError(SEC_ERROR_BAD_KEY); 6104 goto loser; 6105 } 6106 dhParam.prime.data = svrPubKey->u.dh.prime.data; 6107 dhParam.prime.len = svrPubKey->u.dh.prime.len; 6108 dhParam.base.data = svrPubKey->u.dh.base.data; 6109 dhParam.base.len = svrPubKey->u.dh.base.len; 6110 6111 /* Generate ephemeral DH keypair */ 6112 privKey = SECKEY_CreateDHPrivateKey(&dhParam, &pubKey, NULL); 6113 if (!privKey || !pubKey) { 6114 ssl_MapLowLevelError(SEC_ERROR_KEYGEN_FAIL); 6115 rv = SECFailure; 6116 goto loser; 6117 } 6118 PRINT_BUF(50, (ss, "DH public value:", 6119 pubKey->u.dh.publicValue.data, 6120 pubKey->u.dh.publicValue.len)); 6121 6122 if (isTLS) target = CKM_TLS_MASTER_KEY_DERIVE_DH; 6123 else target = CKM_SSL3_MASTER_KEY_DERIVE_DH; 6124 6125 /* Determine the PMS */ 6126 6127 pms = PK11_PubDerive(privKey, svrPubKey, PR_FALSE, NULL, NULL, 6128 CKM_DH_PKCS_DERIVE, target, CKA_DERIVE, 0, NULL); 6129 6130 if (pms == NULL) { 6131 ssl_MapLowLevelError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 6132 goto loser; 6133 } 6134 6135 SECKEY_DestroyPrivateKey(privKey); 6136 privKey = NULL; 6137 6138 rv = ssl3_InitPendingCipherSpec(ss, pms); 6139 PK11_FreeSymKey(pms); pms = NULL; 6140 6141 if (rv != SECSuccess) { 6142 ssl_MapLowLevelError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 6143 goto loser; 6144 } 6145 6146 rv = ssl3_AppendHandshakeHeader(ss, client_key_exchange, 6147 pubKey->u.dh.publicValue.len + 2); 6148 if (rv != SECSuccess) { 6149 goto loser; /* err set by ssl3_AppendHandshake* */ 6150 } 6151 rv = ssl3_AppendHandshakeVariable(ss, 6152 pubKey->u.dh.publicValue.data, 6153 pubKey->u.dh.publicValue.len, 2); 6154 SECKEY_DestroyPublicKey(pubKey); 6155 pubKey = NULL; 6156 6157 if (rv != SECSuccess) { 6158 goto loser; /* err set by ssl3_AppendHandshake* */ 6159 } 6160 6161 rv = SECSuccess; 6162 6163 6164 loser: 6165 6166 if(pms) PK11_FreeSymKey(pms); 6167 if(privKey) SECKEY_DestroyPrivateKey(privKey); 6168 if(pubKey) SECKEY_DestroyPublicKey(pubKey); 6169 return rv; 6170 } 6171 6172 6173 6174 6175 6176 /* Called from ssl3_HandleServerHelloDone(). */ 6177 static SECStatus 6178 ssl3_SendClientKeyExchange(sslSocket *ss) 6179 { 6180 SECKEYPublicKey * serverKey = NULL; 6181 SECStatus rv = SECFailure; 6182 PRBool isTLS; 6183 6184 SSL_TRC(3, ("%d: SSL3[%d]: send client_key_exchange handshake", 6185 SSL_GETPID(), ss->fd)); 6186 6187 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 6188 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 6189 6190 if (ss->sec.peerKey == NULL) { 6191 serverKey = CERT_ExtractPublicKey(ss->sec.peerCert); 6192 if (serverKey == NULL) { 6193 ssl_MapLowLevelError(SSL_ERROR_EXTRACT_PUBLIC_KEY_FAILURE); 6194 return SECFailure; 6195 } 6196 } else { 6197 serverKey = ss->sec.peerKey; 6198 ss->sec.peerKey = NULL; /* we're done with it now */ 6199 } 6200 6201 isTLS = (PRBool)(ss->ssl3.pwSpec->version > SSL_LIBRARY_VERSION_3_0); 6202 /* enforce limits on kea key sizes. */ 6203 if (ss->ssl3.hs.kea_def->is_limited) { 6204 int keyLen = SECKEY_PublicKeyStrength(serverKey); /* bytes */ 6205 6206 if (keyLen * BPB > ss->ssl3.hs.kea_def->key_size_limit) { 6207 if (isTLS) 6208 (void)SSL3_SendAlert(ss, alert_fatal, export_restriction); 6209 else 6210 (void)ssl3_HandshakeFailure(ss); 6211 PORT_SetError(SSL_ERROR_PUB_KEY_SIZE_LIMIT_EXCEEDED); 6212 goto loser; 6213 } 6214 } 6215 6216 ss->sec.keaType = ss->ssl3.hs.kea_def->exchKeyType; 6217 ss->sec.keaKeyBits = SECKEY_PublicKeyStrengthInBits(serverKey); 6218 6219 switch (ss->ssl3.hs.kea_def->exchKeyType) { 6220 case kt_rsa: 6221 rv = sendRSAClientKeyExchange(ss, serverKey); 6222 break; 6223 6224 case kt_dh: 6225 rv = sendDHClientKeyExchange(ss, serverKey); 6226 break; 6227 6228 #ifdef NSS_ENABLE_ECC 6229 case kt_ecdh: 6230 rv = ssl3_SendECDHClientKeyExchange(ss, serverKey); 6231 break; 6232 #endif /* NSS_ENABLE_ECC */ 6233 6234 default: 6235 /* got an unknown or unsupported Key Exchange Algorithm. */ 6236 SEND_ALERT 6237 PORT_SetError(SEC_ERROR_UNSUPPORTED_KEYALG); 6238 break; 6239 } 6240 6241 SSL_TRC(3, ("%d: SSL3[%d]: DONE sending client_key_exchange", 6242 SSL_GETPID(), ss->fd)); 6243 6244 loser: 6245 if (serverKey) 6246 SECKEY_DestroyPublicKey(serverKey); 6247 return rv; /* err code already set. */ 6248 } 6249 6250 /* Called from ssl3_HandleServerHelloDone(). */ 6251 static SECStatus 6252 ssl3_SendCertificateVerify(sslSocket *ss) 6253 { 6254 SECStatus rv = SECFailure; 6255 PRBool isTLS; 6256 PRBool isTLS12; 6257 SECItem buf = {siBuffer, NULL, 0}; 6258 SSL3Hashes hashes; 6259 KeyType keyType; 6260 unsigned int len; 6261 SSL3SignatureAndHashAlgorithm sigAndHash; 6262 6263 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 6264 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 6265 6266 SSL_TRC(3, ("%d: SSL3[%d]: send certificate_verify handshake", 6267 SSL_GETPID(), ss->fd)); 6268 6269 ssl_GetSpecReadLock(ss); 6270 if (ss->ssl3.hs.hashType == handshake_hash_single && 6271 ss->ssl3.hs.backupHash) { 6272 rv = ssl3_ComputeBackupHandshakeHashes(ss, &hashes); 6273 PORT_Assert(!ss->ssl3.hs.backupHash); 6274 } else { 6275 rv = ssl3_ComputeHandshakeHashes(ss, ss->ssl3.pwSpec, &hashes, 0); 6276 } 6277 ssl_ReleaseSpecReadLock(ss); 6278 if (rv != SECSuccess) { 6279 goto done; /* err code was set by ssl3_ComputeHandshakeHashes */ 6280 } 6281 6282 isTLS = (PRBool)(ss->ssl3.pwSpec->version > SSL_LIBRARY_VERSION_3_0); 6283 isTLS12 = (PRBool)(ss->ssl3.pwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_2); 6284 if (ss->ssl3.platformClientKey) { 6285 #ifdef NSS_PLATFORM_CLIENT_AUTH 6286 keyType = CERT_GetCertKeyType( 6287 &ss->ssl3.clientCertificate->subjectPublicKeyInfo); 6288 rv = ssl3_PlatformSignHashes( 6289 &hashes, ss->ssl3.platformClientKey, &buf, isTLS, keyType); 6290 ssl_FreePlatformKey(ss->ssl3.platformClientKey); 6291 ss->ssl3.platformClientKey = (PlatformKey)NULL; 6292 #endif /* NSS_PLATFORM_CLIENT_AUTH */ 6293 } else { 6294 keyType = ss->ssl3.clientPrivateKey->keyType; 6295 rv = ssl3_SignHashes(&hashes, ss->ssl3.clientPrivateKey, &buf, isTLS); 6296 if (rv == SECSuccess) { 6297 PK11SlotInfo * slot; 6298 sslSessionID * sid = ss->sec.ci.sid; 6299 6300 /* Remember the info about the slot that did the signing. 6301 ** Later, when doing an SSL restart handshake, verify this. 6302 ** These calls are mere accessors, and can't fail. 6303 */ 6304 slot = PK11_GetSlotFromPrivateKey(ss->ssl3.clientPrivateKey); 6305 sid->u.ssl3.clAuthSeries = PK11_GetSlotSeries(slot); 6306 sid->u.ssl3.clAuthSlotID = PK11_GetSlotID(slot); 6307 sid->u.ssl3.clAuthModuleID = PK11_GetModuleID(slot); 6308 sid->u.ssl3.clAuthValid = PR_TRUE; 6309 PK11_FreeSlot(slot); 6310 } 6311 SECKEY_DestroyPrivateKey(ss->ssl3.clientPrivateKey); 6312 ss->ssl3.clientPrivateKey = NULL; 6313 } 6314 if (rv != SECSuccess) { 6315 goto done; /* err code was set by ssl3_SignHashes */ 6316 } 6317 6318 len = buf.len + 2 + (isTLS12 ? 2 : 0); 6319 6320 rv = ssl3_AppendHandshakeHeader(ss, certificate_verify, len); 6321 if (rv != SECSuccess) { 6322 goto done; /* error code set by AppendHandshake */ 6323 } 6324 if (isTLS12) { 6325 rv = ssl3_TLSSignatureAlgorithmForKeyType(keyType, 6326 &sigAndHash.sigAlg); 6327 if (rv != SECSuccess) { 6328 goto done; 6329 } 6330 sigAndHash.hashAlg = hashes.hashAlg; 6331 6332 rv = ssl3_AppendSignatureAndHashAlgorithm(ss, &sigAndHash); 6333 if (rv != SECSuccess) { 6334 goto done; /* err set by AppendHandshake. */ 6335 } 6336 } 6337 rv = ssl3_AppendHandshakeVariable(ss, buf.data, buf.len, 2); 6338 if (rv != SECSuccess) { 6339 goto done; /* error code set by AppendHandshake */ 6340 } 6341 6342 done: 6343 if (buf.data) 6344 PORT_Free(buf.data); 6345 return rv; 6346 } 6347 6348 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 6349 * ssl3 ServerHello message. 6350 * Caller must hold Handshake and RecvBuf locks. 6351 */ 6352 static SECStatus 6353 ssl3_HandleServerHello(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 6354 { 6355 sslSessionID *sid = ss->sec.ci.sid; 6356 PRInt32 temp; /* allow for consume number failure */ 6357 PRBool suite_found = PR_FALSE; 6358 int i; 6359 int errCode = SSL_ERROR_RX_MALFORMED_SERVER_HELLO; 6360 SECStatus rv; 6361 SECItem sidBytes = {siBuffer, NULL, 0}; 6362 PRBool sid_match; 6363 PRBool isTLS = PR_FALSE; 6364 SSL3AlertDescription desc = illegal_parameter; 6365 SSL3ProtocolVersion version; 6366 6367 SSL_TRC(3, ("%d: SSL3[%d]: handle server_hello handshake", 6368 SSL_GETPID(), ss->fd)); 6369 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 6370 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 6371 PORT_Assert( ss->ssl3.initialized ); 6372 6373 if (ss->ssl3.hs.ws != wait_server_hello) { 6374 errCode = SSL_ERROR_RX_UNEXPECTED_SERVER_HELLO; 6375 desc = unexpected_message; 6376 goto alert_loser; 6377 } 6378 6379 /* clean up anything left from previous handshake. */ 6380 if (ss->ssl3.clientCertChain != NULL) { 6381 CERT_DestroyCertificateList(ss->ssl3.clientCertChain); 6382 ss->ssl3.clientCertChain = NULL; 6383 } 6384 if (ss->ssl3.clientCertificate != NULL) { 6385 CERT_DestroyCertificate(ss->ssl3.clientCertificate); 6386 ss->ssl3.clientCertificate = NULL; 6387 } 6388 if (ss->ssl3.clientPrivateKey != NULL) { 6389 SECKEY_DestroyPrivateKey(ss->ssl3.clientPrivateKey); 6390 ss->ssl3.clientPrivateKey = NULL; 6391 } 6392 #ifdef NSS_PLATFORM_CLIENT_AUTH 6393 if (ss->ssl3.platformClientKey) { 6394 ssl_FreePlatformKey(ss->ssl3.platformClientKey); 6395 ss->ssl3.platformClientKey = (PlatformKey)NULL; 6396 } 6397 #endif /* NSS_PLATFORM_CLIENT_AUTH */ 6398 6399 if (ss->ssl3.channelID != NULL) { 6400 SECKEY_DestroyPrivateKey(ss->ssl3.channelID); 6401 ss->ssl3.channelID = NULL; 6402 } 6403 if (ss->ssl3.channelIDPub != NULL) { 6404 SECKEY_DestroyPublicKey(ss->ssl3.channelIDPub); 6405 ss->ssl3.channelIDPub = NULL; 6406 } 6407 6408 temp = ssl3_ConsumeHandshakeNumber(ss, 2, &b, &length); 6409 if (temp < 0) { 6410 goto loser; /* alert has been sent */ 6411 } 6412 version = (SSL3ProtocolVersion)temp; 6413 6414 if (IS_DTLS(ss)) { 6415 /* RFC 4347 required that you verify that the server versions 6416 * match (Section 4.2.1) in the HelloVerifyRequest and the 6417 * ServerHello. 6418 * 6419 * RFC 6347 suggests (SHOULD) that servers always use 1.0 6420 * in HelloVerifyRequest and allows the versions not to match, 6421 * especially when 1.2 is being negotiated. 6422 * 6423 * Therefore we do not check for matching here. 6424 */ 6425 version = dtls_DTLSVersionToTLSVersion(version); 6426 if (version == 0) { /* Insane version number */ 6427 goto alert_loser; 6428 } 6429 } 6430 6431 rv = ssl3_NegotiateVersion(ss, version, PR_FALSE); 6432 if (rv != SECSuccess) { 6433 desc = (version > SSL_LIBRARY_VERSION_3_0) ? protocol_version 6434 : handshake_failure; 6435 errCode = SSL_ERROR_NO_CYPHER_OVERLAP; 6436 goto alert_loser; 6437 } 6438 isTLS = (ss->version > SSL_LIBRARY_VERSION_3_0); 6439 6440 rv = ssl3_InitHandshakeHashes(ss); 6441 if (rv != SECSuccess) { 6442 desc = internal_error; 6443 errCode = PORT_GetError(); 6444 goto alert_loser; 6445 } 6446 6447 rv = ssl3_ConsumeHandshake( 6448 ss, &ss->ssl3.hs.server_random, SSL3_RANDOM_LENGTH, &b, &length); 6449 if (rv != SECSuccess) { 6450 goto loser; /* alert has been sent */ 6451 } 6452 6453 rv = ssl3_ConsumeHandshakeVariable(ss, &sidBytes, 1, &b, &length); 6454 if (rv != SECSuccess) { 6455 goto loser; /* alert has been sent */ 6456 } 6457 if (sidBytes.len > SSL3_SESSIONID_BYTES) { 6458 if (isTLS) 6459 desc = decode_error; 6460 goto alert_loser; /* malformed. */ 6461 } 6462 6463 /* find selected cipher suite in our list. */ 6464 temp = ssl3_ConsumeHandshakeNumber(ss, 2, &b, &length); 6465 if (temp < 0) { 6466 goto loser; /* alert has been sent */ 6467 } 6468 ssl3_config_match_init(ss); 6469 for (i = 0; i < ssl_V3_SUITES_IMPLEMENTED; i++) { 6470 ssl3CipherSuiteCfg *suite = &ss->cipherSuites[i]; 6471 if (temp == suite->cipher_suite) { 6472 SSLVersionRange vrange = {ss->version, ss->version}; 6473 if (!config_match(suite, ss->ssl3.policy, PR_TRUE, &vrange)) { 6474 /* config_match already checks whether the cipher suite is 6475 * acceptable for the version, but the check is repeated here 6476 * in order to give a more precise error code. */ 6477 if (!ssl3_CipherSuiteAllowedForVersionRange(temp, &vrange)) { 6478 desc = handshake_failure; 6479 errCode = SSL_ERROR_CIPHER_DISALLOWED_FOR_VERSION; 6480 goto alert_loser; 6481 } 6482 6483 break; /* failure */ 6484 } 6485 6486 suite_found = PR_TRUE; 6487 break; /* success */ 6488 } 6489 } 6490 if (!suite_found) { 6491 desc = handshake_failure; 6492 errCode = SSL_ERROR_NO_CYPHER_OVERLAP; 6493 goto alert_loser; 6494 } 6495 ss->ssl3.hs.cipher_suite = (ssl3CipherSuite)temp; 6496 ss->ssl3.hs.suite_def = ssl_LookupCipherSuiteDef((ssl3CipherSuite)temp); 6497 PORT_Assert(ss->ssl3.hs.suite_def); 6498 if (!ss->ssl3.hs.suite_def) { 6499 PORT_SetError(errCode = SEC_ERROR_LIBRARY_FAILURE); 6500 goto loser; /* we don't send alerts for our screw-ups. */ 6501 } 6502 6503 /* find selected compression method in our list. */ 6504 temp = ssl3_ConsumeHandshakeNumber(ss, 1, &b, &length); 6505 if (temp < 0) { 6506 goto loser; /* alert has been sent */ 6507 } 6508 suite_found = PR_FALSE; 6509 for (i = 0; i < compressionMethodsCount; i++) { 6510 if (temp == compressions[i]) { 6511 if (!compressionEnabled(ss, compressions[i])) { 6512 break; /* failure */ 6513 } 6514 suite_found = PR_TRUE; 6515 break; /* success */ 6516 } 6517 } 6518 if (!suite_found) { 6519 desc = handshake_failure; 6520 errCode = SSL_ERROR_NO_COMPRESSION_OVERLAP; 6521 goto alert_loser; 6522 } 6523 ss->ssl3.hs.compression = (SSLCompressionMethod)temp; 6524 6525 /* Note that if !isTLS and the extra stuff is not extensions, we 6526 * do NOT goto alert_loser. 6527 * There are some old SSL 3.0 implementations that do send stuff 6528 * after the end of the server hello, and we deliberately ignore 6529 * such stuff in the interest of maximal interoperability (being 6530 * "generous in what you accept"). 6531 * Update: Starting in NSS 3.12.6, we handle the renegotiation_info 6532 * extension in SSL 3.0. 6533 */ 6534 if (length != 0) { 6535 SECItem extensions; 6536 rv = ssl3_ConsumeHandshakeVariable(ss, &extensions, 2, &b, &length); 6537 if (rv != SECSuccess || length != 0) { 6538 if (isTLS) 6539 goto alert_loser; 6540 } else { 6541 rv = ssl3_HandleHelloExtensions(ss, &extensions.data, 6542 &extensions.len); 6543 if (rv != SECSuccess) 6544 goto alert_loser; 6545 } 6546 } 6547 if ((ss->opt.requireSafeNegotiation || 6548 (ss->firstHsDone && (ss->peerRequestedProtection || 6549 ss->opt.enableRenegotiation == SSL_RENEGOTIATE_REQUIRES_XTN))) && 6550 !ssl3_ExtensionNegotiated(ss, ssl_renegotiation_info_xtn)) { 6551 desc = handshake_failure; 6552 errCode = ss->firstHsDone ? SSL_ERROR_RENEGOTIATION_NOT_ALLOWED 6553 : SSL_ERROR_UNSAFE_NEGOTIATION; 6554 goto alert_loser; 6555 } 6556 6557 /* Any errors after this point are not "malformed" errors. */ 6558 desc = handshake_failure; 6559 6560 /* we need to call ssl3_SetupPendingCipherSpec here so we can check the 6561 * key exchange algorithm. */ 6562 rv = ssl3_SetupPendingCipherSpec(ss); 6563 if (rv != SECSuccess) { 6564 goto alert_loser; /* error code is set. */ 6565 } 6566 6567 /* We may or may not have sent a session id, we may get one back or 6568 * not and if so it may match the one we sent. 6569 * Attempt to restore the master secret to see if this is so... 6570 * Don't consider failure to find a matching SID an error. 6571 */ 6572 sid_match = (PRBool)(sidBytes.len > 0 && 6573 sidBytes.len == sid->u.ssl3.sessionIDLength && 6574 !PORT_Memcmp(sid->u.ssl3.sessionID, sidBytes.data, sidBytes.len)); 6575 6576 if (sid_match && 6577 sid->version == ss->version && 6578 sid->u.ssl3.cipherSuite == ss->ssl3.hs.cipher_suite) do { 6579 ssl3CipherSpec *pwSpec = ss->ssl3.pwSpec; 6580 6581 SECItem wrappedMS; /* wrapped master secret. */ 6582 6583 ss->sec.authAlgorithm = sid->authAlgorithm; 6584 ss->sec.authKeyBits = sid->authKeyBits; 6585 ss->sec.keaType = sid->keaType; 6586 ss->sec.keaKeyBits = sid->keaKeyBits; 6587 6588 /* 3 cases here: 6589 * a) key is wrapped (implies using PKCS11) 6590 * b) key is unwrapped, but we're still using PKCS11 6591 * c) key is unwrapped, and we're bypassing PKCS11. 6592 */ 6593 if (sid->u.ssl3.keys.msIsWrapped) { 6594 PK11SlotInfo *slot; 6595 PK11SymKey * wrapKey; /* wrapping key */ 6596 CK_FLAGS keyFlags = 0; 6597 6598 #ifndef NO_PKCS11_BYPASS 6599 if (ss->opt.bypassPKCS11) { 6600 /* we cannot restart a non-bypass session in a 6601 ** bypass socket. 6602 */ 6603 break; 6604 } 6605 #endif 6606 /* unwrap master secret with PKCS11 */ 6607 slot = SECMOD_LookupSlot(sid->u.ssl3.masterModuleID, 6608 sid->u.ssl3.masterSlotID); 6609 if (slot == NULL) { 6610 break; /* not considered an error. */ 6611 } 6612 if (!PK11_IsPresent(slot)) { 6613 PK11_FreeSlot(slot); 6614 break; /* not considered an error. */ 6615 } 6616 wrapKey = PK11_GetWrapKey(slot, sid->u.ssl3.masterWrapIndex, 6617 sid->u.ssl3.masterWrapMech, 6618 sid->u.ssl3.masterWrapSeries, 6619 ss->pkcs11PinArg); 6620 PK11_FreeSlot(slot); 6621 if (wrapKey == NULL) { 6622 break; /* not considered an error. */ 6623 } 6624 6625 if (ss->version > SSL_LIBRARY_VERSION_3_0) { /* isTLS */ 6626 keyFlags = CKF_SIGN | CKF_VERIFY; 6627 } 6628 6629 wrappedMS.data = sid->u.ssl3.keys.wrapped_master_secret; 6630 wrappedMS.len = sid->u.ssl3.keys.wrapped_master_secret_len; 6631 pwSpec->master_secret = 6632 PK11_UnwrapSymKeyWithFlags(wrapKey, sid->u.ssl3.masterWrapMech, 6633 NULL, &wrappedMS, CKM_SSL3_MASTER_KEY_DERIVE, 6634 CKA_DERIVE, sizeof(SSL3MasterSecret), keyFlags); 6635 errCode = PORT_GetError(); 6636 PK11_FreeSymKey(wrapKey); 6637 if (pwSpec->master_secret == NULL) { 6638 break; /* errorCode set just after call to UnwrapSymKey. */ 6639 } 6640 #ifndef NO_PKCS11_BYPASS 6641 } else if (ss->opt.bypassPKCS11) { 6642 /* MS is not wrapped */ 6643 wrappedMS.data = sid->u.ssl3.keys.wrapped_master_secret; 6644 wrappedMS.len = sid->u.ssl3.keys.wrapped_master_secret_len; 6645 memcpy(pwSpec->raw_master_secret, wrappedMS.data, wrappedMS.len); 6646 pwSpec->msItem.data = pwSpec->raw_master_secret; 6647 pwSpec->msItem.len = wrappedMS.len; 6648 #endif 6649 } else { 6650 /* We CAN restart a bypass session in a non-bypass socket. */ 6651 /* need to import the raw master secret to session object */ 6652 PK11SlotInfo *slot = PK11_GetInternalSlot(); 6653 wrappedMS.data = sid->u.ssl3.keys.wrapped_master_secret; 6654 wrappedMS.len = sid->u.ssl3.keys.wrapped_master_secret_len; 6655 pwSpec->master_secret = 6656 PK11_ImportSymKey(slot, CKM_SSL3_MASTER_KEY_DERIVE, 6657 PK11_OriginUnwrap, CKA_ENCRYPT, 6658 &wrappedMS, NULL); 6659 PK11_FreeSlot(slot); 6660 if (pwSpec->master_secret == NULL) { 6661 break; 6662 } 6663 } 6664 6665 /* Got a Match */ 6666 SSL_AtomicIncrementLong(& ssl3stats.hsh_sid_cache_hits ); 6667 6668 /* If we sent a session ticket, then this is a stateless resume. */ 6669 if (ss->xtnData.sentSessionTicketInClientHello) 6670 SSL_AtomicIncrementLong(& ssl3stats.hsh_sid_stateless_resumes ); 6671 6672 if (ssl3_ExtensionNegotiated(ss, ssl_session_ticket_xtn)) 6673 ss->ssl3.hs.ws = wait_new_session_ticket; 6674 else 6675 ss->ssl3.hs.ws = wait_change_cipher; 6676 6677 ss->ssl3.hs.isResuming = PR_TRUE; 6678 6679 /* copy the peer cert from the SID */ 6680 if (sid->peerCert != NULL) { 6681 ss->sec.peerCert = CERT_DupCertificate(sid->peerCert); 6682 ssl3_CopyPeerCertsFromSID(ss, sid); 6683 } 6684 6685 /* NULL value for PMS signifies re-use of the old MS */ 6686 rv = ssl3_InitPendingCipherSpec(ss, NULL); 6687 if (rv != SECSuccess) { 6688 goto alert_loser; /* err code was set */ 6689 } 6690 goto winner; 6691 } while (0); 6692 6693 if (sid_match) 6694 SSL_AtomicIncrementLong(& ssl3stats.hsh_sid_cache_not_ok ); 6695 else 6696 SSL_AtomicIncrementLong(& ssl3stats.hsh_sid_cache_misses ); 6697 6698 /* throw the old one away */ 6699 sid->u.ssl3.keys.resumable = PR_FALSE; 6700 if (ss->sec.uncache) 6701 (*ss->sec.uncache)(sid); 6702 ssl_FreeSID(sid); 6703 6704 /* get a new sid */ 6705 ss->sec.ci.sid = sid = ssl3_NewSessionID(ss, PR_FALSE); 6706 if (sid == NULL) { 6707 goto alert_loser; /* memory error is set. */ 6708 } 6709 6710 sid->version = ss->version; 6711 sid->u.ssl3.sessionIDLength = sidBytes.len; 6712 PORT_Memcpy(sid->u.ssl3.sessionID, sidBytes.data, sidBytes.len); 6713 6714 /* Copy Signed Certificate Timestamps, if any. */ 6715 if (ss->xtnData.signedCertTimestamps.data) { 6716 rv = SECITEM_CopyItem(NULL, &sid->u.ssl3.signedCertTimestamps, 6717 &ss->xtnData.signedCertTimestamps); 6718 if (rv != SECSuccess) 6719 goto loser; 6720 } 6721 6722 ss->ssl3.hs.isResuming = PR_FALSE; 6723 ss->ssl3.hs.ws = wait_server_cert; 6724 6725 winner: 6726 /* Clean up the temporary pointer to the handshake buffer. */ 6727 ss->xtnData.signedCertTimestamps.data = NULL; 6728 ss->xtnData.signedCertTimestamps.len = 0; 6729 6730 /* If we will need a ChannelID key then we make the callback now. This 6731 * allows the handshake to be restarted cleanly if the callback returns 6732 * SECWouldBlock. */ 6733 if (ssl3_ExtensionNegotiated(ss, ssl_channel_id_xtn)) { 6734 rv = ss->getChannelID(ss->getChannelIDArg, ss->fd, 6735 &ss->ssl3.channelIDPub, &ss->ssl3.channelID); 6736 if (rv == SECWouldBlock) { 6737 ssl3_SetAlwaysBlock(ss); 6738 return rv; 6739 } 6740 if (rv != SECSuccess || 6741 ss->ssl3.channelIDPub == NULL || 6742 ss->ssl3.channelID == NULL) { 6743 PORT_SetError(SSL_ERROR_GET_CHANNEL_ID_FAILED); 6744 desc = internal_error; 6745 goto alert_loser; 6746 } 6747 } 6748 6749 return SECSuccess; 6750 6751 alert_loser: 6752 (void)SSL3_SendAlert(ss, alert_fatal, desc); 6753 6754 loser: 6755 /* Clean up the temporary pointer to the handshake buffer. */ 6756 ss->xtnData.signedCertTimestamps.data = NULL; 6757 ss->xtnData.signedCertTimestamps.len = 0; 6758 errCode = ssl_MapLowLevelError(errCode); 6759 return SECFailure; 6760 } 6761 6762 /* ssl3_BigIntGreaterThanOne returns true iff |mpint|, taken as an unsigned, 6763 * big-endian integer is > 1 */ 6764 static PRBool 6765 ssl3_BigIntGreaterThanOne(const SECItem* mpint) { 6766 unsigned char firstNonZeroByte = 0; 6767 unsigned int i; 6768 6769 for (i = 0; i < mpint->len; i++) { 6770 if (mpint->data[i]) { 6771 firstNonZeroByte = mpint->data[i]; 6772 break; 6773 } 6774 } 6775 6776 if (firstNonZeroByte == 0) 6777 return PR_FALSE; 6778 if (firstNonZeroByte > 1) 6779 return PR_TRUE; 6780 6781 /* firstNonZeroByte == 1, therefore mpint > 1 iff the first non-zero byte 6782 * is followed by another byte. */ 6783 return (i < mpint->len - 1); 6784 } 6785 6786 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 6787 * ssl3 ServerKeyExchange message. 6788 * Caller must hold Handshake and RecvBuf locks. 6789 */ 6790 static SECStatus 6791 ssl3_HandleServerKeyExchange(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 6792 { 6793 PLArenaPool * arena = NULL; 6794 SECKEYPublicKey *peerKey = NULL; 6795 PRBool isTLS, isTLS12; 6796 SECStatus rv; 6797 int errCode = SSL_ERROR_RX_MALFORMED_SERVER_KEY_EXCH; 6798 SSL3AlertDescription desc = illegal_parameter; 6799 SSL3Hashes hashes; 6800 SECItem signature = {siBuffer, NULL, 0}; 6801 SSL3SignatureAndHashAlgorithm sigAndHash; 6802 6803 sigAndHash.hashAlg = SEC_OID_UNKNOWN; 6804 6805 SSL_TRC(3, ("%d: SSL3[%d]: handle server_key_exchange handshake", 6806 SSL_GETPID(), ss->fd)); 6807 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 6808 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 6809 6810 if (ss->ssl3.hs.ws != wait_server_key && 6811 ss->ssl3.hs.ws != wait_server_cert) { 6812 errCode = SSL_ERROR_RX_UNEXPECTED_SERVER_KEY_EXCH; 6813 desc = unexpected_message; 6814 goto alert_loser; 6815 } 6816 if (ss->sec.peerCert == NULL) { 6817 errCode = SSL_ERROR_RX_UNEXPECTED_SERVER_KEY_EXCH; 6818 desc = unexpected_message; 6819 goto alert_loser; 6820 } 6821 6822 isTLS = (PRBool)(ss->ssl3.prSpec->version > SSL_LIBRARY_VERSION_3_0); 6823 isTLS12 = (PRBool)(ss->ssl3.prSpec->version >= SSL_LIBRARY_VERSION_TLS_1_2); 6824 6825 switch (ss->ssl3.hs.kea_def->exchKeyType) { 6826 6827 case kt_rsa: { 6828 SECItem modulus = {siBuffer, NULL, 0}; 6829 SECItem exponent = {siBuffer, NULL, 0}; 6830 6831 rv = ssl3_ConsumeHandshakeVariable(ss, &modulus, 2, &b, &length); 6832 if (rv != SECSuccess) { 6833 goto loser; /* malformed. */ 6834 } 6835 rv = ssl3_ConsumeHandshakeVariable(ss, &exponent, 2, &b, &length); 6836 if (rv != SECSuccess) { 6837 goto loser; /* malformed. */ 6838 } 6839 if (isTLS12) { 6840 rv = ssl3_ConsumeSignatureAndHashAlgorithm(ss, &b, &length, 6841 &sigAndHash); 6842 if (rv != SECSuccess) { 6843 goto loser; /* malformed or unsupported. */ 6844 } 6845 rv = ssl3_CheckSignatureAndHashAlgorithmConsistency( 6846 &sigAndHash, ss->sec.peerCert); 6847 if (rv != SECSuccess) { 6848 goto loser; 6849 } 6850 } 6851 rv = ssl3_ConsumeHandshakeVariable(ss, &signature, 2, &b, &length); 6852 if (rv != SECSuccess) { 6853 goto loser; /* malformed. */ 6854 } 6855 if (length != 0) { 6856 if (isTLS) 6857 desc = decode_error; 6858 goto alert_loser; /* malformed. */ 6859 } 6860 6861 /* failures after this point are not malformed handshakes. */ 6862 /* TLS: send decrypt_error if signature failed. */ 6863 desc = isTLS ? decrypt_error : handshake_failure; 6864 6865 /* 6866 * check to make sure the hash is signed by right guy 6867 */ 6868 rv = ssl3_ComputeExportRSAKeyHash(sigAndHash.hashAlg, modulus, exponent, 6869 &ss->ssl3.hs.client_random, 6870 &ss->ssl3.hs.server_random, 6871 &hashes, ss->opt.bypassPKCS11); 6872 if (rv != SECSuccess) { 6873 errCode = 6874 ssl_MapLowLevelError(SSL_ERROR_SERVER_KEY_EXCHANGE_FAILURE); 6875 goto alert_loser; 6876 } 6877 rv = ssl3_VerifySignedHashes(&hashes, ss->sec.peerCert, &signature, 6878 isTLS, ss->pkcs11PinArg); 6879 if (rv != SECSuccess) { 6880 errCode = 6881 ssl_MapLowLevelError(SSL_ERROR_SERVER_KEY_EXCHANGE_FAILURE); 6882 goto alert_loser; 6883 } 6884 6885 /* 6886 * we really need to build a new key here because we can no longer 6887 * ignore calling SECKEY_DestroyPublicKey. Using the key may allocate 6888 * pkcs11 slots and ID's. 6889 */ 6890 arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); 6891 if (arena == NULL) { 6892 goto no_memory; 6893 } 6894 6895 peerKey = PORT_ArenaZNew(arena, SECKEYPublicKey); 6896 if (peerKey == NULL) { 6897 PORT_FreeArena(arena, PR_FALSE); 6898 goto no_memory; 6899 } 6900 6901 peerKey->arena = arena; 6902 peerKey->keyType = rsaKey; 6903 peerKey->pkcs11Slot = NULL; 6904 peerKey->pkcs11ID = CK_INVALID_HANDLE; 6905 if (SECITEM_CopyItem(arena, &peerKey->u.rsa.modulus, &modulus) || 6906 SECITEM_CopyItem(arena, &peerKey->u.rsa.publicExponent, &exponent)) 6907 { 6908 PORT_FreeArena(arena, PR_FALSE); 6909 goto no_memory; 6910 } 6911 ss->sec.peerKey = peerKey; 6912 ss->ssl3.hs.ws = wait_cert_request; 6913 return SECSuccess; 6914 } 6915 6916 case kt_dh: { 6917 SECItem dh_p = {siBuffer, NULL, 0}; 6918 SECItem dh_g = {siBuffer, NULL, 0}; 6919 SECItem dh_Ys = {siBuffer, NULL, 0}; 6920 6921 rv = ssl3_ConsumeHandshakeVariable(ss, &dh_p, 2, &b, &length); 6922 if (rv != SECSuccess) { 6923 goto loser; /* malformed. */ 6924 } 6925 if (dh_p.len < 512/8) { 6926 errCode = SSL_ERROR_WEAK_SERVER_EPHEMERAL_DH_KEY; 6927 goto alert_loser; 6928 } 6929 rv = ssl3_ConsumeHandshakeVariable(ss, &dh_g, 2, &b, &length); 6930 if (rv != SECSuccess) { 6931 goto loser; /* malformed. */ 6932 } 6933 if (dh_g.len > dh_p.len || !ssl3_BigIntGreaterThanOne(&dh_g)) 6934 goto alert_loser; 6935 rv = ssl3_ConsumeHandshakeVariable(ss, &dh_Ys, 2, &b, &length); 6936 if (rv != SECSuccess) { 6937 goto loser; /* malformed. */ 6938 } 6939 if (dh_Ys.len > dh_p.len || !ssl3_BigIntGreaterThanOne(&dh_Ys)) 6940 goto alert_loser; 6941 if (isTLS12) { 6942 rv = ssl3_ConsumeSignatureAndHashAlgorithm(ss, &b, &length, 6943 &sigAndHash); 6944 if (rv != SECSuccess) { 6945 goto loser; /* malformed or unsupported. */ 6946 } 6947 rv = ssl3_CheckSignatureAndHashAlgorithmConsistency( 6948 &sigAndHash, ss->sec.peerCert); 6949 if (rv != SECSuccess) { 6950 goto loser; 6951 } 6952 } 6953 rv = ssl3_ConsumeHandshakeVariable(ss, &signature, 2, &b, &length); 6954 if (rv != SECSuccess) { 6955 goto loser; /* malformed. */ 6956 } 6957 if (length != 0) { 6958 if (isTLS) 6959 desc = decode_error; 6960 goto alert_loser; /* malformed. */ 6961 } 6962 6963 PRINT_BUF(60, (NULL, "Server DH p", dh_p.data, dh_p.len)); 6964 PRINT_BUF(60, (NULL, "Server DH g", dh_g.data, dh_g.len)); 6965 PRINT_BUF(60, (NULL, "Server DH Ys", dh_Ys.data, dh_Ys.len)); 6966 6967 /* failures after this point are not malformed handshakes. */ 6968 /* TLS: send decrypt_error if signature failed. */ 6969 desc = isTLS ? decrypt_error : handshake_failure; 6970 6971 /* 6972 * check to make sure the hash is signed by right guy 6973 */ 6974 rv = ssl3_ComputeDHKeyHash(sigAndHash.hashAlg, dh_p, dh_g, dh_Ys, 6975 &ss->ssl3.hs.client_random, 6976 &ss->ssl3.hs.server_random, 6977 &hashes, ss->opt.bypassPKCS11); 6978 if (rv != SECSuccess) { 6979 errCode = 6980 ssl_MapLowLevelError(SSL_ERROR_SERVER_KEY_EXCHANGE_FAILURE); 6981 goto alert_loser; 6982 } 6983 rv = ssl3_VerifySignedHashes(&hashes, ss->sec.peerCert, &signature, 6984 isTLS, ss->pkcs11PinArg); 6985 if (rv != SECSuccess) { 6986 errCode = 6987 ssl_MapLowLevelError(SSL_ERROR_SERVER_KEY_EXCHANGE_FAILURE); 6988 goto alert_loser; 6989 } 6990 6991 /* 6992 * we really need to build a new key here because we can no longer 6993 * ignore calling SECKEY_DestroyPublicKey. Using the key may allocate 6994 * pkcs11 slots and ID's. 6995 */ 6996 arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); 6997 if (arena == NULL) { 6998 goto no_memory; 6999 } 7000 7001 ss->sec.peerKey = peerKey = PORT_ArenaZNew(arena, SECKEYPublicKey); 7002 if (peerKey == NULL) { 7003 goto no_memory; 7004 } 7005 7006 peerKey->arena = arena; 7007 peerKey->keyType = dhKey; 7008 peerKey->pkcs11Slot = NULL; 7009 peerKey->pkcs11ID = CK_INVALID_HANDLE; 7010 7011 if (SECITEM_CopyItem(arena, &peerKey->u.dh.prime, &dh_p) || 7012 SECITEM_CopyItem(arena, &peerKey->u.dh.base, &dh_g) || 7013 SECITEM_CopyItem(arena, &peerKey->u.dh.publicValue, &dh_Ys)) 7014 { 7015 PORT_FreeArena(arena, PR_FALSE); 7016 goto no_memory; 7017 } 7018 ss->sec.peerKey = peerKey; 7019 ss->ssl3.hs.ws = wait_cert_request; 7020 return SECSuccess; 7021 } 7022 7023 #ifdef NSS_ENABLE_ECC 7024 case kt_ecdh: 7025 rv = ssl3_HandleECDHServerKeyExchange(ss, b, length); 7026 return rv; 7027 #endif /* NSS_ENABLE_ECC */ 7028 7029 default: 7030 desc = handshake_failure; 7031 errCode = SEC_ERROR_UNSUPPORTED_KEYALG; 7032 break; /* goto alert_loser; */ 7033 } 7034 7035 alert_loser: 7036 (void)SSL3_SendAlert(ss, alert_fatal, desc); 7037 loser: 7038 PORT_SetError( errCode ); 7039 return SECFailure; 7040 7041 no_memory: /* no-memory error has already been set. */ 7042 ssl_MapLowLevelError(SSL_ERROR_SERVER_KEY_EXCHANGE_FAILURE); 7043 return SECFailure; 7044 } 7045 7046 7047 /* 7048 * Returns the TLS signature algorithm for the client authentication key and 7049 * whether it is an RSA or DSA key that may be able to sign only SHA-1 hashes. 7050 */ 7051 static SECStatus 7052 ssl3_ExtractClientKeyInfo(sslSocket *ss, 7053 TLSSignatureAlgorithm *sigAlg, 7054 PRBool *preferSha1) 7055 { 7056 SECStatus rv = SECSuccess; 7057 SECKEYPublicKey *pubk; 7058 7059 pubk = CERT_ExtractPublicKey(ss->ssl3.clientCertificate); 7060 if (pubk == NULL) { 7061 rv = SECFailure; 7062 goto done; 7063 } 7064 7065 rv = ssl3_TLSSignatureAlgorithmForKeyType(pubk->keyType, sigAlg); 7066 if (rv != SECSuccess) { 7067 goto done; 7068 } 7069 7070 #if defined(NSS_PLATFORM_CLIENT_AUTH) && defined(_WIN32) 7071 /* If the key is in CAPI, assume conservatively that the CAPI service 7072 * provider may be unable to sign SHA-256 hashes. 7073 */ 7074 if (ss->ssl3.platformClientKey->dwKeySpec != CERT_NCRYPT_KEY_SPEC) { 7075 /* CAPI only supports RSA and DSA signatures, so we don't need to 7076 * check the key type. */ 7077 *preferSha1 = PR_TRUE; 7078 goto done; 7079 } 7080 #endif /* NSS_PLATFORM_CLIENT_AUTH && _WIN32 */ 7081 7082 /* If the key is a 1024-bit RSA or DSA key, assume conservatively that 7083 * it may be unable to sign SHA-256 hashes. This is the case for older 7084 * Estonian ID cards that have 1024-bit RSA keys. In FIPS 186-2 and 7085 * older, DSA key size is at most 1024 bits and the hash function must 7086 * be SHA-1. 7087 */ 7088 if (pubk->keyType == rsaKey || pubk->keyType == dsaKey) { 7089 *preferSha1 = SECKEY_PublicKeyStrength(pubk) <= 128; 7090 } else { 7091 *preferSha1 = PR_FALSE; 7092 } 7093 7094 done: 7095 if (pubk) 7096 SECKEY_DestroyPublicKey(pubk); 7097 return rv; 7098 } 7099 7100 /* Destroys the backup handshake hash context if we don't need it. Note that 7101 * this function selects the hash algorithm for client authentication 7102 * signatures; ssl3_SendCertificateVerify uses the presence of the backup hash 7103 * to determine whether to use SHA-1 or SHA-256. */ 7104 static void 7105 ssl3_DestroyBackupHandshakeHashIfNotNeeded(sslSocket *ss, 7106 const SECItem *algorithms) 7107 { 7108 SECStatus rv; 7109 TLSSignatureAlgorithm sigAlg; 7110 PRBool preferSha1; 7111 PRBool supportsSha1 = PR_FALSE; 7112 PRBool supportsSha256 = PR_FALSE; 7113 PRBool needBackupHash = PR_FALSE; 7114 unsigned int i; 7115 7116 #ifndef NO_PKCS11_BYPASS 7117 /* Backup handshake hash is not supported in PKCS #11 bypass mode. */ 7118 if (ss->opt.bypassPKCS11) { 7119 PORT_Assert(!ss->ssl3.hs.backupHash); 7120 return; 7121 } 7122 #endif 7123 PORT_Assert(ss->ssl3.hs.backupHash); 7124 7125 /* Determine the key's signature algorithm and whether it prefers SHA-1. */ 7126 rv = ssl3_ExtractClientKeyInfo(ss, &sigAlg, &preferSha1); 7127 if (rv != SECSuccess) { 7128 goto done; 7129 } 7130 7131 /* Determine the server's hash support for that signature algorithm. */ 7132 for (i = 0; i < algorithms->len; i += 2) { 7133 if (algorithms->data[i+1] == sigAlg) { 7134 if (algorithms->data[i] == tls_hash_sha1) { 7135 supportsSha1 = PR_TRUE; 7136 } else if (algorithms->data[i] == tls_hash_sha256) { 7137 supportsSha256 = PR_TRUE; 7138 } 7139 } 7140 } 7141 7142 /* If either the server does not support SHA-256 or the client key prefers 7143 * SHA-1, leave the backup hash. */ 7144 if (supportsSha1 && (preferSha1 || !supportsSha256)) { 7145 needBackupHash = PR_TRUE; 7146 } 7147 7148 done: 7149 if (!needBackupHash) { 7150 PK11_DestroyContext(ss->ssl3.hs.backupHash, PR_TRUE); 7151 ss->ssl3.hs.backupHash = NULL; 7152 } 7153 } 7154 7155 typedef struct dnameNode { 7156 struct dnameNode *next; 7157 SECItem name; 7158 } dnameNode; 7159 7160 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 7161 * ssl3 Certificate Request message. 7162 * Caller must hold Handshake and RecvBuf locks. 7163 */ 7164 static SECStatus 7165 ssl3_HandleCertificateRequest(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 7166 { 7167 PLArenaPool * arena = NULL; 7168 dnameNode * node; 7169 PRInt32 remaining; 7170 PRBool isTLS = PR_FALSE; 7171 PRBool isTLS12 = PR_FALSE; 7172 int i; 7173 int errCode = SSL_ERROR_RX_MALFORMED_CERT_REQUEST; 7174 int nnames = 0; 7175 SECStatus rv; 7176 SSL3AlertDescription desc = illegal_parameter; 7177 SECItem cert_types = {siBuffer, NULL, 0}; 7178 SECItem algorithms = {siBuffer, NULL, 0}; 7179 CERTDistNames ca_list; 7180 #ifdef NSS_PLATFORM_CLIENT_AUTH 7181 CERTCertList * platform_cert_list = NULL; 7182 CERTCertListNode * certNode = NULL; 7183 #endif /* NSS_PLATFORM_CLIENT_AUTH */ 7184 7185 SSL_TRC(3, ("%d: SSL3[%d]: handle certificate_request handshake", 7186 SSL_GETPID(), ss->fd)); 7187 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 7188 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 7189 7190 if (ss->ssl3.hs.ws != wait_cert_request && 7191 ss->ssl3.hs.ws != wait_server_key) { 7192 desc = unexpected_message; 7193 errCode = SSL_ERROR_RX_UNEXPECTED_CERT_REQUEST; 7194 goto alert_loser; 7195 } 7196 7197 PORT_Assert(ss->ssl3.clientCertChain == NULL); 7198 PORT_Assert(ss->ssl3.clientCertificate == NULL); 7199 PORT_Assert(ss->ssl3.clientPrivateKey == NULL); 7200 PORT_Assert(ss->ssl3.platformClientKey == (PlatformKey)NULL); 7201 7202 isTLS = (PRBool)(ss->ssl3.prSpec->version > SSL_LIBRARY_VERSION_3_0); 7203 isTLS12 = (PRBool)(ss->ssl3.prSpec->version >= SSL_LIBRARY_VERSION_TLS_1_2); 7204 rv = ssl3_ConsumeHandshakeVariable(ss, &cert_types, 1, &b, &length); 7205 if (rv != SECSuccess) 7206 goto loser; /* malformed, alert has been sent */ 7207 7208 PORT_Assert(!ss->requestedCertTypes); 7209 ss->requestedCertTypes = &cert_types; 7210 7211 if (isTLS12) { 7212 rv = ssl3_ConsumeHandshakeVariable(ss, &algorithms, 2, &b, &length); 7213 if (rv != SECSuccess) 7214 goto loser; /* malformed, alert has been sent */ 7215 /* An empty or odd-length value is invalid. 7216 * SignatureAndHashAlgorithm 7217 * supported_signature_algorithms<2..2^16-2>; 7218 */ 7219 if (algorithms.len == 0 || (algorithms.len & 1) != 0) 7220 goto alert_loser; 7221 } 7222 7223 arena = ca_list.arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); 7224 if (arena == NULL) 7225 goto no_mem; 7226 7227 remaining = ssl3_ConsumeHandshakeNumber(ss, 2, &b, &length); 7228 if (remaining < 0) 7229 goto loser; /* malformed, alert has been sent */ 7230 7231 if ((PRUint32)remaining > length) 7232 goto alert_loser; 7233 7234 ca_list.head = node = PORT_ArenaZNew(arena, dnameNode); 7235 if (node == NULL) 7236 goto no_mem; 7237 7238 while (remaining > 0) { 7239 PRInt32 len; 7240 7241 if (remaining < 2) 7242 goto alert_loser; /* malformed */ 7243 7244 node->name.len = len = ssl3_ConsumeHandshakeNumber(ss, 2, &b, &length); 7245 if (len <= 0) 7246 goto loser; /* malformed, alert has been sent */ 7247 7248 remaining -= 2; 7249 if (remaining < len) 7250 goto alert_loser; /* malformed */ 7251 7252 node->name.data = b; 7253 b += len; 7254 length -= len; 7255 remaining -= len; 7256 nnames++; 7257 if (remaining <= 0) 7258 break; /* success */ 7259 7260 node->next = PORT_ArenaZNew(arena, dnameNode); 7261 node = node->next; 7262 if (node == NULL) 7263 goto no_mem; 7264 } 7265 7266 ca_list.nnames = nnames; 7267 ca_list.names = PORT_ArenaNewArray(arena, SECItem, nnames); 7268 if (nnames > 0 && ca_list.names == NULL) 7269 goto no_mem; 7270 7271 for(i = 0, node = (dnameNode*)ca_list.head; 7272 i < nnames; 7273 i++, node = node->next) { 7274 ca_list.names[i] = node->name; 7275 } 7276 7277 if (length != 0) 7278 goto alert_loser; /* malformed */ 7279 7280 desc = no_certificate; 7281 ss->ssl3.hs.ws = wait_hello_done; 7282 7283 #ifdef NSS_PLATFORM_CLIENT_AUTH 7284 if (ss->getPlatformClientAuthData != NULL) { 7285 /* XXX Should pass cert_types and algorithms in this call!! */ 7286 rv = (SECStatus)(*ss->getPlatformClientAuthData)( 7287 ss->getPlatformClientAuthDataArg, 7288 ss->fd, &ca_list, 7289 &platform_cert_list, 7290 (void**)&ss->ssl3.platformClientKey, 7291 &ss->ssl3.clientCertificate, 7292 &ss->ssl3.clientPrivateKey); 7293 } else 7294 #endif 7295 if (ss->getClientAuthData != NULL) { 7296 /* XXX Should pass cert_types and algorithms in this call!! */ 7297 rv = (SECStatus)(*ss->getClientAuthData)(ss->getClientAuthDataArg, 7298 ss->fd, &ca_list, 7299 &ss->ssl3.clientCertificate, 7300 &ss->ssl3.clientPrivateKey); 7301 } else { 7302 rv = SECFailure; /* force it to send a no_certificate alert */ 7303 } 7304 7305 switch (rv) { 7306 case SECWouldBlock: /* getClientAuthData has put up a dialog box. */ 7307 ssl3_SetAlwaysBlock(ss); 7308 break; /* not an error */ 7309 7310 case SECSuccess: 7311 #ifdef NSS_PLATFORM_CLIENT_AUTH 7312 if (!platform_cert_list || CERT_LIST_EMPTY(platform_cert_list) || 7313 !ss->ssl3.platformClientKey) { 7314 if (platform_cert_list) { 7315 CERT_DestroyCertList(platform_cert_list); 7316 platform_cert_list = NULL; 7317 } 7318 if (ss->ssl3.platformClientKey) { 7319 ssl_FreePlatformKey(ss->ssl3.platformClientKey); 7320 ss->ssl3.platformClientKey = (PlatformKey)NULL; 7321 } 7322 /* Fall through to NSS client auth check */ 7323 } else { 7324 certNode = CERT_LIST_HEAD(platform_cert_list); 7325 ss->ssl3.clientCertificate = CERT_DupCertificate(certNode->cert); 7326 7327 /* Setting ssl3.clientCertChain non-NULL will cause 7328 * ssl3_HandleServerHelloDone to call SendCertificate. 7329 * Note: clientCertChain should include the EE cert as 7330 * clientCertificate is ignored during the actual sending 7331 */ 7332 ss->ssl3.clientCertChain = 7333 hack_NewCertificateListFromCertList(platform_cert_list); 7334 CERT_DestroyCertList(platform_cert_list); 7335 platform_cert_list = NULL; 7336 if (ss->ssl3.clientCertChain == NULL) { 7337 if (ss->ssl3.clientCertificate != NULL) { 7338 CERT_DestroyCertificate(ss->ssl3.clientCertificate); 7339 ss->ssl3.clientCertificate = NULL; 7340 } 7341 if (ss->ssl3.platformClientKey) { 7342 ssl_FreePlatformKey(ss->ssl3.platformClientKey); 7343 ss->ssl3.platformClientKey = (PlatformKey)NULL; 7344 } 7345 goto send_no_certificate; 7346 } 7347 if (ss->ssl3.hs.hashType == handshake_hash_single) { 7348 ssl3_DestroyBackupHandshakeHashIfNotNeeded(ss, &algorithms); 7349 } 7350 break; /* not an error */ 7351 } 7352 #endif /* NSS_PLATFORM_CLIENT_AUTH */ 7353 /* check what the callback function returned */ 7354 if ((!ss->ssl3.clientCertificate) || (!ss->ssl3.clientPrivateKey)) { 7355 /* we are missing either the key or cert */ 7356 if (ss->ssl3.clientCertificate) { 7357 /* got a cert, but no key - free it */ 7358 CERT_DestroyCertificate(ss->ssl3.clientCertificate); 7359 ss->ssl3.clientCertificate = NULL; 7360 } 7361 if (ss->ssl3.clientPrivateKey) { 7362 /* got a key, but no cert - free it */ 7363 SECKEY_DestroyPrivateKey(ss->ssl3.clientPrivateKey); 7364 ss->ssl3.clientPrivateKey = NULL; 7365 } 7366 goto send_no_certificate; 7367 } 7368 /* Setting ssl3.clientCertChain non-NULL will cause 7369 * ssl3_HandleServerHelloDone to call SendCertificate. 7370 */ 7371 ss->ssl3.clientCertChain = CERT_CertChainFromCert( 7372 ss->ssl3.clientCertificate, 7373 certUsageSSLClient, PR_FALSE); 7374 if (ss->ssl3.clientCertChain == NULL) { 7375 CERT_DestroyCertificate(ss->ssl3.clientCertificate); 7376 ss->ssl3.clientCertificate = NULL; 7377 SECKEY_DestroyPrivateKey(ss->ssl3.clientPrivateKey); 7378 ss->ssl3.clientPrivateKey = NULL; 7379 goto send_no_certificate; 7380 } 7381 if (ss->ssl3.hs.hashType == handshake_hash_single) { 7382 ssl3_DestroyBackupHandshakeHashIfNotNeeded(ss, &algorithms); 7383 } 7384 break; /* not an error */ 7385 7386 case SECFailure: 7387 default: 7388 send_no_certificate: 7389 if (isTLS) { 7390 ss->ssl3.sendEmptyCert = PR_TRUE; 7391 } else { 7392 (void)SSL3_SendAlert(ss, alert_warning, no_certificate); 7393 } 7394 rv = SECSuccess; 7395 break; 7396 } 7397 goto done; 7398 7399 no_mem: 7400 rv = SECFailure; 7401 PORT_SetError(SEC_ERROR_NO_MEMORY); 7402 goto done; 7403 7404 alert_loser: 7405 if (isTLS && desc == illegal_parameter) 7406 desc = decode_error; 7407 (void)SSL3_SendAlert(ss, alert_fatal, desc); 7408 loser: 7409 PORT_SetError(errCode); 7410 rv = SECFailure; 7411 done: 7412 ss->requestedCertTypes = NULL; 7413 if (arena != NULL) 7414 PORT_FreeArena(arena, PR_FALSE); 7415 #ifdef NSS_PLATFORM_CLIENT_AUTH 7416 if (platform_cert_list) 7417 CERT_DestroyCertList(platform_cert_list); 7418 #endif 7419 return rv; 7420 } 7421 7422 /* 7423 * attempt to restart the handshake after asynchronously handling 7424 * a request for the client's certificate. 7425 * 7426 * inputs: 7427 * cert Client cert chosen by application. 7428 * Note: ssl takes this reference, and does not bump the 7429 * reference count. The caller should drop its reference 7430 * without calling CERT_DestroyCert after calling this function. 7431 * 7432 * key Private key associated with cert. This function takes 7433 * ownership of the private key, so the caller should drop its 7434 * reference without destroying the private key after this 7435 * function returns. 7436 * 7437 * certChain DER-encoded certs, client cert and its signers. 7438 * Note: ssl takes this reference, and does not copy the chain. 7439 * The caller should drop its reference without destroying the 7440 * chain. SSL will free the chain when it is done with it. 7441 * 7442 * Return value: XXX 7443 * 7444 * XXX This code only works on the initial handshake on a connection, XXX 7445 * It does not work on a subsequent handshake (redo). 7446 * 7447 * Caller holds 1stHandshakeLock. 7448 */ 7449 SECStatus 7450 ssl3_RestartHandshakeAfterCertReq(sslSocket * ss, 7451 CERTCertificate * cert, 7452 SECKEYPrivateKey * key, 7453 CERTCertificateList *certChain) 7454 { 7455 SECStatus rv = SECSuccess; 7456 7457 /* XXX This code only works on the initial handshake on a connection, 7458 ** XXX It does not work on a subsequent handshake (redo). 7459 */ 7460 if (ss->handshake != 0) { 7461 ss->handshake = ssl_GatherRecord1stHandshake; 7462 ss->ssl3.clientCertificate = cert; 7463 ss->ssl3.clientPrivateKey = key; 7464 ss->ssl3.clientCertChain = certChain; 7465 if (!cert || !key || !certChain) { 7466 /* we are missing the key, cert, or cert chain */ 7467 if (ss->ssl3.clientCertificate) { 7468 CERT_DestroyCertificate(ss->ssl3.clientCertificate); 7469 ss->ssl3.clientCertificate = NULL; 7470 } 7471 if (ss->ssl3.clientPrivateKey) { 7472 SECKEY_DestroyPrivateKey(ss->ssl3.clientPrivateKey); 7473 ss->ssl3.clientPrivateKey = NULL; 7474 } 7475 if (ss->ssl3.clientCertChain != NULL) { 7476 CERT_DestroyCertificateList(ss->ssl3.clientCertChain); 7477 ss->ssl3.clientCertChain = NULL; 7478 } 7479 if (ss->ssl3.prSpec->version > SSL_LIBRARY_VERSION_3_0) { 7480 ss->ssl3.sendEmptyCert = PR_TRUE; 7481 } else { 7482 (void)SSL3_SendAlert(ss, alert_warning, no_certificate); 7483 } 7484 } 7485 } else { 7486 if (cert) { 7487 CERT_DestroyCertificate(cert); 7488 } 7489 if (key) { 7490 SECKEY_DestroyPrivateKey(key); 7491 } 7492 if (certChain) { 7493 CERT_DestroyCertificateList(certChain); 7494 } 7495 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 7496 rv = SECFailure; 7497 } 7498 return rv; 7499 } 7500 7501 static SECStatus 7502 ssl3_CheckFalseStart(sslSocket *ss) 7503 { 7504 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 7505 PORT_Assert( !ss->ssl3.hs.authCertificatePending ); 7506 PORT_Assert( !ss->ssl3.hs.canFalseStart ); 7507 7508 if (!ss->canFalseStartCallback) { 7509 SSL_TRC(3, ("%d: SSL[%d]: no false start callback so no false start", 7510 SSL_GETPID(), ss->fd)); 7511 } else { 7512 PRBool maybeFalseStart; 7513 SECStatus rv; 7514 7515 /* An attacker can control the selected ciphersuite so we only wish to 7516 * do False Start in the case that the selected ciphersuite is 7517 * sufficiently strong that the attack can gain no advantage. 7518 * Therefore we always require an 80-bit cipher. */ 7519 ssl_GetSpecReadLock(ss); 7520 maybeFalseStart = ss->ssl3.cwSpec->cipher_def->secret_key_size >= 10; 7521 ssl_ReleaseSpecReadLock(ss); 7522 7523 if (!maybeFalseStart) { 7524 SSL_TRC(3, ("%d: SSL[%d]: no false start due to weak cipher", 7525 SSL_GETPID(), ss->fd)); 7526 } else { 7527 rv = (ss->canFalseStartCallback)(ss->fd, 7528 ss->canFalseStartCallbackData, 7529 &ss->ssl3.hs.canFalseStart); 7530 if (rv == SECSuccess) { 7531 SSL_TRC(3, ("%d: SSL[%d]: false start callback returned %s", 7532 SSL_GETPID(), ss->fd, 7533 ss->ssl3.hs.canFalseStart ? "TRUE" : "FALSE")); 7534 } else { 7535 SSL_TRC(3, ("%d: SSL[%d]: false start callback failed (%s)", 7536 SSL_GETPID(), ss->fd, 7537 PR_ErrorToName(PR_GetError()))); 7538 } 7539 return rv; 7540 } 7541 } 7542 7543 ss->ssl3.hs.canFalseStart = PR_FALSE; 7544 return SECSuccess; 7545 } 7546 7547 PRBool 7548 ssl3_WaitingForStartOfServerSecondRound(sslSocket *ss) 7549 { 7550 PRBool result; 7551 7552 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 7553 7554 switch (ss->ssl3.hs.ws) { 7555 case wait_new_session_ticket: 7556 result = PR_TRUE; 7557 break; 7558 case wait_change_cipher: 7559 result = !ssl3_ExtensionNegotiated(ss, ssl_session_ticket_xtn); 7560 break; 7561 default: 7562 result = PR_FALSE; 7563 break; 7564 } 7565 7566 return result; 7567 } 7568 7569 static SECStatus ssl3_SendClientSecondRound(sslSocket *ss); 7570 7571 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 7572 * ssl3 Server Hello Done message. 7573 * Caller must hold Handshake and RecvBuf locks. 7574 */ 7575 static SECStatus 7576 ssl3_HandleServerHelloDone(sslSocket *ss) 7577 { 7578 SECStatus rv; 7579 SSL3WaitState ws = ss->ssl3.hs.ws; 7580 7581 SSL_TRC(3, ("%d: SSL3[%d]: handle server_hello_done handshake", 7582 SSL_GETPID(), ss->fd)); 7583 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 7584 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 7585 7586 if (ws != wait_hello_done && 7587 ws != wait_server_cert && 7588 ws != wait_server_key && 7589 ws != wait_cert_request) { 7590 SSL3_SendAlert(ss, alert_fatal, unexpected_message); 7591 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HELLO_DONE); 7592 return SECFailure; 7593 } 7594 7595 rv = ssl3_SendClientSecondRound(ss); 7596 7597 return rv; 7598 } 7599 7600 /* Called from ssl3_HandleServerHelloDone and ssl3_AuthCertificateComplete. 7601 * 7602 * Caller must hold Handshake and RecvBuf locks. 7603 */ 7604 static SECStatus 7605 ssl3_SendClientSecondRound(sslSocket *ss) 7606 { 7607 SECStatus rv; 7608 PRBool sendClientCert; 7609 7610 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 7611 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 7612 7613 sendClientCert = !ss->ssl3.sendEmptyCert && 7614 ss->ssl3.clientCertChain != NULL && 7615 (ss->ssl3.platformClientKey || 7616 ss->ssl3.clientPrivateKey != NULL); 7617 7618 if (!sendClientCert && 7619 ss->ssl3.hs.hashType == handshake_hash_single && 7620 ss->ssl3.hs.backupHash) { 7621 /* Don't need the backup handshake hash. */ 7622 PK11_DestroyContext(ss->ssl3.hs.backupHash, PR_TRUE); 7623 ss->ssl3.hs.backupHash = NULL; 7624 } 7625 7626 /* We must wait for the server's certificate to be authenticated before 7627 * sending the client certificate in order to disclosing the client 7628 * certificate to an attacker that does not have a valid cert for the 7629 * domain we are connecting to. 7630 * 7631 * XXX: We should do the same for the NPN extension, but for that we 7632 * need an option to give the application the ability to leak the NPN 7633 * information to get better performance. 7634 * 7635 * During the initial handshake on a connection, we never send/receive 7636 * application data until we have authenticated the server's certificate; 7637 * i.e. we have fully authenticated the handshake before using the cipher 7638 * specs agreed upon for that handshake. During a renegotiation, we may 7639 * continue sending and receiving application data during the handshake 7640 * interleaved with the handshake records. If we were to send the client's 7641 * second round for a renegotiation before the server's certificate was 7642 * authenticated, then the application data sent/received after this point 7643 * would be using cipher spec that hadn't been authenticated. By waiting 7644 * until the server's certificate has been authenticated during 7645 * renegotiations, we ensure that renegotiations have the same property 7646 * as initial handshakes; i.e. we have fully authenticated the handshake 7647 * before using the cipher specs agreed upon for that handshake for 7648 * application data. 7649 */ 7650 if (ss->ssl3.hs.restartTarget) { 7651 PR_NOT_REACHED("unexpected ss->ssl3.hs.restartTarget"); 7652 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 7653 return SECFailure; 7654 } 7655 if (ss->ssl3.hs.authCertificatePending && 7656 (sendClientCert || ss->ssl3.sendEmptyCert || ss->firstHsDone)) { 7657 SSL_TRC(3, ("%d: SSL3[%p]: deferring ssl3_SendClientSecondRound because" 7658 " certificate authentication is still pending.", 7659 SSL_GETPID(), ss->fd)); 7660 ss->ssl3.hs.restartTarget = ssl3_SendClientSecondRound; 7661 return SECWouldBlock; 7662 } 7663 7664 ssl_GetXmitBufLock(ss); /*******************************/ 7665 7666 if (ss->ssl3.sendEmptyCert) { 7667 ss->ssl3.sendEmptyCert = PR_FALSE; 7668 rv = ssl3_SendEmptyCertificate(ss); 7669 /* Don't send verify */ 7670 if (rv != SECSuccess) { 7671 goto loser; /* error code is set. */ 7672 } 7673 } else if (sendClientCert) { 7674 rv = ssl3_SendCertificate(ss); 7675 if (rv != SECSuccess) { 7676 goto loser; /* error code is set. */ 7677 } 7678 } 7679 7680 rv = ssl3_SendClientKeyExchange(ss); 7681 if (rv != SECSuccess) { 7682 goto loser; /* err is set. */ 7683 } 7684 7685 if (sendClientCert) { 7686 rv = ssl3_SendCertificateVerify(ss); 7687 if (rv != SECSuccess) { 7688 goto loser; /* err is set. */ 7689 } 7690 } 7691 7692 rv = ssl3_SendChangeCipherSpecs(ss); 7693 if (rv != SECSuccess) { 7694 goto loser; /* err code was set. */ 7695 } 7696 7697 /* This must be done after we've set ss->ssl3.cwSpec in 7698 * ssl3_SendChangeCipherSpecs because SSL_GetChannelInfo uses information 7699 * from cwSpec. This must be done before we call ssl3_CheckFalseStart 7700 * because the false start callback (if any) may need the information from 7701 * the functions that depend on this being set. 7702 */ 7703 ss->enoughFirstHsDone = PR_TRUE; 7704 7705 if (!ss->firstHsDone) { 7706 /* XXX: If the server's certificate hasn't been authenticated by this 7707 * point, then we may be leaking this NPN message to an attacker. 7708 */ 7709 rv = ssl3_SendNextProto(ss); 7710 if (rv != SECSuccess) { 7711 goto loser; /* err code was set. */ 7712 } 7713 } 7714 7715 rv = ssl3_SendEncryptedExtensions(ss); 7716 if (rv != SECSuccess) { 7717 goto loser; /* err code was set. */ 7718 } 7719 7720 if (!ss->firstHsDone) { 7721 if (ss->opt.enableFalseStart) { 7722 if (!ss->ssl3.hs.authCertificatePending) { 7723 /* When we fix bug 589047, we will need to know whether we are 7724 * false starting before we try to flush the client second 7725 * round to the network. With that in mind, we purposefully 7726 * call ssl3_CheckFalseStart before calling ssl3_SendFinished, 7727 * which includes a call to ssl3_FlushHandshake, so that 7728 * no application develops a reliance on such flushing being 7729 * done before its false start callback is called. 7730 */ 7731 ssl_ReleaseXmitBufLock(ss); 7732 rv = ssl3_CheckFalseStart(ss); 7733 ssl_GetXmitBufLock(ss); 7734 if (rv != SECSuccess) { 7735 goto loser; 7736 } 7737 } else { 7738 /* The certificate authentication and the server's Finished 7739 * message are racing each other. If the certificate 7740 * authentication wins, then we will try to false start in 7741 * ssl3_AuthCertificateComplete. 7742 */ 7743 SSL_TRC(3, ("%d: SSL3[%p]: deferring false start check because" 7744 " certificate authentication is still pending.", 7745 SSL_GETPID(), ss->fd)); 7746 } 7747 } 7748 } 7749 7750 rv = ssl3_SendFinished(ss, 0); 7751 if (rv != SECSuccess) { 7752 goto loser; /* err code was set. */ 7753 } 7754 7755 ssl_ReleaseXmitBufLock(ss); /*******************************/ 7756 7757 if (!ss->ssl3.hs.isResuming && 7758 ssl3_ExtensionNegotiated(ss, ssl_channel_id_xtn)) { 7759 /* If we are negotiating ChannelID on a full handshake then we record 7760 * the handshake hashes in |sid| at this point. They will be needed in 7761 * the event that we resume this session and use ChannelID on the 7762 * resumption handshake. */ 7763 SSL3Hashes hashes; 7764 SECItem *originalHandshakeHash = 7765 &ss->sec.ci.sid->u.ssl3.originalHandshakeHash; 7766 PORT_Assert(ss->sec.ci.sid->cached == never_cached); 7767 7768 ssl_GetSpecReadLock(ss); 7769 PORT_Assert(ss->version > SSL_LIBRARY_VERSION_3_0); 7770 rv = ssl3_ComputeHandshakeHashes(ss, ss->ssl3.cwSpec, &hashes, 0); 7771 ssl_ReleaseSpecReadLock(ss); 7772 if (rv != SECSuccess) { 7773 return rv; 7774 } 7775 7776 PORT_Assert(originalHandshakeHash->len == 0); 7777 originalHandshakeHash->data = PORT_Alloc(hashes.len); 7778 if (!originalHandshakeHash->data) 7779 return SECFailure; 7780 originalHandshakeHash->len = hashes.len; 7781 memcpy(originalHandshakeHash->data, hashes.u.raw, hashes.len); 7782 } 7783 7784 if (ssl3_ExtensionNegotiated(ss, ssl_session_ticket_xtn)) 7785 ss->ssl3.hs.ws = wait_new_session_ticket; 7786 else 7787 ss->ssl3.hs.ws = wait_change_cipher; 7788 7789 PORT_Assert(ssl3_WaitingForStartOfServerSecondRound(ss)); 7790 7791 return SECSuccess; 7792 7793 loser: 7794 ssl_ReleaseXmitBufLock(ss); 7795 return rv; 7796 } 7797 7798 /* 7799 * Routines used by servers 7800 */ 7801 static SECStatus 7802 ssl3_SendHelloRequest(sslSocket *ss) 7803 { 7804 SECStatus rv; 7805 7806 SSL_TRC(3, ("%d: SSL3[%d]: send hello_request handshake", SSL_GETPID(), 7807 ss->fd)); 7808 7809 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 7810 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss) ); 7811 7812 rv = ssl3_AppendHandshakeHeader(ss, hello_request, 0); 7813 if (rv != SECSuccess) { 7814 return rv; /* err set by AppendHandshake */ 7815 } 7816 rv = ssl3_FlushHandshake(ss, 0); 7817 if (rv != SECSuccess) { 7818 return rv; /* error code set by ssl3_FlushHandshake */ 7819 } 7820 ss->ssl3.hs.ws = wait_client_hello; 7821 return SECSuccess; 7822 } 7823 7824 /* 7825 * Called from: 7826 * ssl3_HandleClientHello() 7827 */ 7828 static SECComparison 7829 ssl3_ServerNameCompare(const SECItem *name1, const SECItem *name2) 7830 { 7831 if (!name1 != !name2) { 7832 return SECLessThan; 7833 } 7834 if (!name1) { 7835 return SECEqual; 7836 } 7837 if (name1->type != name2->type) { 7838 return SECLessThan; 7839 } 7840 return SECITEM_CompareItem(name1, name2); 7841 } 7842 7843 /* Sets memory error when returning NULL. 7844 * Called from: 7845 * ssl3_SendClientHello() 7846 * ssl3_HandleServerHello() 7847 * ssl3_HandleClientHello() 7848 * ssl3_HandleV2ClientHello() 7849 */ 7850 sslSessionID * 7851 ssl3_NewSessionID(sslSocket *ss, PRBool is_server) 7852 { 7853 sslSessionID *sid; 7854 7855 sid = PORT_ZNew(sslSessionID); 7856 if (sid == NULL) 7857 return sid; 7858 7859 if (is_server) { 7860 const SECItem * srvName; 7861 SECStatus rv = SECSuccess; 7862 7863 ssl_GetSpecReadLock(ss); /********************************/ 7864 srvName = &ss->ssl3.prSpec->srvVirtName; 7865 if (srvName->len && srvName->data) { 7866 rv = SECITEM_CopyItem(NULL, &sid->u.ssl3.srvName, srvName); 7867 } 7868 ssl_ReleaseSpecReadLock(ss); /************************************/ 7869 if (rv != SECSuccess) { 7870 PORT_Free(sid); 7871 return NULL; 7872 } 7873 } 7874 sid->peerID = (ss->peerID == NULL) ? NULL : PORT_Strdup(ss->peerID); 7875 sid->urlSvrName = (ss->url == NULL) ? NULL : PORT_Strdup(ss->url); 7876 sid->addr = ss->sec.ci.peer; 7877 sid->port = ss->sec.ci.port; 7878 sid->references = 1; 7879 sid->cached = never_cached; 7880 sid->version = ss->version; 7881 7882 sid->u.ssl3.keys.resumable = PR_TRUE; 7883 sid->u.ssl3.policy = SSL_ALLOWED; 7884 sid->u.ssl3.clientWriteKey = NULL; 7885 sid->u.ssl3.serverWriteKey = NULL; 7886 7887 if (is_server) { 7888 SECStatus rv; 7889 int pid = SSL_GETPID(); 7890 7891 sid->u.ssl3.sessionIDLength = SSL3_SESSIONID_BYTES; 7892 sid->u.ssl3.sessionID[0] = (pid >> 8) & 0xff; 7893 sid->u.ssl3.sessionID[1] = pid & 0xff; 7894 rv = PK11_GenerateRandom(sid->u.ssl3.sessionID + 2, 7895 SSL3_SESSIONID_BYTES -2); 7896 if (rv != SECSuccess) { 7897 ssl_FreeSID(sid); 7898 ssl_MapLowLevelError(SSL_ERROR_GENERATE_RANDOM_FAILURE); 7899 return NULL; 7900 } 7901 } 7902 return sid; 7903 } 7904 7905 /* Called from: ssl3_HandleClientHello, ssl3_HandleV2ClientHello */ 7906 static SECStatus 7907 ssl3_SendServerHelloSequence(sslSocket *ss) 7908 { 7909 const ssl3KEADef *kea_def; 7910 SECStatus rv; 7911 7912 SSL_TRC(3, ("%d: SSL3[%d]: begin send server_hello sequence", 7913 SSL_GETPID(), ss->fd)); 7914 7915 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 7916 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss) ); 7917 7918 rv = ssl3_SendServerHello(ss); 7919 if (rv != SECSuccess) { 7920 return rv; /* err code is set. */ 7921 } 7922 rv = ssl3_SendCertificate(ss); 7923 if (rv != SECSuccess) { 7924 return rv; /* error code is set. */ 7925 } 7926 rv = ssl3_SendCertificateStatus(ss); 7927 if (rv != SECSuccess) { 7928 return rv; /* error code is set. */ 7929 } 7930 /* We have to do this after the call to ssl3_SendServerHello, 7931 * because kea_def is set up by ssl3_SendServerHello(). 7932 */ 7933 kea_def = ss->ssl3.hs.kea_def; 7934 ss->ssl3.hs.usedStepDownKey = PR_FALSE; 7935 7936 if (kea_def->is_limited && kea_def->exchKeyType == kt_rsa) { 7937 /* see if we can legally use the key in the cert. */ 7938 int keyLen; /* bytes */ 7939 7940 keyLen = PK11_GetPrivateModulusLen( 7941 ss->serverCerts[kea_def->exchKeyType].SERVERKEY); 7942 7943 if (keyLen > 0 && 7944 keyLen * BPB <= kea_def->key_size_limit ) { 7945 /* XXX AND cert is not signing only!! */ 7946 /* just fall through and use it. */ 7947 } else if (ss->stepDownKeyPair != NULL) { 7948 ss->ssl3.hs.usedStepDownKey = PR_TRUE; 7949 rv = ssl3_SendServerKeyExchange(ss); 7950 if (rv != SECSuccess) { 7951 return rv; /* err code was set. */ 7952 } 7953 } else { 7954 #ifndef HACKED_EXPORT_SERVER 7955 PORT_SetError(SSL_ERROR_PUB_KEY_SIZE_LIMIT_EXCEEDED); 7956 return rv; 7957 #endif 7958 } 7959 #ifdef NSS_ENABLE_ECC 7960 } else if ((kea_def->kea == kea_ecdhe_rsa) || 7961 (kea_def->kea == kea_ecdhe_ecdsa)) { 7962 rv = ssl3_SendServerKeyExchange(ss); 7963 if (rv != SECSuccess) { 7964 return rv; /* err code was set. */ 7965 } 7966 #endif /* NSS_ENABLE_ECC */ 7967 } 7968 7969 if (ss->opt.requestCertificate) { 7970 rv = ssl3_SendCertificateRequest(ss); 7971 if (rv != SECSuccess) { 7972 return rv; /* err code is set. */ 7973 } 7974 } 7975 rv = ssl3_SendServerHelloDone(ss); 7976 if (rv != SECSuccess) { 7977 return rv; /* err code is set. */ 7978 } 7979 7980 ss->ssl3.hs.ws = (ss->opt.requestCertificate) ? wait_client_cert 7981 : wait_client_key; 7982 return SECSuccess; 7983 } 7984 7985 /* An empty TLS Renegotiation Info (RI) extension */ 7986 static const PRUint8 emptyRIext[5] = {0xff, 0x01, 0x00, 0x01, 0x00}; 7987 7988 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 7989 * ssl3 Client Hello message. 7990 * Caller must hold Handshake and RecvBuf locks. 7991 */ 7992 static SECStatus 7993 ssl3_HandleClientHello(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 7994 { 7995 sslSessionID * sid = NULL; 7996 PRInt32 tmp; 7997 unsigned int i; 7998 int j; 7999 SECStatus rv; 8000 int errCode = SSL_ERROR_RX_MALFORMED_CLIENT_HELLO; 8001 SSL3AlertDescription desc = illegal_parameter; 8002 SSL3AlertLevel level = alert_fatal; 8003 SSL3ProtocolVersion version; 8004 SECItem sidBytes = {siBuffer, NULL, 0}; 8005 SECItem cookieBytes = {siBuffer, NULL, 0}; 8006 SECItem suites = {siBuffer, NULL, 0}; 8007 SECItem comps = {siBuffer, NULL, 0}; 8008 PRBool haveSpecWriteLock = PR_FALSE; 8009 PRBool haveXmitBufLock = PR_FALSE; 8010 8011 SSL_TRC(3, ("%d: SSL3[%d]: handle client_hello handshake", 8012 SSL_GETPID(), ss->fd)); 8013 8014 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 8015 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 8016 PORT_Assert( ss->ssl3.initialized ); 8017 8018 /* Get peer name of client */ 8019 rv = ssl_GetPeerInfo(ss); 8020 if (rv != SECSuccess) { 8021 return rv; /* error code is set. */ 8022 } 8023 8024 /* Clearing the handshake pointers so that ssl_Do1stHandshake won't 8025 * call ssl2_HandleMessage. 8026 * 8027 * The issue here is that TLS ordinarily starts out in 8028 * ssl2_HandleV3HandshakeRecord() because of the backward-compatibility 8029 * code paths. That function zeroes these next pointers. But with DTLS, 8030 * we don't even try to do the v2 ClientHello so we skip that function 8031 * and need to reset these values here. 8032 */ 8033 if (IS_DTLS(ss)) { 8034 ss->nextHandshake = 0; 8035 ss->securityHandshake = 0; 8036 } 8037 8038 /* We might be starting session renegotiation in which case we should 8039 * clear previous state. 8040 */ 8041 PORT_Memset(&ss->xtnData, 0, sizeof(TLSExtensionData)); 8042 ss->statelessResume = PR_FALSE; 8043 8044 if ((ss->ssl3.hs.ws != wait_client_hello) && 8045 (ss->ssl3.hs.ws != idle_handshake)) { 8046 desc = unexpected_message; 8047 errCode = SSL_ERROR_RX_UNEXPECTED_CLIENT_HELLO; 8048 goto alert_loser; 8049 } 8050 if (ss->ssl3.hs.ws == idle_handshake && 8051 ss->opt.enableRenegotiation == SSL_RENEGOTIATE_NEVER) { 8052 desc = no_renegotiation; 8053 level = alert_warning; 8054 errCode = SSL_ERROR_RENEGOTIATION_NOT_ALLOWED; 8055 goto alert_loser; 8056 } 8057 8058 if (IS_DTLS(ss)) { 8059 dtls_RehandshakeCleanup(ss); 8060 } 8061 8062 tmp = ssl3_ConsumeHandshakeNumber(ss, 2, &b, &length); 8063 if (tmp < 0) 8064 goto loser; /* malformed, alert already sent */ 8065 8066 /* Translate the version */ 8067 if (IS_DTLS(ss)) { 8068 ss->clientHelloVersion = version = 8069 dtls_DTLSVersionToTLSVersion((SSL3ProtocolVersion)tmp); 8070 } else { 8071 ss->clientHelloVersion = version = (SSL3ProtocolVersion)tmp; 8072 } 8073 8074 rv = ssl3_NegotiateVersion(ss, version, PR_TRUE); 8075 if (rv != SECSuccess) { 8076 desc = (version > SSL_LIBRARY_VERSION_3_0) ? protocol_version 8077 : handshake_failure; 8078 errCode = SSL_ERROR_NO_CYPHER_OVERLAP; 8079 goto alert_loser; 8080 } 8081 8082 rv = ssl3_InitHandshakeHashes(ss); 8083 if (rv != SECSuccess) { 8084 desc = internal_error; 8085 errCode = PORT_GetError(); 8086 goto alert_loser; 8087 } 8088 8089 /* grab the client random data. */ 8090 rv = ssl3_ConsumeHandshake( 8091 ss, &ss->ssl3.hs.client_random, SSL3_RANDOM_LENGTH, &b, &length); 8092 if (rv != SECSuccess) { 8093 goto loser; /* malformed */ 8094 } 8095 8096 /* grab the client's SID, if present. */ 8097 rv = ssl3_ConsumeHandshakeVariable(ss, &sidBytes, 1, &b, &length); 8098 if (rv != SECSuccess) { 8099 goto loser; /* malformed */ 8100 } 8101 8102 /* grab the client's cookie, if present. */ 8103 if (IS_DTLS(ss)) { 8104 rv = ssl3_ConsumeHandshakeVariable(ss, &cookieBytes, 1, &b, &length); 8105 if (rv != SECSuccess) { 8106 goto loser; /* malformed */ 8107 } 8108 } 8109 8110 /* grab the list of cipher suites. */ 8111 rv = ssl3_ConsumeHandshakeVariable(ss, &suites, 2, &b, &length); 8112 if (rv != SECSuccess) { 8113 goto loser; /* malformed */ 8114 } 8115 8116 /* If the ClientHello version is less than our maximum version, check for a 8117 * TLS_FALLBACK_SCSV and reject the connection if found. */ 8118 if (ss->vrange.max > ss->clientHelloVersion) { 8119 for (i = 0; i + 1 < suites.len; i += 2) { 8120 PRUint16 suite_i = (suites.data[i] << 8) | suites.data[i + 1]; 8121 if (suite_i != TLS_FALLBACK_SCSV) 8122 continue; 8123 desc = inappropriate_fallback; 8124 errCode = SSL_ERROR_INAPPROPRIATE_FALLBACK_ALERT; 8125 goto alert_loser; 8126 } 8127 } 8128 8129 /* grab the list of compression methods. */ 8130 rv = ssl3_ConsumeHandshakeVariable(ss, &comps, 1, &b, &length); 8131 if (rv != SECSuccess) { 8132 goto loser; /* malformed */ 8133 } 8134 8135 desc = handshake_failure; 8136 8137 /* Handle TLS hello extensions for SSL3 & TLS. We do not know if 8138 * we are restarting a previous session until extensions have been 8139 * parsed, since we might have received a SessionTicket extension. 8140 * Note: we allow extensions even when negotiating SSL3 for the sake 8141 * of interoperability (and backwards compatibility). 8142 */ 8143 8144 if (length) { 8145 /* Get length of hello extensions */ 8146 PRInt32 extension_length; 8147 extension_length = ssl3_ConsumeHandshakeNumber(ss, 2, &b, &length); 8148 if (extension_length < 0) { 8149 goto loser; /* alert already sent */ 8150 } 8151 if (extension_length != length) { 8152 ssl3_DecodeError(ss); /* send alert */ 8153 goto loser; 8154 } 8155 rv = ssl3_HandleHelloExtensions(ss, &b, &length); 8156 if (rv != SECSuccess) { 8157 goto loser; /* malformed */ 8158 } 8159 } 8160 if (!ssl3_ExtensionNegotiated(ss, ssl_renegotiation_info_xtn)) { 8161 /* If we didn't receive an RI extension, look for the SCSV, 8162 * and if found, treat it just like an empty RI extension 8163 * by processing a local copy of an empty RI extension. 8164 */ 8165 for (i = 0; i + 1 < suites.len; i += 2) { 8166 PRUint16 suite_i = (suites.data[i] << 8) | suites.data[i + 1]; 8167 if (suite_i == TLS_EMPTY_RENEGOTIATION_INFO_SCSV) { 8168 SSL3Opaque * b2 = (SSL3Opaque *)emptyRIext; 8169 PRUint32 L2 = sizeof emptyRIext; 8170 (void)ssl3_HandleHelloExtensions(ss, &b2, &L2); 8171 break; 8172 } 8173 } 8174 } 8175 if (ss->firstHsDone && 8176 (ss->opt.enableRenegotiation == SSL_RENEGOTIATE_REQUIRES_XTN || 8177 ss->opt.enableRenegotiation == SSL_RENEGOTIATE_TRANSITIONAL) && 8178 !ssl3_ExtensionNegotiated(ss, ssl_renegotiation_info_xtn)) { 8179 desc = no_renegotiation; 8180 level = alert_warning; 8181 errCode = SSL_ERROR_RENEGOTIATION_NOT_ALLOWED; 8182 goto alert_loser; 8183 } 8184 if ((ss->opt.requireSafeNegotiation || 8185 (ss->firstHsDone && ss->peerRequestedProtection)) && 8186 !ssl3_ExtensionNegotiated(ss, ssl_renegotiation_info_xtn)) { 8187 desc = handshake_failure; 8188 errCode = SSL_ERROR_UNSAFE_NEGOTIATION; 8189 goto alert_loser; 8190 } 8191 8192 /* We do stateful resumes only if either of the following 8193 * conditions are satisfied: (1) the client does not support the 8194 * session ticket extension, or (2) the client support the session 8195 * ticket extension, but sent an empty ticket. 8196 */ 8197 if (!ssl3_ExtensionNegotiated(ss, ssl_session_ticket_xtn) || 8198 ss->xtnData.emptySessionTicket) { 8199 if (sidBytes.len > 0 && !ss->opt.noCache) { 8200 SSL_TRC(7, ("%d: SSL3[%d]: server, lookup client session-id for 0x%08x%08x%08x%08x", 8201 SSL_GETPID(), ss->fd, ss->sec.ci.peer.pr_s6_addr32[0], 8202 ss->sec.ci.peer.pr_s6_addr32[1], 8203 ss->sec.ci.peer.pr_s6_addr32[2], 8204 ss->sec.ci.peer.pr_s6_addr32[3])); 8205 if (ssl_sid_lookup) { 8206 sid = (*ssl_sid_lookup)(&ss->sec.ci.peer, sidBytes.data, 8207 sidBytes.len, ss->dbHandle); 8208 } else { 8209 errCode = SSL_ERROR_SERVER_CACHE_NOT_CONFIGURED; 8210 goto loser; 8211 } 8212 } 8213 } else if (ss->statelessResume) { 8214 /* Fill in the client's session ID if doing a stateless resume. 8215 * (When doing stateless resumes, server echos client's SessionID.) 8216 */ 8217 sid = ss->sec.ci.sid; 8218 PORT_Assert(sid != NULL); /* Should have already been filled in.*/ 8219 8220 if (sidBytes.len > 0 && sidBytes.len <= SSL3_SESSIONID_BYTES) { 8221 sid->u.ssl3.sessionIDLength = sidBytes.len; 8222 PORT_Memcpy(sid->u.ssl3.sessionID, sidBytes.data, 8223 sidBytes.len); 8224 sid->u.ssl3.sessionIDLength = sidBytes.len; 8225 } else { 8226 sid->u.ssl3.sessionIDLength = 0; 8227 } 8228 ss->sec.ci.sid = NULL; 8229 } 8230 8231 /* We only send a session ticket extension if the client supports 8232 * the extension and we are unable to do either a stateful or 8233 * stateless resume. 8234 * 8235 * TODO: send a session ticket if performing a stateful 8236 * resumption. (As per RFC4507, a server may issue a session 8237 * ticket while doing a (stateless or stateful) session resume, 8238 * but OpenSSL-0.9.8g does not accept session tickets while 8239 * resuming.) 8240 */ 8241 if (ssl3_ExtensionNegotiated(ss, ssl_session_ticket_xtn) && sid == NULL) { 8242 ssl3_RegisterServerHelloExtensionSender(ss, 8243 ssl_session_ticket_xtn, ssl3_SendSessionTicketXtn); 8244 } 8245 8246 if (sid != NULL) { 8247 /* We've found a session cache entry for this client. 8248 * Now, if we're going to require a client-auth cert, 8249 * and we don't already have this client's cert in the session cache, 8250 * and this is the first handshake on this connection (not a redo), 8251 * then drop this old cache entry and start a new session. 8252 */ 8253 if ((sid->peerCert == NULL) && ss->opt.requestCertificate && 8254 ((ss->opt.requireCertificate == SSL_REQUIRE_ALWAYS) || 8255 (ss->opt.requireCertificate == SSL_REQUIRE_NO_ERROR) || 8256 ((ss->opt.requireCertificate == SSL_REQUIRE_FIRST_HANDSHAKE) 8257 && !ss->firstHsDone))) { 8258 8259 SSL_AtomicIncrementLong(& ssl3stats.hch_sid_cache_not_ok ); 8260 if (ss->sec.uncache) 8261 ss->sec.uncache(sid); 8262 ssl_FreeSID(sid); 8263 sid = NULL; 8264 } 8265 } 8266 8267 #ifdef NSS_ENABLE_ECC 8268 /* Disable any ECC cipher suites for which we have no cert. */ 8269 ssl3_FilterECCipherSuitesByServerCerts(ss); 8270 #endif 8271 8272 if (IS_DTLS(ss)) { 8273 ssl3_DisableNonDTLSSuites(ss); 8274 } 8275 8276 if (!ssl3_HasGCMSupport()) { 8277 ssl3_DisableGCMSuites(ss); 8278 } 8279 8280 #ifdef PARANOID 8281 /* Look for a matching cipher suite. */ 8282 j = ssl3_config_match_init(ss); 8283 if (j <= 0) { /* no ciphers are working/supported by PK11 */ 8284 errCode = PORT_GetError(); /* error code is already set. */ 8285 goto alert_loser; 8286 } 8287 #endif 8288 8289 /* If we already have a session for this client, be sure to pick the 8290 ** same cipher suite and compression method we picked before. 8291 ** This is not a loop, despite appearances. 8292 */ 8293 if (sid) do { 8294 ssl3CipherSuiteCfg *suite; 8295 #ifdef PARANOID 8296 SSLVersionRange vrange = {ss->version, ss->version}; 8297 #endif 8298 8299 /* Check that the cached compression method is still enabled. */ 8300 if (!compressionEnabled(ss, sid->u.ssl3.compression)) 8301 break; 8302 8303 /* Check that the cached compression method is in the client's list */ 8304 for (i = 0; i < comps.len; i++) { 8305 if (comps.data[i] == sid->u.ssl3.compression) 8306 break; 8307 } 8308 if (i == comps.len) 8309 break; 8310 8311 suite = ss->cipherSuites; 8312 /* Find the entry for the cipher suite used in the cached session. */ 8313 for (j = ssl_V3_SUITES_IMPLEMENTED; j > 0; --j, ++suite) { 8314 if (suite->cipher_suite == sid->u.ssl3.cipherSuite) 8315 break; 8316 } 8317 PORT_Assert(j > 0); 8318 if (j <= 0) 8319 break; 8320 #ifdef PARANOID 8321 /* Double check that the cached cipher suite is still enabled, 8322 * implemented, and allowed by policy. Might have been disabled. 8323 * The product policy won't change during the process lifetime. 8324 * Implemented ("isPresent") shouldn't change for servers. 8325 */ 8326 if (!config_match(suite, ss->ssl3.policy, PR_TRUE, &vrange)) 8327 break; 8328 #else 8329 if (!suite->enabled) 8330 break; 8331 #endif 8332 /* Double check that the cached cipher suite is in the client's list */ 8333 for (i = 0; i + 1 < suites.len; i += 2) { 8334 PRUint16 suite_i = (suites.data[i] << 8) | suites.data[i + 1]; 8335 if (suite_i == suite->cipher_suite) { 8336 ss->ssl3.hs.cipher_suite = suite->cipher_suite; 8337 ss->ssl3.hs.suite_def = 8338 ssl_LookupCipherSuiteDef(ss->ssl3.hs.cipher_suite); 8339 8340 /* Use the cached compression method. */ 8341 ss->ssl3.hs.compression = sid->u.ssl3.compression; 8342 goto compression_found; 8343 } 8344 } 8345 } while (0); 8346 8347 /* START A NEW SESSION */ 8348 8349 #ifndef PARANOID 8350 /* Look for a matching cipher suite. */ 8351 j = ssl3_config_match_init(ss); 8352 if (j <= 0) { /* no ciphers are working/supported by PK11 */ 8353 errCode = PORT_GetError(); /* error code is already set. */ 8354 goto alert_loser; 8355 } 8356 #endif 8357 8358 /* Select a cipher suite. 8359 ** 8360 ** NOTE: This suite selection algorithm should be the same as the one in 8361 ** ssl3_HandleV2ClientHello(). 8362 ** 8363 ** If TLS 1.0 is enabled, we could handle the case where the client 8364 ** offered TLS 1.1 but offered only export cipher suites by choosing TLS 8365 ** 1.0 and selecting one of those export cipher suites. However, a secure 8366 ** TLS 1.1 client should not have export cipher suites enabled at all, 8367 ** and a TLS 1.1 client should definitely not be offering *only* export 8368 ** cipher suites. Therefore, we refuse to negotiate export cipher suites 8369 ** with any client that indicates support for TLS 1.1 or higher when we 8370 ** (the server) have TLS 1.1 support enabled. 8371 */ 8372 for (j = 0; j < ssl_V3_SUITES_IMPLEMENTED; j++) { 8373 ssl3CipherSuiteCfg *suite = &ss->cipherSuites[j]; 8374 SSLVersionRange vrange = {ss->version, ss->version}; 8375 if (!config_match(suite, ss->ssl3.policy, PR_TRUE, &vrange)) { 8376 continue; 8377 } 8378 for (i = 0; i + 1 < suites.len; i += 2) { 8379 PRUint16 suite_i = (suites.data[i] << 8) | suites.data[i + 1]; 8380 if (suite_i == suite->cipher_suite) { 8381 ss->ssl3.hs.cipher_suite = suite->cipher_suite; 8382 ss->ssl3.hs.suite_def = 8383 ssl_LookupCipherSuiteDef(ss->ssl3.hs.cipher_suite); 8384 goto suite_found; 8385 } 8386 } 8387 } 8388 errCode = SSL_ERROR_NO_CYPHER_OVERLAP; 8389 goto alert_loser; 8390 8391 suite_found: 8392 /* Select a compression algorithm. */ 8393 for (i = 0; i < comps.len; i++) { 8394 if (!compressionEnabled(ss, comps.data[i])) 8395 continue; 8396 for (j = 0; j < compressionMethodsCount; j++) { 8397 if (comps.data[i] == compressions[j]) { 8398 ss->ssl3.hs.compression = 8399 (SSLCompressionMethod)compressions[j]; 8400 goto compression_found; 8401 } 8402 } 8403 } 8404 errCode = SSL_ERROR_NO_COMPRESSION_OVERLAP; 8405 /* null compression must be supported */ 8406 goto alert_loser; 8407 8408 compression_found: 8409 suites.data = NULL; 8410 comps.data = NULL; 8411 8412 ss->sec.send = ssl3_SendApplicationData; 8413 8414 /* If there are any failures while processing the old sid, 8415 * we don't consider them to be errors. Instead, We just behave 8416 * as if the client had sent us no sid to begin with, and make a new one. 8417 */ 8418 if (sid != NULL) do { 8419 ssl3CipherSpec *pwSpec; 8420 SECItem wrappedMS; /* wrapped key */ 8421 8422 if (sid->version != ss->version || 8423 sid->u.ssl3.cipherSuite != ss->ssl3.hs.cipher_suite || 8424 sid->u.ssl3.compression != ss->ssl3.hs.compression) { 8425 break; /* not an error */ 8426 } 8427 8428 if (ss->sec.ci.sid) { 8429 if (ss->sec.uncache) 8430 ss->sec.uncache(ss->sec.ci.sid); 8431 PORT_Assert(ss->sec.ci.sid != sid); /* should be impossible, but ... */ 8432 if (ss->sec.ci.sid != sid) { 8433 ssl_FreeSID(ss->sec.ci.sid); 8434 } 8435 ss->sec.ci.sid = NULL; 8436 } 8437 /* we need to resurrect the master secret.... */ 8438 8439 ssl_GetSpecWriteLock(ss); haveSpecWriteLock = PR_TRUE; 8440 pwSpec = ss->ssl3.pwSpec; 8441 if (sid->u.ssl3.keys.msIsWrapped) { 8442 PK11SymKey * wrapKey; /* wrapping key */ 8443 CK_FLAGS keyFlags = 0; 8444 #ifndef NO_PKCS11_BYPASS 8445 if (ss->opt.bypassPKCS11) { 8446 /* we cannot restart a non-bypass session in a 8447 ** bypass socket. 8448 */ 8449 break; 8450 } 8451 #endif 8452 8453 wrapKey = getWrappingKey(ss, NULL, sid->u.ssl3.exchKeyType, 8454 sid->u.ssl3.masterWrapMech, 8455 ss->pkcs11PinArg); 8456 if (!wrapKey) { 8457 /* we have a SID cache entry, but no wrapping key for it??? */ 8458 break; 8459 } 8460 8461 if (ss->version > SSL_LIBRARY_VERSION_3_0) { /* isTLS */ 8462 keyFlags = CKF_SIGN | CKF_VERIFY; 8463 } 8464 8465 wrappedMS.data = sid->u.ssl3.keys.wrapped_master_secret; 8466 wrappedMS.len = sid->u.ssl3.keys.wrapped_master_secret_len; 8467 8468 /* unwrap the master secret. */ 8469 pwSpec->master_secret = 8470 PK11_UnwrapSymKeyWithFlags(wrapKey, sid->u.ssl3.masterWrapMech, 8471 NULL, &wrappedMS, CKM_SSL3_MASTER_KEY_DERIVE, 8472 CKA_DERIVE, sizeof(SSL3MasterSecret), keyFlags); 8473 PK11_FreeSymKey(wrapKey); 8474 if (pwSpec->master_secret == NULL) { 8475 break; /* not an error */ 8476 } 8477 #ifndef NO_PKCS11_BYPASS 8478 } else if (ss->opt.bypassPKCS11) { 8479 wrappedMS.data = sid->u.ssl3.keys.wrapped_master_secret; 8480 wrappedMS.len = sid->u.ssl3.keys.wrapped_master_secret_len; 8481 memcpy(pwSpec->raw_master_secret, wrappedMS.data, wrappedMS.len); 8482 pwSpec->msItem.data = pwSpec->raw_master_secret; 8483 pwSpec->msItem.len = wrappedMS.len; 8484 #endif 8485 } else { 8486 /* We CAN restart a bypass session in a non-bypass socket. */ 8487 /* need to import the raw master secret to session object */ 8488 PK11SlotInfo * slot; 8489 wrappedMS.data = sid->u.ssl3.keys.wrapped_master_secret; 8490 wrappedMS.len = sid->u.ssl3.keys.wrapped_master_secret_len; 8491 slot = PK11_GetInternalSlot(); 8492 pwSpec->master_secret = 8493 PK11_ImportSymKey(slot, CKM_SSL3_MASTER_KEY_DERIVE, 8494 PK11_OriginUnwrap, CKA_ENCRYPT, &wrappedMS, 8495 NULL); 8496 PK11_FreeSlot(slot); 8497 if (pwSpec->master_secret == NULL) { 8498 break; /* not an error */ 8499 } 8500 } 8501 ss->sec.ci.sid = sid; 8502 if (sid->peerCert != NULL) { 8503 ss->sec.peerCert = CERT_DupCertificate(sid->peerCert); 8504 ssl3_CopyPeerCertsFromSID(ss, sid); 8505 } 8506 8507 /* 8508 * Old SID passed all tests, so resume this old session. 8509 * 8510 * XXX make sure compression still matches 8511 */ 8512 SSL_AtomicIncrementLong(& ssl3stats.hch_sid_cache_hits ); 8513 if (ss->statelessResume) 8514 SSL_AtomicIncrementLong(& ssl3stats.hch_sid_stateless_resumes ); 8515 ss->ssl3.hs.isResuming = PR_TRUE; 8516 8517 ss->sec.authAlgorithm = sid->authAlgorithm; 8518 ss->sec.authKeyBits = sid->authKeyBits; 8519 ss->sec.keaType = sid->keaType; 8520 ss->sec.keaKeyBits = sid->keaKeyBits; 8521 8522 /* server sids don't remember the server cert we previously sent, 8523 ** but they do remember the kea type we originally used, so we 8524 ** can locate it again, provided that the current ssl socket 8525 ** has had its server certs configured the same as the previous one. 8526 */ 8527 ss->sec.localCert = 8528 CERT_DupCertificate(ss->serverCerts[sid->keaType].serverCert); 8529 8530 /* Copy cached name in to pending spec */ 8531 if (sid != NULL && 8532 sid->version > SSL_LIBRARY_VERSION_3_0 && 8533 sid->u.ssl3.srvName.len && sid->u.ssl3.srvName.data) { 8534 /* Set server name from sid */ 8535 SECItem *sidName = &sid->u.ssl3.srvName; 8536 SECItem *pwsName = &ss->ssl3.pwSpec->srvVirtName; 8537 if (pwsName->data) { 8538 SECITEM_FreeItem(pwsName, PR_FALSE); 8539 } 8540 rv = SECITEM_CopyItem(NULL, pwsName, sidName); 8541 if (rv != SECSuccess) { 8542 errCode = PORT_GetError(); 8543 desc = internal_error; 8544 goto alert_loser; 8545 } 8546 } 8547 8548 /* Clean up sni name array */ 8549 if (ssl3_ExtensionNegotiated(ss, ssl_server_name_xtn) && 8550 ss->xtnData.sniNameArr) { 8551 PORT_Free(ss->xtnData.sniNameArr); 8552 ss->xtnData.sniNameArr = NULL; 8553 ss->xtnData.sniNameArrSize = 0; 8554 } 8555 8556 ssl_GetXmitBufLock(ss); haveXmitBufLock = PR_TRUE; 8557 8558 rv = ssl3_SendServerHello(ss); 8559 if (rv != SECSuccess) { 8560 errCode = PORT_GetError(); 8561 goto loser; 8562 } 8563 8564 if (haveSpecWriteLock) { 8565 ssl_ReleaseSpecWriteLock(ss); 8566 haveSpecWriteLock = PR_FALSE; 8567 } 8568 8569 /* NULL value for PMS signifies re-use of the old MS */ 8570 rv = ssl3_InitPendingCipherSpec(ss, NULL); 8571 if (rv != SECSuccess) { 8572 errCode = PORT_GetError(); 8573 goto loser; 8574 } 8575 8576 rv = ssl3_SendChangeCipherSpecs(ss); 8577 if (rv != SECSuccess) { 8578 errCode = PORT_GetError(); 8579 goto loser; 8580 } 8581 rv = ssl3_SendFinished(ss, 0); 8582 ss->ssl3.hs.ws = wait_change_cipher; 8583 if (rv != SECSuccess) { 8584 errCode = PORT_GetError(); 8585 goto loser; 8586 } 8587 8588 if (haveXmitBufLock) { 8589 ssl_ReleaseXmitBufLock(ss); 8590 haveXmitBufLock = PR_FALSE; 8591 } 8592 8593 return SECSuccess; 8594 } while (0); 8595 8596 if (haveSpecWriteLock) { 8597 ssl_ReleaseSpecWriteLock(ss); 8598 haveSpecWriteLock = PR_FALSE; 8599 } 8600 8601 if (sid) { /* we had a sid, but it's no longer valid, free it */ 8602 SSL_AtomicIncrementLong(& ssl3stats.hch_sid_cache_not_ok ); 8603 if (ss->sec.uncache) 8604 ss->sec.uncache(sid); 8605 ssl_FreeSID(sid); 8606 sid = NULL; 8607 } 8608 SSL_AtomicIncrementLong(& ssl3stats.hch_sid_cache_misses ); 8609 8610 if (ssl3_ExtensionNegotiated(ss, ssl_server_name_xtn)) { 8611 int ret = 0; 8612 if (ss->sniSocketConfig) do { /* not a loop */ 8613 ret = SSL_SNI_SEND_ALERT; 8614 /* If extension is negotiated, the len of names should > 0. */ 8615 if (ss->xtnData.sniNameArrSize) { 8616 /* Calling client callback to reconfigure the socket. */ 8617 ret = (SECStatus)(*ss->sniSocketConfig)(ss->fd, 8618 ss->xtnData.sniNameArr, 8619 ss->xtnData.sniNameArrSize, 8620 ss->sniSocketConfigArg); 8621 } 8622 if (ret <= SSL_SNI_SEND_ALERT) { 8623 /* Application does not know the name or was not able to 8624 * properly reconfigure the socket. */ 8625 errCode = SSL_ERROR_UNRECOGNIZED_NAME_ALERT; 8626 desc = unrecognized_name; 8627 break; 8628 } else if (ret == SSL_SNI_CURRENT_CONFIG_IS_USED) { 8629 SECStatus rv = SECSuccess; 8630 SECItem * cwsName, *pwsName; 8631 8632 ssl_GetSpecWriteLock(ss); /*******************************/ 8633 pwsName = &ss->ssl3.pwSpec->srvVirtName; 8634 cwsName = &ss->ssl3.cwSpec->srvVirtName; 8635 #ifndef SSL_SNI_ALLOW_NAME_CHANGE_2HS 8636 /* not allow name change on the 2d HS */ 8637 if (ss->firstHsDone) { 8638 if (ssl3_ServerNameCompare(pwsName, cwsName)) { 8639 ssl_ReleaseSpecWriteLock(ss); /******************/ 8640 errCode = SSL_ERROR_UNRECOGNIZED_NAME_ALERT; 8641 desc = handshake_failure; 8642 ret = SSL_SNI_SEND_ALERT; 8643 break; 8644 } 8645 } 8646 #endif 8647 if (pwsName->data) { 8648 SECITEM_FreeItem(pwsName, PR_FALSE); 8649 } 8650 if (cwsName->data) { 8651 rv = SECITEM_CopyItem(NULL, pwsName, cwsName); 8652 } 8653 ssl_ReleaseSpecWriteLock(ss); /**************************/ 8654 if (rv != SECSuccess) { 8655 errCode = SSL_ERROR_INTERNAL_ERROR_ALERT; 8656 desc = internal_error; 8657 ret = SSL_SNI_SEND_ALERT; 8658 break; 8659 } 8660 } else if (ret < ss->xtnData.sniNameArrSize) { 8661 /* Application has configured new socket info. Lets check it 8662 * and save the name. */ 8663 SECStatus rv; 8664 SECItem * name = &ss->xtnData.sniNameArr[ret]; 8665 int configedCiphers; 8666 SECItem * pwsName; 8667 8668 /* get rid of the old name and save the newly picked. */ 8669 /* This code is protected by ssl3HandshakeLock. */ 8670 ssl_GetSpecWriteLock(ss); /*******************************/ 8671 #ifndef SSL_SNI_ALLOW_NAME_CHANGE_2HS 8672 /* not allow name change on the 2d HS */ 8673 if (ss->firstHsDone) { 8674 SECItem *cwsName = &ss->ssl3.cwSpec->srvVirtName; 8675 if (ssl3_ServerNameCompare(name, cwsName)) { 8676 ssl_ReleaseSpecWriteLock(ss); /******************/ 8677 errCode = SSL_ERROR_UNRECOGNIZED_NAME_ALERT; 8678 desc = handshake_failure; 8679 ret = SSL_SNI_SEND_ALERT; 8680 break; 8681 } 8682 } 8683 #endif 8684 pwsName = &ss->ssl3.pwSpec->srvVirtName; 8685 if (pwsName->data) { 8686 SECITEM_FreeItem(pwsName, PR_FALSE); 8687 } 8688 rv = SECITEM_CopyItem(NULL, pwsName, name); 8689 ssl_ReleaseSpecWriteLock(ss); /***************************/ 8690 if (rv != SECSuccess) { 8691 errCode = SSL_ERROR_INTERNAL_ERROR_ALERT; 8692 desc = internal_error; 8693 ret = SSL_SNI_SEND_ALERT; 8694 break; 8695 } 8696 configedCiphers = ssl3_config_match_init(ss); 8697 if (configedCiphers <= 0) { 8698 /* no ciphers are working/supported */ 8699 errCode = PORT_GetError(); 8700 desc = handshake_failure; 8701 ret = SSL_SNI_SEND_ALERT; 8702 break; 8703 } 8704 /* Need to tell the client that application has picked 8705 * the name from the offered list and reconfigured the socket. 8706 */ 8707 ssl3_RegisterServerHelloExtensionSender(ss, ssl_server_name_xtn, 8708 ssl3_SendServerNameXtn); 8709 } else { 8710 /* Callback returned index outside of the boundary. */ 8711 PORT_Assert(ret < ss->xtnData.sniNameArrSize); 8712 errCode = SSL_ERROR_INTERNAL_ERROR_ALERT; 8713 desc = internal_error; 8714 ret = SSL_SNI_SEND_ALERT; 8715 break; 8716 } 8717 } while (0); 8718 /* Free sniNameArr. The data that each SECItem in the array 8719 * points into is the data from the input buffer "b". It will 8720 * not be available outside the scope of this or it's child 8721 * functions.*/ 8722 if (ss->xtnData.sniNameArr) { 8723 PORT_Free(ss->xtnData.sniNameArr); 8724 ss->xtnData.sniNameArr = NULL; 8725 ss->xtnData.sniNameArrSize = 0; 8726 } 8727 if (ret <= SSL_SNI_SEND_ALERT) { 8728 /* desc and errCode should be set. */ 8729 goto alert_loser; 8730 } 8731 } 8732 #ifndef SSL_SNI_ALLOW_NAME_CHANGE_2HS 8733 else if (ss->firstHsDone) { 8734 /* Check that we don't have the name is current spec 8735 * if this extension was not negotiated on the 2d hs. */ 8736 PRBool passed = PR_TRUE; 8737 ssl_GetSpecReadLock(ss); /*******************************/ 8738 if (ss->ssl3.cwSpec->srvVirtName.data) { 8739 passed = PR_FALSE; 8740 } 8741 ssl_ReleaseSpecReadLock(ss); /***************************/ 8742 if (!passed) { 8743 errCode = SSL_ERROR_UNRECOGNIZED_NAME_ALERT; 8744 desc = handshake_failure; 8745 goto alert_loser; 8746 } 8747 } 8748 #endif 8749 8750 sid = ssl3_NewSessionID(ss, PR_TRUE); 8751 if (sid == NULL) { 8752 errCode = PORT_GetError(); 8753 goto loser; /* memory error is set. */ 8754 } 8755 ss->sec.ci.sid = sid; 8756 8757 ss->ssl3.hs.isResuming = PR_FALSE; 8758 ssl_GetXmitBufLock(ss); 8759 rv = ssl3_SendServerHelloSequence(ss); 8760 ssl_ReleaseXmitBufLock(ss); 8761 if (rv != SECSuccess) { 8762 errCode = PORT_GetError(); 8763 goto loser; 8764 } 8765 8766 if (haveXmitBufLock) { 8767 ssl_ReleaseXmitBufLock(ss); 8768 haveXmitBufLock = PR_FALSE; 8769 } 8770 8771 return SECSuccess; 8772 8773 alert_loser: 8774 if (haveSpecWriteLock) { 8775 ssl_ReleaseSpecWriteLock(ss); 8776 haveSpecWriteLock = PR_FALSE; 8777 } 8778 (void)SSL3_SendAlert(ss, level, desc); 8779 /* FALLTHRU */ 8780 loser: 8781 if (haveSpecWriteLock) { 8782 ssl_ReleaseSpecWriteLock(ss); 8783 haveSpecWriteLock = PR_FALSE; 8784 } 8785 8786 if (haveXmitBufLock) { 8787 ssl_ReleaseXmitBufLock(ss); 8788 haveXmitBufLock = PR_FALSE; 8789 } 8790 8791 PORT_SetError(errCode); 8792 return SECFailure; 8793 } 8794 8795 /* 8796 * ssl3_HandleV2ClientHello is used when a V2 formatted hello comes 8797 * in asking to use the V3 handshake. 8798 * Called from ssl2_HandleClientHelloMessage() in sslcon.c 8799 */ 8800 SECStatus 8801 ssl3_HandleV2ClientHello(sslSocket *ss, unsigned char *buffer, int length) 8802 { 8803 sslSessionID * sid = NULL; 8804 unsigned char * suites; 8805 unsigned char * random; 8806 SSL3ProtocolVersion version; 8807 SECStatus rv; 8808 int i; 8809 int j; 8810 int sid_length; 8811 int suite_length; 8812 int rand_length; 8813 int errCode = SSL_ERROR_RX_MALFORMED_CLIENT_HELLO; 8814 SSL3AlertDescription desc = handshake_failure; 8815 8816 SSL_TRC(3, ("%d: SSL3[%d]: handle v2 client_hello", SSL_GETPID(), ss->fd)); 8817 8818 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 8819 8820 ssl_GetSSL3HandshakeLock(ss); 8821 8822 PORT_Memset(&ss->xtnData, 0, sizeof(TLSExtensionData)); 8823 8824 rv = ssl3_InitState(ss); 8825 if (rv != SECSuccess) { 8826 ssl_ReleaseSSL3HandshakeLock(ss); 8827 return rv; /* ssl3_InitState has set the error code. */ 8828 } 8829 rv = ssl3_RestartHandshakeHashes(ss); 8830 if (rv != SECSuccess) { 8831 ssl_ReleaseSSL3HandshakeLock(ss); 8832 return rv; 8833 } 8834 8835 if (ss->ssl3.hs.ws != wait_client_hello) { 8836 desc = unexpected_message; 8837 errCode = SSL_ERROR_RX_UNEXPECTED_CLIENT_HELLO; 8838 goto loser; /* alert_loser */ 8839 } 8840 8841 version = (buffer[1] << 8) | buffer[2]; 8842 suite_length = (buffer[3] << 8) | buffer[4]; 8843 sid_length = (buffer[5] << 8) | buffer[6]; 8844 rand_length = (buffer[7] << 8) | buffer[8]; 8845 ss->clientHelloVersion = version; 8846 8847 rv = ssl3_NegotiateVersion(ss, version, PR_TRUE); 8848 if (rv != SECSuccess) { 8849 /* send back which ever alert client will understand. */ 8850 desc = (version > SSL_LIBRARY_VERSION_3_0) ? protocol_version : handshake_failure; 8851 errCode = SSL_ERROR_NO_CYPHER_OVERLAP; 8852 goto alert_loser; 8853 } 8854 8855 rv = ssl3_InitHandshakeHashes(ss); 8856 if (rv != SECSuccess) { 8857 desc = internal_error; 8858 errCode = PORT_GetError(); 8859 goto alert_loser; 8860 } 8861 8862 /* if we get a non-zero SID, just ignore it. */ 8863 if (length != 8864 SSL_HL_CLIENT_HELLO_HBYTES + suite_length + sid_length + rand_length) { 8865 SSL_DBG(("%d: SSL3[%d]: bad v2 client hello message, len=%d should=%d", 8866 SSL_GETPID(), ss->fd, length, 8867 SSL_HL_CLIENT_HELLO_HBYTES + suite_length + sid_length + 8868 rand_length)); 8869 goto loser; /* malformed */ /* alert_loser */ 8870 } 8871 8872 suites = buffer + SSL_HL_CLIENT_HELLO_HBYTES; 8873 random = suites + suite_length + sid_length; 8874 8875 if (rand_length < SSL_MIN_CHALLENGE_BYTES || 8876 rand_length > SSL_MAX_CHALLENGE_BYTES) { 8877 goto loser; /* malformed */ /* alert_loser */ 8878 } 8879 8880 PORT_Assert(SSL_MAX_CHALLENGE_BYTES == SSL3_RANDOM_LENGTH); 8881 8882 PORT_Memset(&ss->ssl3.hs.client_random, 0, SSL3_RANDOM_LENGTH); 8883 PORT_Memcpy( 8884 &ss->ssl3.hs.client_random.rand[SSL3_RANDOM_LENGTH - rand_length], 8885 random, rand_length); 8886 8887 PRINT_BUF(60, (ss, "client random:", &ss->ssl3.hs.client_random.rand[0], 8888 SSL3_RANDOM_LENGTH)); 8889 #ifdef NSS_ENABLE_ECC 8890 /* Disable any ECC cipher suites for which we have no cert. */ 8891 ssl3_FilterECCipherSuitesByServerCerts(ss); 8892 #endif 8893 i = ssl3_config_match_init(ss); 8894 if (i <= 0) { 8895 errCode = PORT_GetError(); /* error code is already set. */ 8896 goto alert_loser; 8897 } 8898 8899 /* Select a cipher suite. 8900 ** 8901 ** NOTE: This suite selection algorithm should be the same as the one in 8902 ** ssl3_HandleClientHello(). 8903 ** 8904 ** See the comments about export cipher suites in ssl3_HandleClientHello(). 8905 */ 8906 for (j = 0; j < ssl_V3_SUITES_IMPLEMENTED; j++) { 8907 ssl3CipherSuiteCfg *suite = &ss->cipherSuites[j]; 8908 SSLVersionRange vrange = {ss->version, ss->version}; 8909 if (!config_match(suite, ss->ssl3.policy, PR_TRUE, &vrange)) { 8910 continue; 8911 } 8912 for (i = 0; i+2 < suite_length; i += 3) { 8913 PRUint32 suite_i = (suites[i] << 16)|(suites[i+1] << 8)|suites[i+2]; 8914 if (suite_i == suite->cipher_suite) { 8915 ss->ssl3.hs.cipher_suite = suite->cipher_suite; 8916 ss->ssl3.hs.suite_def = 8917 ssl_LookupCipherSuiteDef(ss->ssl3.hs.cipher_suite); 8918 goto suite_found; 8919 } 8920 } 8921 } 8922 errCode = SSL_ERROR_NO_CYPHER_OVERLAP; 8923 goto alert_loser; 8924 8925 suite_found: 8926 8927 /* Look for the SCSV, and if found, treat it just like an empty RI 8928 * extension by processing a local copy of an empty RI extension. 8929 */ 8930 for (i = 0; i+2 < suite_length; i += 3) { 8931 PRUint32 suite_i = (suites[i] << 16) | (suites[i+1] << 8) | suites[i+2]; 8932 if (suite_i == TLS_EMPTY_RENEGOTIATION_INFO_SCSV) { 8933 SSL3Opaque * b2 = (SSL3Opaque *)emptyRIext; 8934 PRUint32 L2 = sizeof emptyRIext; 8935 (void)ssl3_HandleHelloExtensions(ss, &b2, &L2); 8936 break; 8937 } 8938 } 8939 8940 if (ss->opt.requireSafeNegotiation && 8941 !ssl3_ExtensionNegotiated(ss, ssl_renegotiation_info_xtn)) { 8942 desc = handshake_failure; 8943 errCode = SSL_ERROR_UNSAFE_NEGOTIATION; 8944 goto alert_loser; 8945 } 8946 8947 ss->ssl3.hs.compression = ssl_compression_null; 8948 ss->sec.send = ssl3_SendApplicationData; 8949 8950 /* we don't even search for a cache hit here. It's just a miss. */ 8951 SSL_AtomicIncrementLong(& ssl3stats.hch_sid_cache_misses ); 8952 sid = ssl3_NewSessionID(ss, PR_TRUE); 8953 if (sid == NULL) { 8954 errCode = PORT_GetError(); 8955 goto loser; /* memory error is set. */ 8956 } 8957 ss->sec.ci.sid = sid; 8958 /* do not worry about memory leak of sid since it now belongs to ci */ 8959 8960 /* We have to update the handshake hashes before we can send stuff */ 8961 rv = ssl3_UpdateHandshakeHashes(ss, buffer, length); 8962 if (rv != SECSuccess) { 8963 errCode = PORT_GetError(); 8964 goto loser; 8965 } 8966 8967 ssl_GetXmitBufLock(ss); 8968 rv = ssl3_SendServerHelloSequence(ss); 8969 ssl_ReleaseXmitBufLock(ss); 8970 if (rv != SECSuccess) { 8971 errCode = PORT_GetError(); 8972 goto loser; 8973 } 8974 8975 /* XXX_1 The call stack to here is: 8976 * ssl_Do1stHandshake -> ssl2_HandleClientHelloMessage -> here. 8977 * ssl2_HandleClientHelloMessage returns whatever we return here. 8978 * ssl_Do1stHandshake will continue looping if it gets back either 8979 * SECSuccess or SECWouldBlock. 8980 * SECSuccess is preferable here. See XXX_1 in sslgathr.c. 8981 */ 8982 ssl_ReleaseSSL3HandshakeLock(ss); 8983 return SECSuccess; 8984 8985 alert_loser: 8986 SSL3_SendAlert(ss, alert_fatal, desc); 8987 loser: 8988 ssl_ReleaseSSL3HandshakeLock(ss); 8989 PORT_SetError(errCode); 8990 return SECFailure; 8991 } 8992 8993 /* The negotiated version number has been already placed in ss->version. 8994 ** 8995 ** Called from: ssl3_HandleClientHello (resuming session), 8996 ** ssl3_SendServerHelloSequence <- ssl3_HandleClientHello (new session), 8997 ** ssl3_SendServerHelloSequence <- ssl3_HandleV2ClientHello (new session) 8998 */ 8999 static SECStatus 9000 ssl3_SendServerHello(sslSocket *ss) 9001 { 9002 sslSessionID *sid; 9003 SECStatus rv; 9004 PRUint32 maxBytes = 65535; 9005 PRUint32 length; 9006 PRInt32 extensions_len = 0; 9007 SSL3ProtocolVersion version; 9008 9009 SSL_TRC(3, ("%d: SSL3[%d]: send server_hello handshake", SSL_GETPID(), 9010 ss->fd)); 9011 9012 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 9013 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 9014 9015 if (!IS_DTLS(ss)) { 9016 PORT_Assert(MSB(ss->version) == MSB(SSL_LIBRARY_VERSION_3_0)); 9017 9018 if (MSB(ss->version) != MSB(SSL_LIBRARY_VERSION_3_0)) { 9019 PORT_SetError(SSL_ERROR_NO_CYPHER_OVERLAP); 9020 return SECFailure; 9021 } 9022 } else { 9023 PORT_Assert(MSB(ss->version) == MSB(SSL_LIBRARY_VERSION_DTLS_1_0)); 9024 9025 if (MSB(ss->version) != MSB(SSL_LIBRARY_VERSION_DTLS_1_0)) { 9026 PORT_SetError(SSL_ERROR_NO_CYPHER_OVERLAP); 9027 return SECFailure; 9028 } 9029 } 9030 9031 sid = ss->sec.ci.sid; 9032 9033 extensions_len = ssl3_CallHelloExtensionSenders(ss, PR_FALSE, maxBytes, 9034 &ss->xtnData.serverSenders[0]); 9035 if (extensions_len > 0) 9036 extensions_len += 2; /* Add sizeof total extension length */ 9037 9038 length = sizeof(SSL3ProtocolVersion) + SSL3_RANDOM_LENGTH + 1 + 9039 ((sid == NULL) ? 0: sid->u.ssl3.sessionIDLength) + 9040 sizeof(ssl3CipherSuite) + 1 + extensions_len; 9041 rv = ssl3_AppendHandshakeHeader(ss, server_hello, length); 9042 if (rv != SECSuccess) { 9043 return rv; /* err set by AppendHandshake. */ 9044 } 9045 9046 if (IS_DTLS(ss)) { 9047 version = dtls_TLSVersionToDTLSVersion(ss->version); 9048 } else { 9049 version = ss->version; 9050 } 9051 9052 rv = ssl3_AppendHandshakeNumber(ss, version, 2); 9053 if (rv != SECSuccess) { 9054 return rv; /* err set by AppendHandshake. */ 9055 } 9056 rv = ssl3_GetNewRandom(&ss->ssl3.hs.server_random); 9057 if (rv != SECSuccess) { 9058 ssl_MapLowLevelError(SSL_ERROR_GENERATE_RANDOM_FAILURE); 9059 return rv; 9060 } 9061 rv = ssl3_AppendHandshake( 9062 ss, &ss->ssl3.hs.server_random, SSL3_RANDOM_LENGTH); 9063 if (rv != SECSuccess) { 9064 return rv; /* err set by AppendHandshake. */ 9065 } 9066 9067 if (sid) 9068 rv = ssl3_AppendHandshakeVariable( 9069 ss, sid->u.ssl3.sessionID, sid->u.ssl3.sessionIDLength, 1); 9070 else 9071 rv = ssl3_AppendHandshakeVariable(ss, NULL, 0, 1); 9072 if (rv != SECSuccess) { 9073 return rv; /* err set by AppendHandshake. */ 9074 } 9075 9076 rv = ssl3_AppendHandshakeNumber(ss, ss->ssl3.hs.cipher_suite, 2); 9077 if (rv != SECSuccess) { 9078 return rv; /* err set by AppendHandshake. */ 9079 } 9080 rv = ssl3_AppendHandshakeNumber(ss, ss->ssl3.hs.compression, 1); 9081 if (rv != SECSuccess) { 9082 return rv; /* err set by AppendHandshake. */ 9083 } 9084 if (extensions_len) { 9085 PRInt32 sent_len; 9086 9087 extensions_len -= 2; 9088 rv = ssl3_AppendHandshakeNumber(ss, extensions_len, 2); 9089 if (rv != SECSuccess) 9090 return rv; /* err set by ssl3_SetupPendingCipherSpec */ 9091 sent_len = ssl3_CallHelloExtensionSenders(ss, PR_TRUE, extensions_len, 9092 &ss->xtnData.serverSenders[0]); 9093 PORT_Assert(sent_len == extensions_len); 9094 if (sent_len != extensions_len) { 9095 if (sent_len >= 0) 9096 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 9097 return SECFailure; 9098 } 9099 } 9100 rv = ssl3_SetupPendingCipherSpec(ss); 9101 if (rv != SECSuccess) { 9102 return rv; /* err set by ssl3_SetupPendingCipherSpec */ 9103 } 9104 9105 return SECSuccess; 9106 } 9107 9108 /* ssl3_PickSignatureHashAlgorithm selects a hash algorithm to use when signing 9109 * elements of the handshake. (The negotiated cipher suite determines the 9110 * signature algorithm.) Prior to TLS 1.2, the MD5/SHA1 combination is always 9111 * used. With TLS 1.2, a client may advertise its support for signature and 9112 * hash combinations. */ 9113 static SECStatus 9114 ssl3_PickSignatureHashAlgorithm(sslSocket *ss, 9115 SSL3SignatureAndHashAlgorithm* out) 9116 { 9117 TLSSignatureAlgorithm sigAlg; 9118 unsigned int i, j; 9119 /* hashPreference expresses our preferences for hash algorithms, most 9120 * preferable first. */ 9121 static const PRUint8 hashPreference[] = { 9122 tls_hash_sha256, 9123 tls_hash_sha384, 9124 tls_hash_sha512, 9125 tls_hash_sha1, 9126 }; 9127 9128 switch (ss->ssl3.hs.kea_def->kea) { 9129 case kea_rsa: 9130 case kea_rsa_export: 9131 case kea_rsa_export_1024: 9132 case kea_dh_rsa: 9133 case kea_dh_rsa_export: 9134 case kea_dhe_rsa: 9135 case kea_dhe_rsa_export: 9136 case kea_rsa_fips: 9137 case kea_ecdh_rsa: 9138 case kea_ecdhe_rsa: 9139 sigAlg = tls_sig_rsa; 9140 break; 9141 case kea_dh_dss: 9142 case kea_dh_dss_export: 9143 case kea_dhe_dss: 9144 case kea_dhe_dss_export: 9145 sigAlg = tls_sig_dsa; 9146 break; 9147 case kea_ecdh_ecdsa: 9148 case kea_ecdhe_ecdsa: 9149 sigAlg = tls_sig_ecdsa; 9150 break; 9151 default: 9152 PORT_SetError(SEC_ERROR_UNSUPPORTED_KEYALG); 9153 return SECFailure; 9154 } 9155 out->sigAlg = sigAlg; 9156 9157 if (ss->version <= SSL_LIBRARY_VERSION_TLS_1_1) { 9158 /* SEC_OID_UNKNOWN means the MD5/SHA1 combo hash used in TLS 1.1 and 9159 * prior. */ 9160 out->hashAlg = SEC_OID_UNKNOWN; 9161 return SECSuccess; 9162 } 9163 9164 if (ss->ssl3.hs.numClientSigAndHash == 0) { 9165 /* If the client didn't provide any signature_algorithms extension then 9166 * we can assume that they support SHA-1: 9167 * https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1 */ 9168 out->hashAlg = SEC_OID_SHA1; 9169 return SECSuccess; 9170 } 9171 9172 for (i = 0; i < PR_ARRAY_SIZE(hashPreference); i++) { 9173 for (j = 0; j < ss->ssl3.hs.numClientSigAndHash; j++) { 9174 const SSL3SignatureAndHashAlgorithm* sh = 9175 &ss->ssl3.hs.clientSigAndHash[j]; 9176 if (sh->sigAlg == sigAlg && sh->hashAlg == hashPreference[i]) { 9177 out->hashAlg = sh->hashAlg; 9178 return SECSuccess; 9179 } 9180 } 9181 } 9182 9183 PORT_SetError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM); 9184 return SECFailure; 9185 } 9186 9187 9188 static SECStatus 9189 ssl3_SendServerKeyExchange(sslSocket *ss) 9190 { 9191 const ssl3KEADef * kea_def = ss->ssl3.hs.kea_def; 9192 SECStatus rv = SECFailure; 9193 int length; 9194 PRBool isTLS; 9195 SECItem signed_hash = {siBuffer, NULL, 0}; 9196 SSL3Hashes hashes; 9197 SECKEYPublicKey * sdPub; /* public key for step-down */ 9198 SSL3SignatureAndHashAlgorithm sigAndHash; 9199 9200 SSL_TRC(3, ("%d: SSL3[%d]: send server_key_exchange handshake", 9201 SSL_GETPID(), ss->fd)); 9202 9203 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 9204 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 9205 9206 if (ssl3_PickSignatureHashAlgorithm(ss, &sigAndHash) != SECSuccess) { 9207 return SECFailure; 9208 } 9209 9210 switch (kea_def->exchKeyType) { 9211 case kt_rsa: 9212 /* Perform SSL Step-Down here. */ 9213 sdPub = ss->stepDownKeyPair->pubKey; 9214 PORT_Assert(sdPub != NULL); 9215 if (!sdPub) { 9216 PORT_SetError(SSL_ERROR_SERVER_KEY_EXCHANGE_FAILURE); 9217 return SECFailure; 9218 } 9219 rv = ssl3_ComputeExportRSAKeyHash(sigAndHash.hashAlg, 9220 sdPub->u.rsa.modulus, 9221 sdPub->u.rsa.publicExponent, 9222 &ss->ssl3.hs.client_random, 9223 &ss->ssl3.hs.server_random, 9224 &hashes, ss->opt.bypassPKCS11); 9225 if (rv != SECSuccess) { 9226 ssl_MapLowLevelError(SSL_ERROR_SERVER_KEY_EXCHANGE_FAILURE); 9227 return rv; 9228 } 9229 9230 isTLS = (PRBool)(ss->ssl3.pwSpec->version > SSL_LIBRARY_VERSION_3_0); 9231 rv = ssl3_SignHashes(&hashes, ss->serverCerts[kt_rsa].SERVERKEY, 9232 &signed_hash, isTLS); 9233 if (rv != SECSuccess) { 9234 goto loser; /* ssl3_SignHashes has set err. */ 9235 } 9236 if (signed_hash.data == NULL) { 9237 /* how can this happen and rv == SECSuccess ?? */ 9238 PORT_SetError(SSL_ERROR_SERVER_KEY_EXCHANGE_FAILURE); 9239 goto loser; 9240 } 9241 length = 2 + sdPub->u.rsa.modulus.len + 9242 2 + sdPub->u.rsa.publicExponent.len + 9243 2 + signed_hash.len; 9244 9245 rv = ssl3_AppendHandshakeHeader(ss, server_key_exchange, length); 9246 if (rv != SECSuccess) { 9247 goto loser; /* err set by AppendHandshake. */ 9248 } 9249 9250 rv = ssl3_AppendHandshakeVariable(ss, sdPub->u.rsa.modulus.data, 9251 sdPub->u.rsa.modulus.len, 2); 9252 if (rv != SECSuccess) { 9253 goto loser; /* err set by AppendHandshake. */ 9254 } 9255 9256 rv = ssl3_AppendHandshakeVariable( 9257 ss, sdPub->u.rsa.publicExponent.data, 9258 sdPub->u.rsa.publicExponent.len, 2); 9259 if (rv != SECSuccess) { 9260 goto loser; /* err set by AppendHandshake. */ 9261 } 9262 9263 if (ss->ssl3.pwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_2) { 9264 rv = ssl3_AppendSignatureAndHashAlgorithm(ss, &sigAndHash); 9265 if (rv != SECSuccess) { 9266 goto loser; /* err set by AppendHandshake. */ 9267 } 9268 } 9269 9270 rv = ssl3_AppendHandshakeVariable(ss, signed_hash.data, 9271 signed_hash.len, 2); 9272 if (rv != SECSuccess) { 9273 goto loser; /* err set by AppendHandshake. */ 9274 } 9275 PORT_Free(signed_hash.data); 9276 return SECSuccess; 9277 9278 #ifdef NSS_ENABLE_ECC 9279 case kt_ecdh: { 9280 rv = ssl3_SendECDHServerKeyExchange(ss, &sigAndHash); 9281 return rv; 9282 } 9283 #endif /* NSS_ENABLE_ECC */ 9284 9285 case kt_dh: 9286 case kt_null: 9287 default: 9288 PORT_SetError(SEC_ERROR_UNSUPPORTED_KEYALG); 9289 break; 9290 } 9291 loser: 9292 if (signed_hash.data != NULL) 9293 PORT_Free(signed_hash.data); 9294 return SECFailure; 9295 } 9296 9297 9298 static SECStatus 9299 ssl3_SendCertificateRequest(sslSocket *ss) 9300 { 9301 PRBool isTLS12; 9302 SECItem * name; 9303 CERTDistNames *ca_list; 9304 const PRUint8 *certTypes; 9305 const PRUint8 *sigAlgs; 9306 SECItem * names = NULL; 9307 SECStatus rv; 9308 int length; 9309 int i; 9310 int calen = 0; 9311 int nnames = 0; 9312 int certTypesLength; 9313 int sigAlgsLength; 9314 9315 SSL_TRC(3, ("%d: SSL3[%d]: send certificate_request handshake", 9316 SSL_GETPID(), ss->fd)); 9317 9318 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 9319 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 9320 9321 isTLS12 = (PRBool)(ss->ssl3.pwSpec->version >= SSL_LIBRARY_VERSION_TLS_1_2); 9322 9323 /* ssl3.ca_list is initialized to NULL, and never changed. */ 9324 ca_list = ss->ssl3.ca_list; 9325 if (!ca_list) { 9326 ca_list = ssl3_server_ca_list; 9327 } 9328 9329 if (ca_list != NULL) { 9330 names = ca_list->names; 9331 nnames = ca_list->nnames; 9332 } 9333 9334 for (i = 0, name = names; i < nnames; i++, name++) { 9335 calen += 2 + name->len; 9336 } 9337 9338 certTypes = certificate_types; 9339 certTypesLength = sizeof certificate_types; 9340 sigAlgs = supported_signature_algorithms; 9341 sigAlgsLength = sizeof supported_signature_algorithms; 9342 9343 length = 1 + certTypesLength + 2 + calen; 9344 if (isTLS12) { 9345 length += 2 + sigAlgsLength; 9346 } 9347 9348 rv = ssl3_AppendHandshakeHeader(ss, certificate_request, length); 9349 if (rv != SECSuccess) { 9350 return rv; /* err set by AppendHandshake. */ 9351 } 9352 rv = ssl3_AppendHandshakeVariable(ss, certTypes, certTypesLength, 1); 9353 if (rv != SECSuccess) { 9354 return rv; /* err set by AppendHandshake. */ 9355 } 9356 if (isTLS12) { 9357 rv = ssl3_AppendHandshakeVariable(ss, sigAlgs, sigAlgsLength, 2); 9358 if (rv != SECSuccess) { 9359 return rv; /* err set by AppendHandshake. */ 9360 } 9361 } 9362 rv = ssl3_AppendHandshakeNumber(ss, calen, 2); 9363 if (rv != SECSuccess) { 9364 return rv; /* err set by AppendHandshake. */ 9365 } 9366 for (i = 0, name = names; i < nnames; i++, name++) { 9367 rv = ssl3_AppendHandshakeVariable(ss, name->data, name->len, 2); 9368 if (rv != SECSuccess) { 9369 return rv; /* err set by AppendHandshake. */ 9370 } 9371 } 9372 9373 return SECSuccess; 9374 } 9375 9376 static SECStatus 9377 ssl3_SendServerHelloDone(sslSocket *ss) 9378 { 9379 SECStatus rv; 9380 9381 SSL_TRC(3, ("%d: SSL3[%d]: send server_hello_done handshake", 9382 SSL_GETPID(), ss->fd)); 9383 9384 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 9385 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 9386 9387 rv = ssl3_AppendHandshakeHeader(ss, server_hello_done, 0); 9388 if (rv != SECSuccess) { 9389 return rv; /* err set by AppendHandshake. */ 9390 } 9391 rv = ssl3_FlushHandshake(ss, 0); 9392 if (rv != SECSuccess) { 9393 return rv; /* error code set by ssl3_FlushHandshake */ 9394 } 9395 return SECSuccess; 9396 } 9397 9398 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 9399 * ssl3 Certificate Verify message 9400 * Caller must hold Handshake and RecvBuf locks. 9401 */ 9402 static SECStatus 9403 ssl3_HandleCertificateVerify(sslSocket *ss, SSL3Opaque *b, PRUint32 length, 9404 SSL3Hashes *hashes) 9405 { 9406 SECItem signed_hash = {siBuffer, NULL, 0}; 9407 SECStatus rv; 9408 int errCode = SSL_ERROR_RX_MALFORMED_CERT_VERIFY; 9409 SSL3AlertDescription desc = handshake_failure; 9410 PRBool isTLS, isTLS12; 9411 SSL3SignatureAndHashAlgorithm sigAndHash; 9412 9413 SSL_TRC(3, ("%d: SSL3[%d]: handle certificate_verify handshake", 9414 SSL_GETPID(), ss->fd)); 9415 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 9416 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 9417 9418 isTLS = (PRBool)(ss->ssl3.prSpec->version > SSL_LIBRARY_VERSION_3_0); 9419 isTLS12 = (PRBool)(ss->ssl3.prSpec->version >= SSL_LIBRARY_VERSION_TLS_1_2); 9420 9421 if (ss->ssl3.hs.ws != wait_cert_verify || ss->sec.peerCert == NULL) { 9422 desc = unexpected_message; 9423 errCode = SSL_ERROR_RX_UNEXPECTED_CERT_VERIFY; 9424 goto alert_loser; 9425 } 9426 9427 if (isTLS12) { 9428 rv = ssl3_ConsumeSignatureAndHashAlgorithm(ss, &b, &length, 9429 &sigAndHash); 9430 if (rv != SECSuccess) { 9431 goto loser; /* malformed or unsupported. */ 9432 } 9433 rv = ssl3_CheckSignatureAndHashAlgorithmConsistency( 9434 &sigAndHash, ss->sec.peerCert); 9435 if (rv != SECSuccess) { 9436 errCode = PORT_GetError(); 9437 desc = decrypt_error; 9438 goto alert_loser; 9439 } 9440 9441 /* We only support CertificateVerify messages that use the handshake 9442 * hash. */ 9443 if (sigAndHash.hashAlg != hashes->hashAlg) { 9444 errCode = SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM; 9445 desc = decrypt_error; 9446 goto alert_loser; 9447 } 9448 } 9449 9450 rv = ssl3_ConsumeHandshakeVariable(ss, &signed_hash, 2, &b, &length); 9451 if (rv != SECSuccess) { 9452 goto loser; /* malformed. */ 9453 } 9454 9455 /* XXX verify that the key & kea match */ 9456 rv = ssl3_VerifySignedHashes(hashes, ss->sec.peerCert, &signed_hash, 9457 isTLS, ss->pkcs11PinArg); 9458 if (rv != SECSuccess) { 9459 errCode = PORT_GetError(); 9460 desc = isTLS ? decrypt_error : handshake_failure; 9461 goto alert_loser; 9462 } 9463 9464 signed_hash.data = NULL; 9465 9466 if (length != 0) { 9467 desc = isTLS ? decode_error : illegal_parameter; 9468 goto alert_loser; /* malformed */ 9469 } 9470 ss->ssl3.hs.ws = wait_change_cipher; 9471 return SECSuccess; 9472 9473 alert_loser: 9474 SSL3_SendAlert(ss, alert_fatal, desc); 9475 loser: 9476 PORT_SetError(errCode); 9477 return SECFailure; 9478 } 9479 9480 9481 /* find a slot that is able to generate a PMS and wrap it with RSA. 9482 * Then generate and return the PMS. 9483 * If the serverKeySlot parameter is non-null, this function will use 9484 * that slot to do the job, otherwise it will find a slot. 9485 * 9486 * Called from ssl3_DeriveConnectionKeysPKCS11() (above) 9487 * sendRSAClientKeyExchange() (above) 9488 * ssl3_HandleRSAClientKeyExchange() (below) 9489 * Caller must hold the SpecWriteLock, the SSL3HandshakeLock 9490 */ 9491 static PK11SymKey * 9492 ssl3_GenerateRSAPMS(sslSocket *ss, ssl3CipherSpec *spec, 9493 PK11SlotInfo * serverKeySlot) 9494 { 9495 PK11SymKey * pms = NULL; 9496 PK11SlotInfo * slot = serverKeySlot; 9497 void * pwArg = ss->pkcs11PinArg; 9498 SECItem param; 9499 CK_VERSION version; 9500 CK_MECHANISM_TYPE mechanism_array[3]; 9501 9502 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 9503 9504 if (slot == NULL) { 9505 SSLCipherAlgorithm calg; 9506 /* The specReadLock would suffice here, but we cannot assert on 9507 ** read locks. Also, all the callers who call with a non-null 9508 ** slot already hold the SpecWriteLock. 9509 */ 9510 PORT_Assert( ss->opt.noLocks || ssl_HaveSpecWriteLock(ss)); 9511 PORT_Assert(ss->ssl3.prSpec == ss->ssl3.pwSpec); 9512 9513 calg = spec->cipher_def->calg; 9514 PORT_Assert(alg2Mech[calg].calg == calg); 9515 9516 /* First get an appropriate slot. */ 9517 mechanism_array[0] = CKM_SSL3_PRE_MASTER_KEY_GEN; 9518 mechanism_array[1] = CKM_RSA_PKCS; 9519 mechanism_array[2] = alg2Mech[calg].cmech; 9520 9521 slot = PK11_GetBestSlotMultiple(mechanism_array, 3, pwArg); 9522 if (slot == NULL) { 9523 /* can't find a slot with all three, find a slot with the minimum */ 9524 slot = PK11_GetBestSlotMultiple(mechanism_array, 2, pwArg); 9525 if (slot == NULL) { 9526 PORT_SetError(SSL_ERROR_TOKEN_SLOT_NOT_FOUND); 9527 return pms; /* which is NULL */ 9528 } 9529 } 9530 } 9531 9532 /* Generate the pre-master secret ... */ 9533 if (IS_DTLS(ss)) { 9534 SSL3ProtocolVersion temp; 9535 9536 temp = dtls_TLSVersionToDTLSVersion(ss->clientHelloVersion); 9537 version.major = MSB(temp); 9538 version.minor = LSB(temp); 9539 } else { 9540 version.major = MSB(ss->clientHelloVersion); 9541 version.minor = LSB(ss->clientHelloVersion); 9542 } 9543 9544 param.data = (unsigned char *)&version; 9545 param.len = sizeof version; 9546 9547 pms = PK11_KeyGen(slot, CKM_SSL3_PRE_MASTER_KEY_GEN, ¶m, 0, pwArg); 9548 if (!serverKeySlot) 9549 PK11_FreeSlot(slot); 9550 if (pms == NULL) { 9551 ssl_MapLowLevelError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 9552 } 9553 return pms; 9554 } 9555 9556 /* Note: The Bleichenbacher attack on PKCS#1 necessitates that we NEVER 9557 * return any indication of failure of the Client Key Exchange message, 9558 * where that failure is caused by the content of the client's message. 9559 * This function must not return SECFailure for any reason that is directly 9560 * or indirectly caused by the content of the client's encrypted PMS. 9561 * We must not send an alert and also not drop the connection. 9562 * Instead, we generate a random PMS. This will cause a failure 9563 * in the processing the finished message, which is exactly where 9564 * the failure must occur. 9565 * 9566 * Called from ssl3_HandleClientKeyExchange 9567 */ 9568 static SECStatus 9569 ssl3_HandleRSAClientKeyExchange(sslSocket *ss, 9570 SSL3Opaque *b, 9571 PRUint32 length, 9572 SECKEYPrivateKey *serverKey) 9573 { 9574 PK11SymKey * pms; 9575 #ifndef NO_PKCS11_BYPASS 9576 unsigned char * cr = (unsigned char *)&ss->ssl3.hs.client_random; 9577 unsigned char * sr = (unsigned char *)&ss->ssl3.hs.server_random; 9578 ssl3CipherSpec * pwSpec = ss->ssl3.pwSpec; 9579 unsigned int outLen = 0; 9580 #endif 9581 PRBool isTLS = PR_FALSE; 9582 SECStatus rv; 9583 SECItem enc_pms; 9584 unsigned char rsaPmsBuf[SSL3_RSA_PMS_LENGTH]; 9585 SECItem pmsItem = {siBuffer, NULL, 0}; 9586 9587 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 9588 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 9589 PORT_Assert( ss->ssl3.prSpec == ss->ssl3.pwSpec ); 9590 9591 enc_pms.data = b; 9592 enc_pms.len = length; 9593 pmsItem.data = rsaPmsBuf; 9594 pmsItem.len = sizeof rsaPmsBuf; 9595 9596 if (ss->ssl3.prSpec->version > SSL_LIBRARY_VERSION_3_0) { /* isTLS */ 9597 PRInt32 kLen; 9598 kLen = ssl3_ConsumeHandshakeNumber(ss, 2, &enc_pms.data, &enc_pms.len); 9599 if (kLen < 0) { 9600 PORT_SetError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 9601 return SECFailure; 9602 } 9603 if ((unsigned)kLen < enc_pms.len) { 9604 enc_pms.len = kLen; 9605 } 9606 isTLS = PR_TRUE; 9607 } else { 9608 isTLS = (PRBool)(ss->ssl3.hs.kea_def->tls_keygen != 0); 9609 } 9610 9611 #ifndef NO_PKCS11_BYPASS 9612 if (ss->opt.bypassPKCS11) { 9613 /* TRIPLE BYPASS, get PMS directly from RSA decryption. 9614 * Use PK11_PrivDecryptPKCS1 to decrypt the PMS to a buffer, 9615 * then, check for version rollback attack, then 9616 * do the equivalent of ssl3_DeriveMasterSecret, placing the MS in 9617 * pwSpec->msItem. Finally call ssl3_InitPendingCipherSpec with 9618 * ss and NULL, so that it will use the MS we've already derived here. 9619 */ 9620 9621 rv = PK11_PrivDecryptPKCS1(serverKey, rsaPmsBuf, &outLen, 9622 sizeof rsaPmsBuf, enc_pms.data, enc_pms.len); 9623 if (rv != SECSuccess) { 9624 /* triple bypass failed. Let's try for a double bypass. */ 9625 goto double_bypass; 9626 } else if (ss->opt.detectRollBack) { 9627 SSL3ProtocolVersion client_version = 9628 (rsaPmsBuf[0] << 8) | rsaPmsBuf[1]; 9629 9630 if (IS_DTLS(ss)) { 9631 client_version = dtls_DTLSVersionToTLSVersion(client_version); 9632 } 9633 9634 if (client_version != ss->clientHelloVersion) { 9635 /* Version roll-back detected. ensure failure. */ 9636 rv = PK11_GenerateRandom(rsaPmsBuf, sizeof rsaPmsBuf); 9637 } 9638 } 9639 /* have PMS, build MS without PKCS11 */ 9640 rv = ssl3_MasterKeyDeriveBypass(pwSpec, cr, sr, &pmsItem, isTLS, 9641 PR_TRUE); 9642 if (rv != SECSuccess) { 9643 pwSpec->msItem.data = pwSpec->raw_master_secret; 9644 pwSpec->msItem.len = SSL3_MASTER_SECRET_LENGTH; 9645 PK11_GenerateRandom(pwSpec->msItem.data, pwSpec->msItem.len); 9646 } 9647 rv = ssl3_InitPendingCipherSpec(ss, NULL); 9648 } else 9649 #endif 9650 { 9651 #ifndef NO_PKCS11_BYPASS 9652 double_bypass: 9653 #endif 9654 /* 9655 * unwrap pms out of the incoming buffer 9656 * Note: CKM_SSL3_MASTER_KEY_DERIVE is NOT the mechanism used to do 9657 * the unwrap. Rather, it is the mechanism with which the 9658 * unwrapped pms will be used. 9659 */ 9660 pms = PK11_PubUnwrapSymKey(serverKey, &enc_pms, 9661 CKM_SSL3_MASTER_KEY_DERIVE, CKA_DERIVE, 0); 9662 if (pms != NULL) { 9663 PRINT_BUF(60, (ss, "decrypted premaster secret:", 9664 PK11_GetKeyData(pms)->data, 9665 PK11_GetKeyData(pms)->len)); 9666 } else { 9667 /* unwrap failed. Generate a bogus PMS and carry on. */ 9668 PK11SlotInfo * slot = PK11_GetSlotFromPrivateKey(serverKey); 9669 9670 ssl_GetSpecWriteLock(ss); 9671 pms = ssl3_GenerateRSAPMS(ss, ss->ssl3.prSpec, slot); 9672 ssl_ReleaseSpecWriteLock(ss); 9673 PK11_FreeSlot(slot); 9674 } 9675 9676 if (pms == NULL) { 9677 /* last gasp. */ 9678 ssl_MapLowLevelError(SSL_ERROR_CLIENT_KEY_EXCHANGE_FAILURE); 9679 return SECFailure; 9680 } 9681 9682 /* This step will derive the MS from the PMS, among other things. */ 9683 rv = ssl3_InitPendingCipherSpec(ss, pms); 9684 PK11_FreeSymKey(pms); 9685 } 9686 9687 if (rv != SECSuccess) { 9688 SEND_ALERT 9689 return SECFailure; /* error code set by ssl3_InitPendingCipherSpec */ 9690 } 9691 return SECSuccess; 9692 } 9693 9694 9695 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 9696 * ssl3 ClientKeyExchange message from the remote client 9697 * Caller must hold Handshake and RecvBuf locks. 9698 */ 9699 static SECStatus 9700 ssl3_HandleClientKeyExchange(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 9701 { 9702 SECKEYPrivateKey *serverKey = NULL; 9703 SECStatus rv; 9704 const ssl3KEADef *kea_def; 9705 ssl3KeyPair *serverKeyPair = NULL; 9706 #ifdef NSS_ENABLE_ECC 9707 SECKEYPublicKey *serverPubKey = NULL; 9708 #endif /* NSS_ENABLE_ECC */ 9709 9710 SSL_TRC(3, ("%d: SSL3[%d]: handle client_key_exchange handshake", 9711 SSL_GETPID(), ss->fd)); 9712 9713 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 9714 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 9715 9716 if (ss->ssl3.hs.ws != wait_client_key) { 9717 SSL3_SendAlert(ss, alert_fatal, unexpected_message); 9718 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_CLIENT_KEY_EXCH); 9719 return SECFailure; 9720 } 9721 9722 kea_def = ss->ssl3.hs.kea_def; 9723 9724 if (ss->ssl3.hs.usedStepDownKey) { 9725 PORT_Assert(kea_def->is_limited /* XXX OR cert is signing only */ 9726 && kea_def->exchKeyType == kt_rsa 9727 && ss->stepDownKeyPair != NULL); 9728 if (!kea_def->is_limited || 9729 kea_def->exchKeyType != kt_rsa || 9730 ss->stepDownKeyPair == NULL) { 9731 /* shouldn't happen, don't use step down if it does */ 9732 goto skip; 9733 } 9734 serverKeyPair = ss->stepDownKeyPair; 9735 ss->sec.keaKeyBits = EXPORT_RSA_KEY_LENGTH * BPB; 9736 } else 9737 skip: 9738 #ifdef NSS_ENABLE_ECC 9739 /* XXX Using SSLKEAType to index server certifiates 9740 * does not work for (EC)DHE ciphers. Until we have 9741 * an indexing mechanism general enough for all key 9742 * exchange algorithms, we'll need to deal with each 9743 * one seprately. 9744 */ 9745 if ((kea_def->kea == kea_ecdhe_rsa) || 9746 (kea_def->kea == kea_ecdhe_ecdsa)) { 9747 if (ss->ephemeralECDHKeyPair != NULL) { 9748 serverKeyPair = ss->ephemeralECDHKeyPair; 9749 if (serverKeyPair->pubKey) { 9750 ss->sec.keaKeyBits = 9751 SECKEY_PublicKeyStrengthInBits(serverKeyPair->pubKey); 9752 } 9753 } 9754 } else 9755 #endif 9756 { 9757 sslServerCerts * sc = ss->serverCerts + kea_def->exchKeyType; 9758 serverKeyPair = sc->serverKeyPair; 9759 ss->sec.keaKeyBits = sc->serverKeyBits; 9760 } 9761 9762 if (serverKeyPair) { 9763 serverKey = serverKeyPair->privKey; 9764 } 9765 9766 if (serverKey == NULL) { 9767 SEND_ALERT 9768 PORT_SetError(SSL_ERROR_NO_SERVER_KEY_FOR_ALG); 9769 return SECFailure; 9770 } 9771 9772 ss->sec.keaType = kea_def->exchKeyType; 9773 9774 switch (kea_def->exchKeyType) { 9775 case kt_rsa: 9776 rv = ssl3_HandleRSAClientKeyExchange(ss, b, length, serverKey); 9777 if (rv != SECSuccess) { 9778 SEND_ALERT 9779 return SECFailure; /* error code set */ 9780 } 9781 break; 9782 9783 9784 #ifdef NSS_ENABLE_ECC 9785 case kt_ecdh: 9786 /* XXX We really ought to be able to store multiple 9787 * EC certs (a requirement if we wish to support both 9788 * ECDH-RSA and ECDH-ECDSA key exchanges concurrently). 9789 * When we make that change, we'll need an index other 9790 * than kt_ecdh to pick the right EC certificate. 9791 */ 9792 if (serverKeyPair) { 9793 serverPubKey = serverKeyPair->pubKey; 9794 } 9795 if (serverPubKey == NULL) { 9796 /* XXX Is this the right error code? */ 9797 PORT_SetError(SSL_ERROR_EXTRACT_PUBLIC_KEY_FAILURE); 9798 return SECFailure; 9799 } 9800 rv = ssl3_HandleECDHClientKeyExchange(ss, b, length, 9801 serverPubKey, serverKey); 9802 if (rv != SECSuccess) { 9803 return SECFailure; /* error code set */ 9804 } 9805 break; 9806 #endif /* NSS_ENABLE_ECC */ 9807 9808 default: 9809 (void) ssl3_HandshakeFailure(ss); 9810 PORT_SetError(SEC_ERROR_UNSUPPORTED_KEYALG); 9811 return SECFailure; 9812 } 9813 ss->ssl3.hs.ws = ss->sec.peerCert ? wait_cert_verify : wait_change_cipher; 9814 return SECSuccess; 9815 9816 } 9817 9818 /* This is TLS's equivalent of sending a no_certificate alert. */ 9819 static SECStatus 9820 ssl3_SendEmptyCertificate(sslSocket *ss) 9821 { 9822 SECStatus rv; 9823 9824 rv = ssl3_AppendHandshakeHeader(ss, certificate, 3); 9825 if (rv == SECSuccess) { 9826 rv = ssl3_AppendHandshakeNumber(ss, 0, 3); 9827 } 9828 return rv; /* error, if any, set by functions called above. */ 9829 } 9830 9831 SECStatus 9832 ssl3_HandleNewSessionTicket(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 9833 { 9834 SECStatus rv; 9835 SECItem ticketData; 9836 9837 SSL_TRC(3, ("%d: SSL3[%d]: handle session_ticket handshake", 9838 SSL_GETPID(), ss->fd)); 9839 9840 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 9841 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 9842 9843 PORT_Assert(!ss->ssl3.hs.newSessionTicket.ticket.data); 9844 PORT_Assert(!ss->ssl3.hs.receivedNewSessionTicket); 9845 9846 if (ss->ssl3.hs.ws != wait_new_session_ticket) { 9847 SSL3_SendAlert(ss, alert_fatal, unexpected_message); 9848 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_NEW_SESSION_TICKET); 9849 return SECFailure; 9850 } 9851 9852 /* RFC5077 Section 3.3: "The client MUST NOT treat the ticket as valid 9853 * until it has verified the server's Finished message." See the comment in 9854 * ssl3_FinishHandshake for more details. 9855 */ 9856 ss->ssl3.hs.newSessionTicket.received_timestamp = ssl_Time(); 9857 if (length < 4) { 9858 (void)SSL3_SendAlert(ss, alert_fatal, decode_error); 9859 PORT_SetError(SSL_ERROR_RX_MALFORMED_NEW_SESSION_TICKET); 9860 return SECFailure; 9861 } 9862 ss->ssl3.hs.newSessionTicket.ticket_lifetime_hint = 9863 (PRUint32)ssl3_ConsumeHandshakeNumber(ss, 4, &b, &length); 9864 9865 rv = ssl3_ConsumeHandshakeVariable(ss, &ticketData, 2, &b, &length); 9866 if (length != 0 || rv != SECSuccess) { 9867 (void)SSL3_SendAlert(ss, alert_fatal, decode_error); 9868 PORT_SetError(SSL_ERROR_RX_MALFORMED_NEW_SESSION_TICKET); 9869 return SECFailure; /* malformed */ 9870 } 9871 rv = SECITEM_CopyItem(NULL, &ss->ssl3.hs.newSessionTicket.ticket, 9872 &ticketData); 9873 if (rv != SECSuccess) { 9874 return rv; 9875 } 9876 ss->ssl3.hs.receivedNewSessionTicket = PR_TRUE; 9877 9878 ss->ssl3.hs.ws = wait_change_cipher; 9879 return SECSuccess; 9880 } 9881 9882 #ifdef NISCC_TEST 9883 static PRInt32 connNum = 0; 9884 9885 static SECStatus 9886 get_fake_cert(SECItem *pCertItem, int *pIndex) 9887 { 9888 PRFileDesc *cf; 9889 char * testdir; 9890 char * startat; 9891 char * stopat; 9892 const char *extension; 9893 int fileNum; 9894 PRInt32 numBytes = 0; 9895 PRStatus prStatus; 9896 PRFileInfo info; 9897 char cfn[100]; 9898 9899 pCertItem->data = 0; 9900 if ((testdir = PR_GetEnv("NISCC_TEST")) == NULL) { 9901 return SECSuccess; 9902 } 9903 *pIndex = (NULL != strstr(testdir, "root")); 9904 extension = (strstr(testdir, "simple") ? "" : ".der"); 9905 fileNum = PR_ATOMIC_INCREMENT(&connNum) - 1; 9906 if ((startat = PR_GetEnv("START_AT")) != NULL) { 9907 fileNum += atoi(startat); 9908 } 9909 if ((stopat = PR_GetEnv("STOP_AT")) != NULL && 9910 fileNum >= atoi(stopat)) { 9911 *pIndex = -1; 9912 return SECSuccess; 9913 } 9914 sprintf(cfn, "%s/%08d%s", testdir, fileNum, extension); 9915 cf = PR_Open(cfn, PR_RDONLY, 0); 9916 if (!cf) { 9917 goto loser; 9918 } 9919 prStatus = PR_GetOpenFileInfo(cf, &info); 9920 if (prStatus != PR_SUCCESS) { 9921 PR_Close(cf); 9922 goto loser; 9923 } 9924 pCertItem = SECITEM_AllocItem(NULL, pCertItem, info.size); 9925 if (pCertItem) { 9926 numBytes = PR_Read(cf, pCertItem->data, info.size); 9927 } 9928 PR_Close(cf); 9929 if (numBytes != info.size) { 9930 SECITEM_FreeItem(pCertItem, PR_FALSE); 9931 PORT_SetError(SEC_ERROR_IO); 9932 goto loser; 9933 } 9934 fprintf(stderr, "using %s\n", cfn); 9935 return SECSuccess; 9936 9937 loser: 9938 fprintf(stderr, "failed to use %s\n", cfn); 9939 *pIndex = -1; 9940 return SECFailure; 9941 } 9942 #endif 9943 9944 /* 9945 * Used by both client and server. 9946 * Called from HandleServerHelloDone and from SendServerHelloSequence. 9947 */ 9948 static SECStatus 9949 ssl3_SendCertificate(sslSocket *ss) 9950 { 9951 SECStatus rv; 9952 CERTCertificateList *certChain; 9953 int len = 0; 9954 int i; 9955 SSL3KEAType certIndex; 9956 #ifdef NISCC_TEST 9957 SECItem fakeCert; 9958 int ndex = -1; 9959 #endif 9960 9961 SSL_TRC(3, ("%d: SSL3[%d]: send certificate handshake", 9962 SSL_GETPID(), ss->fd)); 9963 9964 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 9965 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 9966 9967 if (ss->sec.localCert) 9968 CERT_DestroyCertificate(ss->sec.localCert); 9969 if (ss->sec.isServer) { 9970 sslServerCerts * sc = NULL; 9971 9972 /* XXX SSLKEAType isn't really a good choice for 9973 * indexing certificates (it breaks when we deal 9974 * with (EC)DHE-* cipher suites. This hack ensures 9975 * the RSA cert is picked for (EC)DHE-RSA. 9976 * Revisit this when we add server side support 9977 * for ECDHE-ECDSA or client-side authentication 9978 * using EC certificates. 9979 */ 9980 if ((ss->ssl3.hs.kea_def->kea == kea_ecdhe_rsa) || 9981 (ss->ssl3.hs.kea_def->kea == kea_dhe_rsa)) { 9982 certIndex = kt_rsa; 9983 } else { 9984 certIndex = ss->ssl3.hs.kea_def->exchKeyType; 9985 } 9986 sc = ss->serverCerts + certIndex; 9987 certChain = sc->serverCertChain; 9988 ss->sec.authKeyBits = sc->serverKeyBits; 9989 ss->sec.authAlgorithm = ss->ssl3.hs.kea_def->signKeyType; 9990 ss->sec.localCert = CERT_DupCertificate(sc->serverCert); 9991 } else { 9992 certChain = ss->ssl3.clientCertChain; 9993 ss->sec.localCert = CERT_DupCertificate(ss->ssl3.clientCertificate); 9994 } 9995 9996 #ifdef NISCC_TEST 9997 rv = get_fake_cert(&fakeCert, &ndex); 9998 #endif 9999 10000 if (certChain) { 10001 for (i = 0; i < certChain->len; i++) { 10002 #ifdef NISCC_TEST 10003 if (fakeCert.len > 0 && i == ndex) { 10004 len += fakeCert.len + 3; 10005 } else { 10006 len += certChain->certs[i].len + 3; 10007 } 10008 #else 10009 len += certChain->certs[i].len + 3; 10010 #endif 10011 } 10012 } 10013 10014 rv = ssl3_AppendHandshakeHeader(ss, certificate, len + 3); 10015 if (rv != SECSuccess) { 10016 return rv; /* err set by AppendHandshake. */ 10017 } 10018 rv = ssl3_AppendHandshakeNumber(ss, len, 3); 10019 if (rv != SECSuccess) { 10020 return rv; /* err set by AppendHandshake. */ 10021 } 10022 if (certChain) { 10023 for (i = 0; i < certChain->len; i++) { 10024 #ifdef NISCC_TEST 10025 if (fakeCert.len > 0 && i == ndex) { 10026 rv = ssl3_AppendHandshakeVariable(ss, fakeCert.data, 10027 fakeCert.len, 3); 10028 SECITEM_FreeItem(&fakeCert, PR_FALSE); 10029 } else { 10030 rv = ssl3_AppendHandshakeVariable(ss, certChain->certs[i].data, 10031 certChain->certs[i].len, 3); 10032 } 10033 #else 10034 rv = ssl3_AppendHandshakeVariable(ss, certChain->certs[i].data, 10035 certChain->certs[i].len, 3); 10036 #endif 10037 if (rv != SECSuccess) { 10038 return rv; /* err set by AppendHandshake. */ 10039 } 10040 } 10041 } 10042 10043 return SECSuccess; 10044 } 10045 10046 /* 10047 * Used by server only. 10048 * single-stapling, send only a single cert status 10049 */ 10050 static SECStatus 10051 ssl3_SendCertificateStatus(sslSocket *ss) 10052 { 10053 SECStatus rv; 10054 int len = 0; 10055 SECItemArray *statusToSend = NULL; 10056 SSL3KEAType certIndex; 10057 10058 SSL_TRC(3, ("%d: SSL3[%d]: send certificate status handshake", 10059 SSL_GETPID(), ss->fd)); 10060 10061 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 10062 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 10063 PORT_Assert( ss->sec.isServer); 10064 10065 if (!ssl3_ExtensionNegotiated(ss, ssl_cert_status_xtn)) 10066 return SECSuccess; 10067 10068 /* Use certStatus based on the cert being used. */ 10069 if ((ss->ssl3.hs.kea_def->kea == kea_ecdhe_rsa) || 10070 (ss->ssl3.hs.kea_def->kea == kea_dhe_rsa)) { 10071 certIndex = kt_rsa; 10072 } else { 10073 certIndex = ss->ssl3.hs.kea_def->exchKeyType; 10074 } 10075 if (ss->certStatusArray[certIndex] && ss->certStatusArray[certIndex]->len) { 10076 statusToSend = ss->certStatusArray[certIndex]; 10077 } 10078 if (!statusToSend) 10079 return SECSuccess; 10080 10081 /* Use the array's first item only (single stapling) */ 10082 len = 1 + statusToSend->items[0].len + 3; 10083 10084 rv = ssl3_AppendHandshakeHeader(ss, certificate_status, len); 10085 if (rv != SECSuccess) { 10086 return rv; /* err set by AppendHandshake. */ 10087 } 10088 rv = ssl3_AppendHandshakeNumber(ss, 1 /*ocsp*/, 1); 10089 if (rv != SECSuccess) 10090 return rv; /* err set by AppendHandshake. */ 10091 10092 rv = ssl3_AppendHandshakeVariable(ss, 10093 statusToSend->items[0].data, 10094 statusToSend->items[0].len, 10095 3); 10096 if (rv != SECSuccess) 10097 return rv; /* err set by AppendHandshake. */ 10098 10099 return SECSuccess; 10100 } 10101 10102 /* This is used to delete the CA certificates in the peer certificate chain 10103 * from the cert database after they've been validated. 10104 */ 10105 static void 10106 ssl3_CleanupPeerCerts(sslSocket *ss) 10107 { 10108 PLArenaPool * arena = ss->ssl3.peerCertArena; 10109 ssl3CertNode *certs = (ssl3CertNode *)ss->ssl3.peerCertChain; 10110 10111 for (; certs; certs = certs->next) { 10112 CERT_DestroyCertificate(certs->cert); 10113 } 10114 if (arena) PORT_FreeArena(arena, PR_FALSE); 10115 ss->ssl3.peerCertArena = NULL; 10116 ss->ssl3.peerCertChain = NULL; 10117 } 10118 10119 static void 10120 ssl3_CopyPeerCertsFromSID(sslSocket *ss, sslSessionID *sid) 10121 { 10122 PLArenaPool *arena; 10123 ssl3CertNode *lastCert = NULL; 10124 ssl3CertNode *certs = NULL; 10125 int i; 10126 10127 if (!sid->peerCertChain[0]) 10128 return; 10129 PORT_Assert(!ss->ssl3.peerCertArena); 10130 PORT_Assert(!ss->ssl3.peerCertChain); 10131 ss->ssl3.peerCertArena = arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); 10132 for (i = 0; i < MAX_PEER_CERT_CHAIN_SIZE && sid->peerCertChain[i]; i++) { 10133 ssl3CertNode *c = PORT_ArenaNew(arena, ssl3CertNode); 10134 c->cert = CERT_DupCertificate(sid->peerCertChain[i]); 10135 c->next = NULL; 10136 if (lastCert) { 10137 lastCert->next = c; 10138 } else { 10139 certs = c; 10140 } 10141 lastCert = c; 10142 } 10143 ss->ssl3.peerCertChain = certs; 10144 } 10145 10146 static void 10147 ssl3_CopyPeerCertsToSID(ssl3CertNode *certs, sslSessionID *sid) 10148 { 10149 int i = 0; 10150 ssl3CertNode *c = certs; 10151 for (; i < MAX_PEER_CERT_CHAIN_SIZE && c; i++, c = c->next) { 10152 PORT_Assert(!sid->peerCertChain[i]); 10153 sid->peerCertChain[i] = CERT_DupCertificate(c->cert); 10154 } 10155 } 10156 10157 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 10158 * ssl3 CertificateStatus message. 10159 * Caller must hold Handshake and RecvBuf locks. 10160 * This is always called before ssl3_HandleCertificate, even if the Certificate 10161 * message is sent first. 10162 */ 10163 static SECStatus 10164 ssl3_HandleCertificateStatus(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 10165 { 10166 PRInt32 status, len; 10167 10168 if (ss->ssl3.hs.ws != wait_certificate_status) { 10169 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 10170 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_CERT_STATUS); 10171 return SECFailure; 10172 } 10173 10174 PORT_Assert(!ss->sec.isServer); 10175 10176 /* Consume the CertificateStatusType enum */ 10177 status = ssl3_ConsumeHandshakeNumber(ss, 1, &b, &length); 10178 if (status != 1 /* ocsp */) { 10179 goto format_loser; 10180 } 10181 10182 len = ssl3_ConsumeHandshakeNumber(ss, 3, &b, &length); 10183 if (len != length) { 10184 goto format_loser; 10185 } 10186 10187 #define MAX_CERTSTATUS_LEN 0x1ffff /* 128k - 1 */ 10188 if (length > MAX_CERTSTATUS_LEN) 10189 goto format_loser; 10190 #undef MAX_CERTSTATUS_LEN 10191 10192 /* Array size 1, because we currently implement single-stapling only */ 10193 SECITEM_AllocArray(NULL, &ss->sec.ci.sid->peerCertStatus, 1); 10194 if (!ss->sec.ci.sid->peerCertStatus.items) 10195 return SECFailure; 10196 10197 ss->sec.ci.sid->peerCertStatus.items[0].data = PORT_Alloc(length); 10198 10199 if (!ss->sec.ci.sid->peerCertStatus.items[0].data) { 10200 SECITEM_FreeArray(&ss->sec.ci.sid->peerCertStatus, PR_FALSE); 10201 return SECFailure; 10202 } 10203 10204 PORT_Memcpy(ss->sec.ci.sid->peerCertStatus.items[0].data, b, length); 10205 ss->sec.ci.sid->peerCertStatus.items[0].len = length; 10206 ss->sec.ci.sid->peerCertStatus.items[0].type = siBuffer; 10207 10208 return ssl3_AuthCertificate(ss); 10209 10210 format_loser: 10211 return ssl3_DecodeError(ss); 10212 } 10213 10214 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 10215 * ssl3 Certificate message. 10216 * Caller must hold Handshake and RecvBuf locks. 10217 */ 10218 static SECStatus 10219 ssl3_HandleCertificate(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 10220 { 10221 ssl3CertNode * c; 10222 ssl3CertNode * lastCert = NULL; 10223 PRInt32 remaining = 0; 10224 PRInt32 size; 10225 SECStatus rv; 10226 PRBool isServer = (PRBool)(!!ss->sec.isServer); 10227 PRBool isTLS; 10228 SSL3AlertDescription desc; 10229 int errCode = SSL_ERROR_RX_MALFORMED_CERTIFICATE; 10230 SECItem certItem; 10231 10232 SSL_TRC(3, ("%d: SSL3[%d]: handle certificate handshake", 10233 SSL_GETPID(), ss->fd)); 10234 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 10235 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 10236 10237 if ((ss->ssl3.hs.ws != wait_server_cert) && 10238 (ss->ssl3.hs.ws != wait_client_cert)) { 10239 desc = unexpected_message; 10240 errCode = SSL_ERROR_RX_UNEXPECTED_CERTIFICATE; 10241 goto alert_loser; 10242 } 10243 10244 if (ss->sec.peerCert != NULL) { 10245 if (ss->sec.peerKey) { 10246 SECKEY_DestroyPublicKey(ss->sec.peerKey); 10247 ss->sec.peerKey = NULL; 10248 } 10249 CERT_DestroyCertificate(ss->sec.peerCert); 10250 ss->sec.peerCert = NULL; 10251 } 10252 10253 ssl3_CleanupPeerCerts(ss); 10254 isTLS = (PRBool)(ss->ssl3.prSpec->version > SSL_LIBRARY_VERSION_3_0); 10255 10256 /* It is reported that some TLS client sends a Certificate message 10257 ** with a zero-length message body. We'll treat that case like a 10258 ** normal no_certificates message to maximize interoperability. 10259 */ 10260 if (length) { 10261 remaining = ssl3_ConsumeHandshakeNumber(ss, 3, &b, &length); 10262 if (remaining < 0) 10263 goto loser; /* fatal alert already sent by ConsumeHandshake. */ 10264 if ((PRUint32)remaining > length) 10265 goto decode_loser; 10266 } 10267 10268 if (!remaining) { 10269 if (!(isTLS && isServer)) { 10270 desc = bad_certificate; 10271 goto alert_loser; 10272 } 10273 /* This is TLS's version of a no_certificate alert. */ 10274 /* I'm a server. I've requested a client cert. He hasn't got one. */ 10275 rv = ssl3_HandleNoCertificate(ss); 10276 if (rv != SECSuccess) { 10277 errCode = PORT_GetError(); 10278 goto loser; 10279 } 10280 ss->ssl3.hs.ws = wait_client_key; 10281 return SECSuccess; 10282 } 10283 10284 ss->ssl3.peerCertArena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); 10285 if (ss->ssl3.peerCertArena == NULL) { 10286 goto loser; /* don't send alerts on memory errors */ 10287 } 10288 10289 /* First get the peer cert. */ 10290 remaining -= 3; 10291 if (remaining < 0) 10292 goto decode_loser; 10293 10294 size = ssl3_ConsumeHandshakeNumber(ss, 3, &b, &length); 10295 if (size <= 0) 10296 goto loser; /* fatal alert already sent by ConsumeHandshake. */ 10297 10298 if (remaining < size) 10299 goto decode_loser; 10300 10301 certItem.data = b; 10302 certItem.len = size; 10303 b += size; 10304 length -= size; 10305 remaining -= size; 10306 10307 ss->sec.peerCert = CERT_NewTempCertificate(ss->dbHandle, &certItem, NULL, 10308 PR_FALSE, PR_TRUE); 10309 if (ss->sec.peerCert == NULL) { 10310 /* We should report an alert if the cert was bad, but not if the 10311 * problem was just some local problem, like memory error. 10312 */ 10313 goto ambiguous_err; 10314 } 10315 10316 /* Now get all of the CA certs. */ 10317 while (remaining > 0) { 10318 remaining -= 3; 10319 if (remaining < 0) 10320 goto decode_loser; 10321 10322 size = ssl3_ConsumeHandshakeNumber(ss, 3, &b, &length); 10323 if (size <= 0) 10324 goto loser; /* fatal alert already sent by ConsumeHandshake. */ 10325 10326 if (remaining < size) 10327 goto decode_loser; 10328 10329 certItem.data = b; 10330 certItem.len = size; 10331 b += size; 10332 length -= size; 10333 remaining -= size; 10334 10335 c = PORT_ArenaNew(ss->ssl3.peerCertArena, ssl3CertNode); 10336 if (c == NULL) { 10337 goto loser; /* don't send alerts on memory errors */ 10338 } 10339 10340 c->cert = CERT_NewTempCertificate(ss->dbHandle, &certItem, NULL, 10341 PR_FALSE, PR_TRUE); 10342 if (c->cert == NULL) { 10343 goto ambiguous_err; 10344 } 10345 10346 c->next = NULL; 10347 if (lastCert) { 10348 lastCert->next = c; 10349 } else { 10350 ss->ssl3.peerCertChain = c; 10351 } 10352 lastCert = c; 10353 } 10354 10355 if (remaining != 0) 10356 goto decode_loser; 10357 10358 SECKEY_UpdateCertPQG(ss->sec.peerCert); 10359 10360 if (!isServer && ssl3_ExtensionNegotiated(ss, ssl_cert_status_xtn)) { 10361 ss->ssl3.hs.ws = wait_certificate_status; 10362 rv = SECSuccess; 10363 } else { 10364 rv = ssl3_AuthCertificate(ss); /* sets ss->ssl3.hs.ws */ 10365 } 10366 10367 return rv; 10368 10369 ambiguous_err: 10370 errCode = PORT_GetError(); 10371 switch (errCode) { 10372 case PR_OUT_OF_MEMORY_ERROR: 10373 case SEC_ERROR_BAD_DATABASE: 10374 case SEC_ERROR_NO_MEMORY: 10375 if (isTLS) { 10376 desc = internal_error; 10377 goto alert_loser; 10378 } 10379 goto loser; 10380 } 10381 ssl3_SendAlertForCertError(ss, errCode); 10382 goto loser; 10383 10384 decode_loser: 10385 desc = isTLS ? decode_error : bad_certificate; 10386 10387 alert_loser: 10388 (void)SSL3_SendAlert(ss, alert_fatal, desc); 10389 10390 loser: 10391 (void)ssl_MapLowLevelError(errCode); 10392 return SECFailure; 10393 } 10394 10395 static SECStatus 10396 ssl3_AuthCertificate(sslSocket *ss) 10397 { 10398 SECStatus rv; 10399 PRBool isServer = (PRBool)(!!ss->sec.isServer); 10400 int errCode; 10401 10402 ss->ssl3.hs.authCertificatePending = PR_FALSE; 10403 10404 /* 10405 * Ask caller-supplied callback function to validate cert chain. 10406 */ 10407 rv = (SECStatus)(*ss->authCertificate)(ss->authCertificateArg, ss->fd, 10408 PR_TRUE, isServer); 10409 if (rv) { 10410 errCode = PORT_GetError(); 10411 if (rv != SECWouldBlock) { 10412 if (ss->handleBadCert) { 10413 rv = (*ss->handleBadCert)(ss->badCertArg, ss->fd); 10414 } 10415 } 10416 10417 if (rv == SECWouldBlock) { 10418 if (ss->sec.isServer) { 10419 errCode = SSL_ERROR_FEATURE_NOT_SUPPORTED_FOR_SERVERS; 10420 rv = SECFailure; 10421 goto loser; 10422 } 10423 10424 ss->ssl3.hs.authCertificatePending = PR_TRUE; 10425 rv = SECSuccess; 10426 } 10427 10428 if (rv != SECSuccess) { 10429 ssl3_SendAlertForCertError(ss, errCode); 10430 goto loser; 10431 } 10432 } 10433 10434 ss->sec.ci.sid->peerCert = CERT_DupCertificate(ss->sec.peerCert); 10435 ssl3_CopyPeerCertsToSID(ss->ssl3.peerCertChain, ss->sec.ci.sid); 10436 10437 if (!ss->sec.isServer) { 10438 CERTCertificate *cert = ss->sec.peerCert; 10439 10440 /* set the server authentication and key exchange types and sizes 10441 ** from the value in the cert. If the key exchange key is different, 10442 ** it will get fixed when we handle the server key exchange message. 10443 */ 10444 SECKEYPublicKey * pubKey = CERT_ExtractPublicKey(cert); 10445 ss->sec.authAlgorithm = ss->ssl3.hs.kea_def->signKeyType; 10446 ss->sec.keaType = ss->ssl3.hs.kea_def->exchKeyType; 10447 if (pubKey) { 10448 ss->sec.keaKeyBits = ss->sec.authKeyBits = 10449 SECKEY_PublicKeyStrengthInBits(pubKey); 10450 #ifdef NSS_ENABLE_ECC 10451 if (ss->sec.keaType == kt_ecdh) { 10452 /* Get authKeyBits from signing key. 10453 * XXX The code below uses a quick approximation of 10454 * key size based on cert->signatureWrap.signature.data 10455 * (which contains the DER encoded signature). The field 10456 * cert->signatureWrap.signature.len contains the 10457 * length of the encoded signature in bits. 10458 */ 10459 if (ss->ssl3.hs.kea_def->kea == kea_ecdh_ecdsa) { 10460 ss->sec.authKeyBits = 10461 cert->signatureWrap.signature.data[3]*8; 10462 if (cert->signatureWrap.signature.data[4] == 0x00) 10463 ss->sec.authKeyBits -= 8; 10464 /* 10465 * XXX: if cert is not signed by ecdsa we should 10466 * destroy pubKey and goto bad_cert 10467 */ 10468 } else if (ss->ssl3.hs.kea_def->kea == kea_ecdh_rsa) { 10469 ss->sec.authKeyBits = cert->signatureWrap.signature.len; 10470 /* 10471 * XXX: if cert is not signed by rsa we should 10472 * destroy pubKey and goto bad_cert 10473 */ 10474 } 10475 } 10476 #endif /* NSS_ENABLE_ECC */ 10477 SECKEY_DestroyPublicKey(pubKey); 10478 pubKey = NULL; 10479 } 10480 10481 ss->ssl3.hs.ws = wait_cert_request; /* disallow server_key_exchange */ 10482 if (ss->ssl3.hs.kea_def->is_limited || 10483 /* XXX OR server cert is signing only. */ 10484 #ifdef NSS_ENABLE_ECC 10485 ss->ssl3.hs.kea_def->kea == kea_ecdhe_ecdsa || 10486 ss->ssl3.hs.kea_def->kea == kea_ecdhe_rsa || 10487 #endif /* NSS_ENABLE_ECC */ 10488 ss->ssl3.hs.kea_def->exchKeyType == kt_dh) { 10489 ss->ssl3.hs.ws = wait_server_key; /* allow server_key_exchange */ 10490 } 10491 } else { 10492 ss->ssl3.hs.ws = wait_client_key; 10493 } 10494 10495 PORT_Assert(rv == SECSuccess); 10496 if (rv != SECSuccess) { 10497 errCode = SEC_ERROR_LIBRARY_FAILURE; 10498 rv = SECFailure; 10499 goto loser; 10500 } 10501 10502 return rv; 10503 10504 loser: 10505 (void)ssl_MapLowLevelError(errCode); 10506 return SECFailure; 10507 } 10508 10509 static SECStatus ssl3_FinishHandshake(sslSocket *ss); 10510 10511 static SECStatus 10512 ssl3_AlwaysFail(sslSocket * ss) 10513 { 10514 PORT_SetError(PR_INVALID_STATE_ERROR); 10515 return SECFailure; 10516 } 10517 10518 /* Caller must hold 1stHandshakeLock. 10519 */ 10520 SECStatus 10521 ssl3_AuthCertificateComplete(sslSocket *ss, PRErrorCode error) 10522 { 10523 SECStatus rv; 10524 10525 PORT_Assert(ss->opt.noLocks || ssl_Have1stHandshakeLock(ss)); 10526 10527 if (ss->sec.isServer) { 10528 PORT_SetError(SSL_ERROR_FEATURE_NOT_SUPPORTED_FOR_SERVERS); 10529 return SECFailure; 10530 } 10531 10532 ssl_GetRecvBufLock(ss); 10533 ssl_GetSSL3HandshakeLock(ss); 10534 10535 if (!ss->ssl3.hs.authCertificatePending) { 10536 PORT_SetError(PR_INVALID_STATE_ERROR); 10537 rv = SECFailure; 10538 goto done; 10539 } 10540 10541 ss->ssl3.hs.authCertificatePending = PR_FALSE; 10542 10543 if (error != 0) { 10544 ss->ssl3.hs.restartTarget = ssl3_AlwaysFail; 10545 ssl3_SendAlertForCertError(ss, error); 10546 rv = SECSuccess; 10547 } else if (ss->ssl3.hs.restartTarget != NULL) { 10548 sslRestartTarget target = ss->ssl3.hs.restartTarget; 10549 ss->ssl3.hs.restartTarget = NULL; 10550 10551 if (target == ssl3_FinishHandshake) { 10552 SSL_TRC(3,("%d: SSL3[%p]: certificate authentication lost the race" 10553 " with peer's finished message", SSL_GETPID(), ss->fd)); 10554 } 10555 10556 rv = target(ss); 10557 /* Even if we blocked here, we have accomplished enough to claim 10558 * success. Any remaining work will be taken care of by subsequent 10559 * calls to SSL_ForceHandshake/PR_Send/PR_Read/etc. 10560 */ 10561 if (rv == SECWouldBlock) { 10562 rv = SECSuccess; 10563 } 10564 } else { 10565 SSL_TRC(3, ("%d: SSL3[%p]: certificate authentication won the race with" 10566 " peer's finished message", SSL_GETPID(), ss->fd)); 10567 10568 PORT_Assert(!ss->ssl3.hs.isResuming); 10569 PORT_Assert(ss->ssl3.hs.ws != idle_handshake); 10570 10571 if (ss->opt.enableFalseStart && 10572 !ss->firstHsDone && 10573 !ss->ssl3.hs.isResuming && 10574 ssl3_WaitingForStartOfServerSecondRound(ss)) { 10575 /* ssl3_SendClientSecondRound deferred the false start check because 10576 * certificate authentication was pending, so we do it now if we still 10577 * haven't received any of the server's second round yet. 10578 */ 10579 rv = ssl3_CheckFalseStart(ss); 10580 } else { 10581 rv = SECSuccess; 10582 } 10583 } 10584 10585 done: 10586 ssl_ReleaseSSL3HandshakeLock(ss); 10587 ssl_ReleaseRecvBufLock(ss); 10588 10589 return rv; 10590 } 10591 10592 static SECStatus 10593 ssl3_ComputeTLSFinished(ssl3CipherSpec *spec, 10594 PRBool isServer, 10595 const SSL3Hashes * hashes, 10596 TLSFinished * tlsFinished) 10597 { 10598 const char * label; 10599 unsigned int len; 10600 SECStatus rv; 10601 10602 label = isServer ? "server finished" : "client finished"; 10603 len = 15; 10604 10605 rv = ssl3_TLSPRFWithMasterSecret(spec, label, len, hashes->u.raw, 10606 hashes->len, tlsFinished->verify_data, 10607 sizeof tlsFinished->verify_data); 10608 10609 return rv; 10610 } 10611 10612 /* The calling function must acquire and release the appropriate 10613 * lock (e.g., ssl_GetSpecReadLock / ssl_ReleaseSpecReadLock for 10614 * ss->ssl3.crSpec). 10615 */ 10616 SECStatus 10617 ssl3_TLSPRFWithMasterSecret(ssl3CipherSpec *spec, const char *label, 10618 unsigned int labelLen, const unsigned char *val, unsigned int valLen, 10619 unsigned char *out, unsigned int outLen) 10620 { 10621 SECStatus rv = SECSuccess; 10622 10623 if (spec->master_secret && !spec->bypassCiphers) { 10624 SECItem param = {siBuffer, NULL, 0}; 10625 CK_MECHANISM_TYPE mech = CKM_TLS_PRF_GENERAL; 10626 PK11Context *prf_context; 10627 unsigned int retLen; 10628 10629 if (spec->version >= SSL_LIBRARY_VERSION_TLS_1_2) { 10630 mech = CKM_NSS_TLS_PRF_GENERAL_SHA256; 10631 } 10632 prf_context = PK11_CreateContextBySymKey(mech, CKA_SIGN, 10633 spec->master_secret, ¶m); 10634 if (!prf_context) 10635 return SECFailure; 10636 10637 rv = PK11_DigestBegin(prf_context); 10638 rv |= PK11_DigestOp(prf_context, (unsigned char *) label, labelLen); 10639 rv |= PK11_DigestOp(prf_context, val, valLen); 10640 rv |= PK11_DigestFinal(prf_context, out, &retLen, outLen); 10641 PORT_Assert(rv != SECSuccess || retLen == outLen); 10642 10643 PK11_DestroyContext(prf_context, PR_TRUE); 10644 } else { 10645 /* bypass PKCS11 */ 10646 #ifdef NO_PKCS11_BYPASS 10647 PORT_Assert(spec->master_secret); 10648 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 10649 rv = SECFailure; 10650 #else 10651 SECItem inData = { siBuffer, }; 10652 SECItem outData = { siBuffer, }; 10653 PRBool isFIPS = PR_FALSE; 10654 10655 inData.data = (unsigned char *) val; 10656 inData.len = valLen; 10657 outData.data = out; 10658 outData.len = outLen; 10659 if (spec->version >= SSL_LIBRARY_VERSION_TLS_1_2) { 10660 rv = TLS_P_hash(HASH_AlgSHA256, &spec->msItem, label, &inData, 10661 &outData, isFIPS); 10662 } else { 10663 rv = TLS_PRF(&spec->msItem, label, &inData, &outData, isFIPS); 10664 } 10665 PORT_Assert(rv != SECSuccess || outData.len == outLen); 10666 #endif 10667 } 10668 return rv; 10669 } 10670 10671 /* called from ssl3_SendClientSecondRound 10672 * ssl3_HandleFinished 10673 */ 10674 static SECStatus 10675 ssl3_SendNextProto(sslSocket *ss) 10676 { 10677 SECStatus rv; 10678 int padding_len; 10679 static const unsigned char padding[32] = {0}; 10680 10681 if (ss->ssl3.nextProto.len == 0 || 10682 ss->ssl3.nextProtoState == SSL_NEXT_PROTO_SELECTED) { 10683 return SECSuccess; 10684 } 10685 10686 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 10687 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 10688 10689 padding_len = 32 - ((ss->ssl3.nextProto.len + 2) % 32); 10690 10691 rv = ssl3_AppendHandshakeHeader(ss, next_proto, ss->ssl3.nextProto.len + 10692 2 + padding_len); 10693 if (rv != SECSuccess) { 10694 return rv; /* error code set by AppendHandshakeHeader */ 10695 } 10696 rv = ssl3_AppendHandshakeVariable(ss, ss->ssl3.nextProto.data, 10697 ss->ssl3.nextProto.len, 1); 10698 if (rv != SECSuccess) { 10699 return rv; /* error code set by AppendHandshake */ 10700 } 10701 rv = ssl3_AppendHandshakeVariable(ss, padding, padding_len, 1); 10702 if (rv != SECSuccess) { 10703 return rv; /* error code set by AppendHandshake */ 10704 } 10705 return rv; 10706 } 10707 10708 /* called from ssl3_SendFinished 10709 * 10710 * This function is simply a debugging aid and therefore does not return a 10711 * SECStatus. */ 10712 static void 10713 ssl3_RecordKeyLog(sslSocket *ss) 10714 { 10715 SECStatus rv; 10716 SECItem *keyData; 10717 char buf[14 /* "CLIENT_RANDOM " */ + 10718 SSL3_RANDOM_LENGTH*2 /* client_random */ + 10719 1 /* " " */ + 10720 48*2 /* master secret */ + 10721 1 /* new line */]; 10722 unsigned int j; 10723 10724 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 10725 10726 if (!ssl_keylog_iob) 10727 return; 10728 10729 rv = PK11_ExtractKeyValue(ss->ssl3.cwSpec->master_secret); 10730 if (rv != SECSuccess) 10731 return; 10732 10733 ssl_GetSpecReadLock(ss); 10734 10735 /* keyData does not need to be freed. */ 10736 keyData = PK11_GetKeyData(ss->ssl3.cwSpec->master_secret); 10737 if (!keyData || !keyData->data || keyData->len != 48) { 10738 ssl_ReleaseSpecReadLock(ss); 10739 return; 10740 } 10741 10742 /* https://developer.mozilla.org/en/NSS_Key_Log_Format */ 10743 10744 /* There could be multiple, concurrent writers to the 10745 * keylog, so we have to do everything in a single call to 10746 * fwrite. */ 10747 10748 memcpy(buf, "CLIENT_RANDOM ", 14); 10749 j = 14; 10750 hexEncode(buf + j, ss->ssl3.hs.client_random.rand, SSL3_RANDOM_LENGTH); 10751 j += SSL3_RANDOM_LENGTH*2; 10752 buf[j++] = ' '; 10753 hexEncode(buf + j, keyData->data, 48); 10754 j += 48*2; 10755 buf[j++] = '\n'; 10756 10757 PORT_Assert(j == sizeof(buf)); 10758 10759 ssl_ReleaseSpecReadLock(ss); 10760 10761 if (fwrite(buf, sizeof(buf), 1, ssl_keylog_iob) != 1) 10762 return; 10763 fflush(ssl_keylog_iob); 10764 return; 10765 } 10766 10767 /* called from ssl3_SendClientSecondRound 10768 * ssl3_HandleFinished 10769 */ 10770 static SECStatus 10771 ssl3_SendEncryptedExtensions(sslSocket *ss) 10772 { 10773 static const char CHANNEL_ID_MAGIC[] = "TLS Channel ID signature"; 10774 static const char CHANNEL_ID_RESUMPTION_MAGIC[] = "Resumption"; 10775 /* This is the ASN.1 prefix for a P-256 public key. Specifically it's: 10776 * SEQUENCE 10777 * SEQUENCE 10778 * OID id-ecPublicKey 10779 * OID prime256v1 10780 * BIT STRING, length 66, 0 trailing bits: 0x04 10781 * 10782 * The 0x04 in the BIT STRING is the prefix for an uncompressed, X9.62 10783 * public key. Following that are the two field elements as 32-byte, 10784 * big-endian numbers, as required by the Channel ID. */ 10785 static const unsigned char P256_SPKI_PREFIX[] = { 10786 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 10787 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 10788 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 10789 0x42, 0x00, 0x04 10790 }; 10791 /* ChannelIDs are always 128 bytes long: 64 bytes of P-256 public key and 64 10792 * bytes of ECDSA signature. */ 10793 static const int CHANNEL_ID_PUBLIC_KEY_LENGTH = 64; 10794 static const int CHANNEL_ID_LENGTH = 128; 10795 10796 SECStatus rv = SECFailure; 10797 SECItem *spki = NULL; 10798 SSL3Hashes hashes; 10799 const unsigned char *pub_bytes; 10800 unsigned char signed_data[sizeof(CHANNEL_ID_MAGIC) + 10801 sizeof(CHANNEL_ID_RESUMPTION_MAGIC) + 10802 sizeof(SSL3Hashes)*2]; 10803 size_t signed_data_len; 10804 unsigned char digest[SHA256_LENGTH]; 10805 SECItem digest_item; 10806 unsigned char signature[64]; 10807 SECItem signature_item; 10808 10809 PORT_Assert(ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 10810 PORT_Assert(ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 10811 10812 if (ss->ssl3.channelID == NULL) 10813 return SECSuccess; 10814 10815 PORT_Assert(ssl3_ExtensionNegotiated(ss, ssl_channel_id_xtn)); 10816 10817 if (SECKEY_GetPrivateKeyType(ss->ssl3.channelID) != ecKey || 10818 PK11_SignatureLen(ss->ssl3.channelID) != sizeof(signature)) { 10819 PORT_SetError(SSL_ERROR_INVALID_CHANNEL_ID_KEY); 10820 rv = SECFailure; 10821 goto loser; 10822 } 10823 10824 ssl_GetSpecReadLock(ss); 10825 rv = ssl3_ComputeHandshakeHashes(ss, ss->ssl3.cwSpec, &hashes, 0); 10826 ssl_ReleaseSpecReadLock(ss); 10827 10828 if (rv != SECSuccess) 10829 goto loser; 10830 10831 rv = ssl3_AppendHandshakeHeader(ss, encrypted_extensions, 10832 2 + 2 + CHANNEL_ID_LENGTH); 10833 if (rv != SECSuccess) 10834 goto loser; /* error code set by AppendHandshakeHeader */ 10835 rv = ssl3_AppendHandshakeNumber(ss, ssl_channel_id_xtn, 2); 10836 if (rv != SECSuccess) 10837 goto loser; /* error code set by AppendHandshake */ 10838 rv = ssl3_AppendHandshakeNumber(ss, CHANNEL_ID_LENGTH, 2); 10839 if (rv != SECSuccess) 10840 goto loser; /* error code set by AppendHandshake */ 10841 10842 spki = SECKEY_EncodeDERSubjectPublicKeyInfo(ss->ssl3.channelIDPub); 10843 10844 if (spki->len != sizeof(P256_SPKI_PREFIX) + CHANNEL_ID_PUBLIC_KEY_LENGTH || 10845 memcmp(spki->data, P256_SPKI_PREFIX, sizeof(P256_SPKI_PREFIX)) != 0) { 10846 PORT_SetError(SSL_ERROR_INVALID_CHANNEL_ID_KEY); 10847 rv = SECFailure; 10848 goto loser; 10849 } 10850 10851 pub_bytes = spki->data + sizeof(P256_SPKI_PREFIX); 10852 10853 signed_data_len = 0; 10854 memcpy(signed_data + signed_data_len, CHANNEL_ID_MAGIC, 10855 sizeof(CHANNEL_ID_MAGIC)); 10856 signed_data_len += sizeof(CHANNEL_ID_MAGIC); 10857 if (ss->ssl3.hs.isResuming) { 10858 SECItem *originalHandshakeHash = 10859 &ss->sec.ci.sid->u.ssl3.originalHandshakeHash; 10860 PORT_Assert(originalHandshakeHash->len > 0); 10861 10862 memcpy(signed_data + signed_data_len, CHANNEL_ID_RESUMPTION_MAGIC, 10863 sizeof(CHANNEL_ID_RESUMPTION_MAGIC)); 10864 signed_data_len += sizeof(CHANNEL_ID_RESUMPTION_MAGIC); 10865 memcpy(signed_data + signed_data_len, originalHandshakeHash->data, 10866 originalHandshakeHash->len); 10867 signed_data_len += originalHandshakeHash->len; 10868 } 10869 memcpy(signed_data + signed_data_len, hashes.u.raw, hashes.len); 10870 signed_data_len += hashes.len; 10871 10872 rv = PK11_HashBuf(SEC_OID_SHA256, digest, signed_data, signed_data_len); 10873 if (rv != SECSuccess) 10874 goto loser; 10875 10876 digest_item.data = digest; 10877 digest_item.len = sizeof(digest); 10878 10879 signature_item.data = signature; 10880 signature_item.len = sizeof(signature); 10881 10882 rv = PK11_Sign(ss->ssl3.channelID, &signature_item, &digest_item); 10883 if (rv != SECSuccess) 10884 goto loser; 10885 10886 rv = ssl3_AppendHandshake(ss, pub_bytes, CHANNEL_ID_PUBLIC_KEY_LENGTH); 10887 if (rv != SECSuccess) 10888 goto loser; 10889 rv = ssl3_AppendHandshake(ss, signature, sizeof(signature)); 10890 10891 loser: 10892 if (spki) 10893 SECITEM_FreeItem(spki, PR_TRUE); 10894 if (ss->ssl3.channelID) { 10895 SECKEY_DestroyPrivateKey(ss->ssl3.channelID); 10896 ss->ssl3.channelID = NULL; 10897 } 10898 if (ss->ssl3.channelIDPub) { 10899 SECKEY_DestroyPublicKey(ss->ssl3.channelIDPub); 10900 ss->ssl3.channelIDPub = NULL; 10901 } 10902 10903 return rv; 10904 } 10905 10906 /* ssl3_RestartHandshakeAfterChannelIDReq is called to restart a handshake 10907 * after a ChannelID callback returned SECWouldBlock. At this point we have 10908 * processed the server's ServerHello but not yet any further messages. We will 10909 * always get a message from the server after a ServerHello so either they are 10910 * waiting in the buffer or we'll get network I/O. */ 10911 SECStatus 10912 ssl3_RestartHandshakeAfterChannelIDReq(sslSocket *ss, 10913 SECKEYPublicKey *channelIDPub, 10914 SECKEYPrivateKey *channelID) 10915 { 10916 if (ss->handshake == 0) { 10917 SECKEY_DestroyPublicKey(channelIDPub); 10918 SECKEY_DestroyPrivateKey(channelID); 10919 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 10920 return SECFailure; 10921 } 10922 10923 if (channelIDPub == NULL || 10924 channelID == NULL) { 10925 if (channelIDPub) 10926 SECKEY_DestroyPublicKey(channelIDPub); 10927 if (channelID) 10928 SECKEY_DestroyPrivateKey(channelID); 10929 PORT_SetError(PR_INVALID_ARGUMENT_ERROR); 10930 return SECFailure; 10931 } 10932 10933 if (ss->ssl3.channelID) 10934 SECKEY_DestroyPrivateKey(ss->ssl3.channelID); 10935 if (ss->ssl3.channelIDPub) 10936 SECKEY_DestroyPublicKey(ss->ssl3.channelIDPub); 10937 10938 ss->handshake = ssl_GatherRecord1stHandshake; 10939 ss->ssl3.channelID = channelID; 10940 ss->ssl3.channelIDPub = channelIDPub; 10941 10942 return SECSuccess; 10943 } 10944 10945 /* called from ssl3_SendClientSecondRound 10946 * ssl3_HandleClientHello 10947 * ssl3_HandleFinished 10948 */ 10949 static SECStatus 10950 ssl3_SendFinished(sslSocket *ss, PRInt32 flags) 10951 { 10952 ssl3CipherSpec *cwSpec; 10953 PRBool isTLS; 10954 PRBool isServer = ss->sec.isServer; 10955 SECStatus rv; 10956 SSL3Sender sender = isServer ? sender_server : sender_client; 10957 SSL3Hashes hashes; 10958 TLSFinished tlsFinished; 10959 10960 SSL_TRC(3, ("%d: SSL3[%d]: send finished handshake", SSL_GETPID(), ss->fd)); 10961 10962 PORT_Assert( ss->opt.noLocks || ssl_HaveXmitBufLock(ss)); 10963 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 10964 10965 ssl_GetSpecReadLock(ss); 10966 cwSpec = ss->ssl3.cwSpec; 10967 isTLS = (PRBool)(cwSpec->version > SSL_LIBRARY_VERSION_3_0); 10968 rv = ssl3_ComputeHandshakeHashes(ss, cwSpec, &hashes, sender); 10969 if (isTLS && rv == SECSuccess) { 10970 rv = ssl3_ComputeTLSFinished(cwSpec, isServer, &hashes, &tlsFinished); 10971 } 10972 ssl_ReleaseSpecReadLock(ss); 10973 if (rv != SECSuccess) { 10974 goto fail; /* err code was set by ssl3_ComputeHandshakeHashes */ 10975 } 10976 10977 if (isTLS) { 10978 if (isServer) 10979 ss->ssl3.hs.finishedMsgs.tFinished[1] = tlsFinished; 10980 else 10981 ss->ssl3.hs.finishedMsgs.tFinished[0] = tlsFinished; 10982 ss->ssl3.hs.finishedBytes = sizeof tlsFinished; 10983 rv = ssl3_AppendHandshakeHeader(ss, finished, sizeof tlsFinished); 10984 if (rv != SECSuccess) 10985 goto fail; /* err set by AppendHandshake. */ 10986 rv = ssl3_AppendHandshake(ss, &tlsFinished, sizeof tlsFinished); 10987 if (rv != SECSuccess) 10988 goto fail; /* err set by AppendHandshake. */ 10989 } else { 10990 if (isServer) 10991 ss->ssl3.hs.finishedMsgs.sFinished[1] = hashes.u.s; 10992 else 10993 ss->ssl3.hs.finishedMsgs.sFinished[0] = hashes.u.s; 10994 PORT_Assert(hashes.len == sizeof hashes.u.s); 10995 ss->ssl3.hs.finishedBytes = sizeof hashes.u.s; 10996 rv = ssl3_AppendHandshakeHeader(ss, finished, sizeof hashes.u.s); 10997 if (rv != SECSuccess) 10998 goto fail; /* err set by AppendHandshake. */ 10999 rv = ssl3_AppendHandshake(ss, &hashes.u.s, sizeof hashes.u.s); 11000 if (rv != SECSuccess) 11001 goto fail; /* err set by AppendHandshake. */ 11002 } 11003 rv = ssl3_FlushHandshake(ss, flags); 11004 if (rv != SECSuccess) { 11005 goto fail; /* error code set by ssl3_FlushHandshake */ 11006 } 11007 11008 ssl3_RecordKeyLog(ss); 11009 11010 return SECSuccess; 11011 11012 fail: 11013 return rv; 11014 } 11015 11016 /* wrap the master secret, and put it into the SID. 11017 * Caller holds the Spec read lock. 11018 */ 11019 SECStatus 11020 ssl3_CacheWrappedMasterSecret(sslSocket *ss, sslSessionID *sid, 11021 ssl3CipherSpec *spec, SSL3KEAType effectiveExchKeyType) 11022 { 11023 PK11SymKey * wrappingKey = NULL; 11024 PK11SlotInfo * symKeySlot; 11025 void * pwArg = ss->pkcs11PinArg; 11026 SECStatus rv = SECFailure; 11027 PRBool isServer = ss->sec.isServer; 11028 CK_MECHANISM_TYPE mechanism = CKM_INVALID_MECHANISM; 11029 symKeySlot = PK11_GetSlotFromKey(spec->master_secret); 11030 if (!isServer) { 11031 int wrapKeyIndex; 11032 int incarnation; 11033 11034 /* these next few functions are mere accessors and don't fail. */ 11035 sid->u.ssl3.masterWrapIndex = wrapKeyIndex = 11036 PK11_GetCurrentWrapIndex(symKeySlot); 11037 PORT_Assert(wrapKeyIndex == 0); /* array has only one entry! */ 11038 11039 sid->u.ssl3.masterWrapSeries = incarnation = 11040 PK11_GetSlotSeries(symKeySlot); 11041 sid->u.ssl3.masterSlotID = PK11_GetSlotID(symKeySlot); 11042 sid->u.ssl3.masterModuleID = PK11_GetModuleID(symKeySlot); 11043 sid->u.ssl3.masterValid = PR_TRUE; 11044 /* Get the default wrapping key, for wrapping the master secret before 11045 * placing it in the SID cache entry. */ 11046 wrappingKey = PK11_GetWrapKey(symKeySlot, wrapKeyIndex, 11047 CKM_INVALID_MECHANISM, incarnation, 11048 pwArg); 11049 if (wrappingKey) { 11050 mechanism = PK11_GetMechanism(wrappingKey); /* can't fail. */ 11051 } else { 11052 int keyLength; 11053 /* if the wrappingKey doesn't exist, attempt to create it. 11054 * Note: we intentionally ignore errors here. If we cannot 11055 * generate a wrapping key, it is not fatal to this SSL connection, 11056 * but we will not be able to restart this session. 11057 */ 11058 mechanism = PK11_GetBestWrapMechanism(symKeySlot); 11059 keyLength = PK11_GetBestKeyLength(symKeySlot, mechanism); 11060 /* Zero length means fixed key length algorithm, or error. 11061 * It's ambiguous. 11062 */ 11063 wrappingKey = PK11_KeyGen(symKeySlot, mechanism, NULL, 11064 keyLength, pwArg); 11065 if (wrappingKey) { 11066 PK11_SetWrapKey(symKeySlot, wrapKeyIndex, wrappingKey); 11067 } 11068 } 11069 } else { 11070 /* server socket using session cache. */ 11071 mechanism = PK11_GetBestWrapMechanism(symKeySlot); 11072 if (mechanism != CKM_INVALID_MECHANISM) { 11073 wrappingKey = 11074 getWrappingKey(ss, symKeySlot, effectiveExchKeyType, 11075 mechanism, pwArg); 11076 if (wrappingKey) { 11077 mechanism = PK11_GetMechanism(wrappingKey); /* can't fail. */ 11078 } 11079 } 11080 } 11081 11082 sid->u.ssl3.masterWrapMech = mechanism; 11083 PK11_FreeSlot(symKeySlot); 11084 11085 if (wrappingKey) { 11086 SECItem wmsItem; 11087 11088 wmsItem.data = sid->u.ssl3.keys.wrapped_master_secret; 11089 wmsItem.len = sizeof sid->u.ssl3.keys.wrapped_master_secret; 11090 rv = PK11_WrapSymKey(mechanism, NULL, wrappingKey, 11091 spec->master_secret, &wmsItem); 11092 /* rv is examined below. */ 11093 sid->u.ssl3.keys.wrapped_master_secret_len = wmsItem.len; 11094 PK11_FreeSymKey(wrappingKey); 11095 } 11096 return rv; 11097 } 11098 11099 /* Called from ssl3_HandleHandshakeMessage() when it has deciphered a complete 11100 * ssl3 Finished message from the peer. 11101 * Caller must hold Handshake and RecvBuf locks. 11102 */ 11103 static SECStatus 11104 ssl3_HandleFinished(sslSocket *ss, SSL3Opaque *b, PRUint32 length, 11105 const SSL3Hashes *hashes) 11106 { 11107 sslSessionID * sid = ss->sec.ci.sid; 11108 SECStatus rv = SECSuccess; 11109 PRBool isServer = ss->sec.isServer; 11110 PRBool isTLS; 11111 SSL3KEAType effectiveExchKeyType; 11112 11113 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 11114 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 11115 11116 SSL_TRC(3, ("%d: SSL3[%d]: handle finished handshake", 11117 SSL_GETPID(), ss->fd)); 11118 11119 if (ss->ssl3.hs.ws != wait_finished) { 11120 SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11121 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_FINISHED); 11122 return SECFailure; 11123 } 11124 11125 isTLS = (PRBool)(ss->ssl3.crSpec->version > SSL_LIBRARY_VERSION_3_0); 11126 if (isTLS) { 11127 TLSFinished tlsFinished; 11128 11129 if (length != sizeof tlsFinished) { 11130 (void)SSL3_SendAlert(ss, alert_fatal, decode_error); 11131 PORT_SetError(SSL_ERROR_RX_MALFORMED_FINISHED); 11132 return SECFailure; 11133 } 11134 rv = ssl3_ComputeTLSFinished(ss->ssl3.crSpec, !isServer, 11135 hashes, &tlsFinished); 11136 if (!isServer) 11137 ss->ssl3.hs.finishedMsgs.tFinished[1] = tlsFinished; 11138 else 11139 ss->ssl3.hs.finishedMsgs.tFinished[0] = tlsFinished; 11140 ss->ssl3.hs.finishedBytes = sizeof tlsFinished; 11141 if (rv != SECSuccess || 11142 0 != NSS_SecureMemcmp(&tlsFinished, b, length)) { 11143 (void)SSL3_SendAlert(ss, alert_fatal, decrypt_error); 11144 PORT_SetError(SSL_ERROR_BAD_HANDSHAKE_HASH_VALUE); 11145 return SECFailure; 11146 } 11147 } else { 11148 if (length != sizeof(SSL3Finished)) { 11149 (void)ssl3_IllegalParameter(ss); 11150 PORT_SetError(SSL_ERROR_RX_MALFORMED_FINISHED); 11151 return SECFailure; 11152 } 11153 11154 if (!isServer) 11155 ss->ssl3.hs.finishedMsgs.sFinished[1] = hashes->u.s; 11156 else 11157 ss->ssl3.hs.finishedMsgs.sFinished[0] = hashes->u.s; 11158 PORT_Assert(hashes->len == sizeof hashes->u.s); 11159 ss->ssl3.hs.finishedBytes = sizeof hashes->u.s; 11160 if (0 != NSS_SecureMemcmp(&hashes->u.s, b, length)) { 11161 (void)ssl3_HandshakeFailure(ss); 11162 PORT_SetError(SSL_ERROR_BAD_HANDSHAKE_HASH_VALUE); 11163 return SECFailure; 11164 } 11165 } 11166 11167 ssl_GetXmitBufLock(ss); /*************************************/ 11168 11169 if ((isServer && !ss->ssl3.hs.isResuming) || 11170 (!isServer && ss->ssl3.hs.isResuming)) { 11171 PRInt32 flags = 0; 11172 11173 /* Send a NewSessionTicket message if the client sent us 11174 * either an empty session ticket, or one that did not verify. 11175 * (Note that if either of these conditions was met, then the 11176 * server has sent a SessionTicket extension in the 11177 * ServerHello message.) 11178 */ 11179 if (isServer && !ss->ssl3.hs.isResuming && 11180 ssl3_ExtensionNegotiated(ss, ssl_session_ticket_xtn)) { 11181 /* RFC 5077 Section 3.3: "In the case of a full handshake, the 11182 * server MUST verify the client's Finished message before sending 11183 * the ticket." Presumably, this also means that the client's 11184 * certificate, if any, must be verified beforehand too. 11185 */ 11186 rv = ssl3_SendNewSessionTicket(ss); 11187 if (rv != SECSuccess) { 11188 goto xmit_loser; 11189 } 11190 } 11191 11192 rv = ssl3_SendChangeCipherSpecs(ss); 11193 if (rv != SECSuccess) { 11194 goto xmit_loser; /* err is set. */ 11195 } 11196 /* If this thread is in SSL_SecureSend (trying to write some data) 11197 ** then set the ssl_SEND_FLAG_FORCE_INTO_BUFFER flag, so that the 11198 ** last two handshake messages (change cipher spec and finished) 11199 ** will be sent in the same send/write call as the application data. 11200 */ 11201 if (ss->writerThread == PR_GetCurrentThread()) { 11202 flags = ssl_SEND_FLAG_FORCE_INTO_BUFFER; 11203 } 11204 11205 if (!isServer) { 11206 if (!ss->firstHsDone) { 11207 rv = ssl3_SendNextProto(ss); 11208 if (rv != SECSuccess) { 11209 goto xmit_loser; /* err code was set. */ 11210 } 11211 } 11212 rv = ssl3_SendEncryptedExtensions(ss); 11213 if (rv != SECSuccess) 11214 goto xmit_loser; /* err code was set. */ 11215 } 11216 11217 if (IS_DTLS(ss)) { 11218 flags |= ssl_SEND_FLAG_NO_RETRANSMIT; 11219 } 11220 11221 rv = ssl3_SendFinished(ss, flags); 11222 if (rv != SECSuccess) { 11223 goto xmit_loser; /* err is set. */ 11224 } 11225 } 11226 11227 xmit_loser: 11228 ssl_ReleaseXmitBufLock(ss); /*************************************/ 11229 if (rv != SECSuccess) { 11230 return rv; 11231 } 11232 11233 if (ss->ssl3.hs.kea_def->kea == kea_ecdhe_rsa) { 11234 effectiveExchKeyType = kt_rsa; 11235 } else { 11236 effectiveExchKeyType = ss->ssl3.hs.kea_def->exchKeyType; 11237 } 11238 11239 if (sid->cached == never_cached && !ss->opt.noCache && ss->sec.cache) { 11240 /* fill in the sid */ 11241 sid->u.ssl3.cipherSuite = ss->ssl3.hs.cipher_suite; 11242 sid->u.ssl3.compression = ss->ssl3.hs.compression; 11243 sid->u.ssl3.policy = ss->ssl3.policy; 11244 #ifdef NSS_ENABLE_ECC 11245 sid->u.ssl3.negotiatedECCurves = ss->ssl3.hs.negotiatedECCurves; 11246 #endif 11247 sid->u.ssl3.exchKeyType = effectiveExchKeyType; 11248 sid->version = ss->version; 11249 sid->authAlgorithm = ss->sec.authAlgorithm; 11250 sid->authKeyBits = ss->sec.authKeyBits; 11251 sid->keaType = ss->sec.keaType; 11252 sid->keaKeyBits = ss->sec.keaKeyBits; 11253 sid->lastAccessTime = sid->creationTime = ssl_Time(); 11254 sid->expirationTime = sid->creationTime + ssl3_sid_timeout; 11255 sid->localCert = CERT_DupCertificate(ss->sec.localCert); 11256 11257 ssl_GetSpecReadLock(ss); /*************************************/ 11258 11259 /* Copy the master secret (wrapped or unwrapped) into the sid */ 11260 if (ss->ssl3.crSpec->msItem.len && ss->ssl3.crSpec->msItem.data) { 11261 sid->u.ssl3.keys.wrapped_master_secret_len = 11262 ss->ssl3.crSpec->msItem.len; 11263 memcpy(sid->u.ssl3.keys.wrapped_master_secret, 11264 ss->ssl3.crSpec->msItem.data, ss->ssl3.crSpec->msItem.len); 11265 sid->u.ssl3.masterValid = PR_TRUE; 11266 sid->u.ssl3.keys.msIsWrapped = PR_FALSE; 11267 rv = SECSuccess; 11268 } else { 11269 rv = ssl3_CacheWrappedMasterSecret(ss, ss->sec.ci.sid, 11270 ss->ssl3.crSpec, 11271 effectiveExchKeyType); 11272 sid->u.ssl3.keys.msIsWrapped = PR_TRUE; 11273 } 11274 ssl_ReleaseSpecReadLock(ss); /*************************************/ 11275 11276 /* If the wrap failed, we don't cache the sid. 11277 * The connection continues normally however. 11278 */ 11279 ss->ssl3.hs.cacheSID = rv == SECSuccess; 11280 } 11281 11282 if (ss->ssl3.hs.authCertificatePending) { 11283 if (ss->ssl3.hs.restartTarget) { 11284 PR_NOT_REACHED("ssl3_HandleFinished: unexpected restartTarget"); 11285 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 11286 return SECFailure; 11287 } 11288 11289 ss->ssl3.hs.restartTarget = ssl3_FinishHandshake; 11290 return SECWouldBlock; 11291 } 11292 11293 rv = ssl3_FinishHandshake(ss); 11294 return rv; 11295 } 11296 11297 /* The return type is SECStatus instead of void because this function needs 11298 * to have type sslRestartTarget. 11299 */ 11300 SECStatus 11301 ssl3_FinishHandshake(sslSocket * ss) 11302 { 11303 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 11304 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 11305 PORT_Assert( ss->ssl3.hs.restartTarget == NULL ); 11306 11307 /* The first handshake is now completed. */ 11308 ss->handshake = NULL; 11309 11310 /* RFC 5077 Section 3.3: "The client MUST NOT treat the ticket as valid 11311 * until it has verified the server's Finished message." When the server 11312 * sends a NewSessionTicket in a resumption handshake, we must wait until 11313 * the handshake is finished (we have verified the server's Finished 11314 * AND the server's certificate) before we update the ticket in the sid. 11315 * 11316 * This must be done before we call (*ss->sec.cache)(ss->sec.ci.sid) 11317 * because CacheSID requires the session ticket to already be set, and also 11318 * because of the lazy lock creation scheme used by CacheSID and 11319 * ssl3_SetSIDSessionTicket. 11320 */ 11321 if (ss->ssl3.hs.receivedNewSessionTicket) { 11322 PORT_Assert(!ss->sec.isServer); 11323 ssl3_SetSIDSessionTicket(ss->sec.ci.sid, &ss->ssl3.hs.newSessionTicket); 11324 /* The sid took over the ticket data */ 11325 PORT_Assert(!ss->ssl3.hs.newSessionTicket.ticket.data); 11326 ss->ssl3.hs.receivedNewSessionTicket = PR_FALSE; 11327 } 11328 11329 if (ss->ssl3.hs.cacheSID && ss->sec.isServer) { 11330 PORT_Assert(ss->sec.ci.sid->cached == never_cached); 11331 (*ss->sec.cache)(ss->sec.ci.sid); 11332 ss->ssl3.hs.cacheSID = PR_FALSE; 11333 } 11334 11335 ss->ssl3.hs.canFalseStart = PR_FALSE; /* False Start phase is complete */ 11336 ss->ssl3.hs.ws = idle_handshake; 11337 11338 ssl_FinishHandshake(ss); 11339 11340 return SECSuccess; 11341 } 11342 11343 /* Called from ssl3_HandleHandshake() when it has gathered a complete ssl3 11344 * hanshake message. 11345 * Caller must hold Handshake and RecvBuf locks. 11346 */ 11347 SECStatus 11348 ssl3_HandleHandshakeMessage(sslSocket *ss, SSL3Opaque *b, PRUint32 length) 11349 { 11350 SECStatus rv = SECSuccess; 11351 SSL3HandshakeType type = ss->ssl3.hs.msg_type; 11352 SSL3Hashes hashes; /* computed hashes are put here. */ 11353 PRUint8 hdr[4]; 11354 PRUint8 dtlsData[8]; 11355 11356 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 11357 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 11358 /* 11359 * We have to compute the hashes before we update them with the 11360 * current message. 11361 */ 11362 ssl_GetSpecReadLock(ss); /************************************/ 11363 if((type == finished) || (type == certificate_verify)) { 11364 SSL3Sender sender = (SSL3Sender)0; 11365 ssl3CipherSpec *rSpec = ss->ssl3.prSpec; 11366 11367 if (type == finished) { 11368 sender = ss->sec.isServer ? sender_client : sender_server; 11369 rSpec = ss->ssl3.crSpec; 11370 } 11371 rv = ssl3_ComputeHandshakeHashes(ss, rSpec, &hashes, sender); 11372 } 11373 ssl_ReleaseSpecReadLock(ss); /************************************/ 11374 if (rv != SECSuccess) { 11375 return rv; /* error code was set by ssl3_ComputeHandshakeHashes*/ 11376 } 11377 SSL_TRC(30,("%d: SSL3[%d]: handle handshake message: %s", SSL_GETPID(), 11378 ss->fd, ssl3_DecodeHandshakeType(ss->ssl3.hs.msg_type))); 11379 11380 hdr[0] = (PRUint8)ss->ssl3.hs.msg_type; 11381 hdr[1] = (PRUint8)(length >> 16); 11382 hdr[2] = (PRUint8)(length >> 8); 11383 hdr[3] = (PRUint8)(length ); 11384 11385 /* Start new handshake hashes when we start a new handshake */ 11386 if (ss->ssl3.hs.msg_type == client_hello) { 11387 rv = ssl3_RestartHandshakeHashes(ss); 11388 if (rv != SECSuccess) { 11389 return rv; 11390 } 11391 } 11392 /* We should not include hello_request and hello_verify_request messages 11393 * in the handshake hashes */ 11394 if ((ss->ssl3.hs.msg_type != hello_request) && 11395 (ss->ssl3.hs.msg_type != hello_verify_request)) { 11396 rv = ssl3_UpdateHandshakeHashes(ss, (unsigned char*) hdr, 4); 11397 if (rv != SECSuccess) return rv; /* err code already set. */ 11398 11399 /* Extra data to simulate a complete DTLS handshake fragment */ 11400 if (IS_DTLS(ss)) { 11401 /* Sequence number */ 11402 dtlsData[0] = MSB(ss->ssl3.hs.recvMessageSeq); 11403 dtlsData[1] = LSB(ss->ssl3.hs.recvMessageSeq); 11404 11405 /* Fragment offset */ 11406 dtlsData[2] = 0; 11407 dtlsData[3] = 0; 11408 dtlsData[4] = 0; 11409 11410 /* Fragment length */ 11411 dtlsData[5] = (PRUint8)(length >> 16); 11412 dtlsData[6] = (PRUint8)(length >> 8); 11413 dtlsData[7] = (PRUint8)(length ); 11414 11415 rv = ssl3_UpdateHandshakeHashes(ss, (unsigned char*) dtlsData, 11416 sizeof(dtlsData)); 11417 if (rv != SECSuccess) return rv; /* err code already set. */ 11418 } 11419 11420 /* The message body */ 11421 rv = ssl3_UpdateHandshakeHashes(ss, b, length); 11422 if (rv != SECSuccess) return rv; /* err code already set. */ 11423 } 11424 11425 PORT_SetError(0); /* each message starts with no error. */ 11426 11427 if (ss->ssl3.hs.ws == wait_certificate_status && 11428 ss->ssl3.hs.msg_type != certificate_status) { 11429 /* If we negotiated the certificate_status extension then we deferred 11430 * certificate validation until we get the CertificateStatus messsage. 11431 * But the CertificateStatus message is optional. If the server did 11432 * not send it then we need to validate the certificate now. If the 11433 * server does send the CertificateStatus message then we will 11434 * authenticate the certificate in ssl3_HandleCertificateStatus. 11435 */ 11436 rv = ssl3_AuthCertificate(ss); /* sets ss->ssl3.hs.ws */ 11437 PORT_Assert(rv != SECWouldBlock); 11438 if (rv != SECSuccess) { 11439 return rv; 11440 } 11441 } 11442 11443 switch (ss->ssl3.hs.msg_type) { 11444 case hello_request: 11445 if (length != 0) { 11446 (void)ssl3_DecodeError(ss); 11447 PORT_SetError(SSL_ERROR_RX_MALFORMED_HELLO_REQUEST); 11448 return SECFailure; 11449 } 11450 if (ss->sec.isServer) { 11451 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11452 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HELLO_REQUEST); 11453 return SECFailure; 11454 } 11455 rv = ssl3_HandleHelloRequest(ss); 11456 break; 11457 case client_hello: 11458 if (!ss->sec.isServer) { 11459 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11460 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_CLIENT_HELLO); 11461 return SECFailure; 11462 } 11463 rv = ssl3_HandleClientHello(ss, b, length); 11464 break; 11465 case server_hello: 11466 if (ss->sec.isServer) { 11467 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11468 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_SERVER_HELLO); 11469 return SECFailure; 11470 } 11471 rv = ssl3_HandleServerHello(ss, b, length); 11472 break; 11473 case hello_verify_request: 11474 if (!IS_DTLS(ss) || ss->sec.isServer) { 11475 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11476 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HELLO_VERIFY_REQUEST); 11477 return SECFailure; 11478 } 11479 rv = dtls_HandleHelloVerifyRequest(ss, b, length); 11480 break; 11481 case certificate: 11482 rv = ssl3_HandleCertificate(ss, b, length); 11483 break; 11484 case certificate_status: 11485 rv = ssl3_HandleCertificateStatus(ss, b, length); 11486 break; 11487 case server_key_exchange: 11488 if (ss->sec.isServer) { 11489 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11490 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_SERVER_KEY_EXCH); 11491 return SECFailure; 11492 } 11493 rv = ssl3_HandleServerKeyExchange(ss, b, length); 11494 break; 11495 case certificate_request: 11496 if (ss->sec.isServer) { 11497 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11498 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_CERT_REQUEST); 11499 return SECFailure; 11500 } 11501 rv = ssl3_HandleCertificateRequest(ss, b, length); 11502 break; 11503 case server_hello_done: 11504 if (length != 0) { 11505 (void)ssl3_DecodeError(ss); 11506 PORT_SetError(SSL_ERROR_RX_MALFORMED_HELLO_DONE); 11507 return SECFailure; 11508 } 11509 if (ss->sec.isServer) { 11510 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11511 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_HELLO_DONE); 11512 return SECFailure; 11513 } 11514 rv = ssl3_HandleServerHelloDone(ss); 11515 break; 11516 case certificate_verify: 11517 if (!ss->sec.isServer) { 11518 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11519 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_CERT_VERIFY); 11520 return SECFailure; 11521 } 11522 rv = ssl3_HandleCertificateVerify(ss, b, length, &hashes); 11523 break; 11524 case client_key_exchange: 11525 if (!ss->sec.isServer) { 11526 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11527 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_CLIENT_KEY_EXCH); 11528 return SECFailure; 11529 } 11530 rv = ssl3_HandleClientKeyExchange(ss, b, length); 11531 break; 11532 case new_session_ticket: 11533 if (ss->sec.isServer) { 11534 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11535 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_NEW_SESSION_TICKET); 11536 return SECFailure; 11537 } 11538 rv = ssl3_HandleNewSessionTicket(ss, b, length); 11539 break; 11540 case finished: 11541 rv = ssl3_HandleFinished(ss, b, length, &hashes); 11542 break; 11543 default: 11544 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 11545 PORT_SetError(SSL_ERROR_RX_UNKNOWN_HANDSHAKE); 11546 rv = SECFailure; 11547 } 11548 11549 if (IS_DTLS(ss) && (rv != SECFailure)) { 11550 /* Increment the expected sequence number */ 11551 ss->ssl3.hs.recvMessageSeq++; 11552 } 11553 11554 return rv; 11555 } 11556 11557 /* Called only from ssl3_HandleRecord, for each (deciphered) ssl3 record. 11558 * origBuf is the decrypted ssl record content. 11559 * Caller must hold the handshake and RecvBuf locks. 11560 */ 11561 static SECStatus 11562 ssl3_HandleHandshake(sslSocket *ss, sslBuffer *origBuf) 11563 { 11564 /* 11565 * There may be a partial handshake message already in the handshake 11566 * state. The incoming buffer may contain another portion, or a 11567 * complete message or several messages followed by another portion. 11568 * 11569 * Each message is made contiguous before being passed to the actual 11570 * message parser. 11571 */ 11572 sslBuffer *buf = &ss->ssl3.hs.msgState; /* do not lose the original buffer pointer */ 11573 SECStatus rv; 11574 11575 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 11576 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 11577 11578 if (buf->buf == NULL) { 11579 *buf = *origBuf; 11580 } 11581 while (buf->len > 0) { 11582 if (ss->ssl3.hs.header_bytes < 4) { 11583 PRUint8 t; 11584 t = *(buf->buf++); 11585 buf->len--; 11586 if (ss->ssl3.hs.header_bytes++ == 0) 11587 ss->ssl3.hs.msg_type = (SSL3HandshakeType)t; 11588 else 11589 ss->ssl3.hs.msg_len = (ss->ssl3.hs.msg_len << 8) + t; 11590 if (ss->ssl3.hs.header_bytes < 4) 11591 continue; 11592 11593 #define MAX_HANDSHAKE_MSG_LEN 0x1ffff /* 128k - 1 */ 11594 if (ss->ssl3.hs.msg_len > MAX_HANDSHAKE_MSG_LEN) { 11595 (void)ssl3_DecodeError(ss); 11596 PORT_SetError(SSL_ERROR_RX_RECORD_TOO_LONG); 11597 return SECFailure; 11598 } 11599 #undef MAX_HANDSHAKE_MSG_LEN 11600 11601 /* If msg_len is zero, be sure we fall through, 11602 ** even if buf->len is zero. 11603 */ 11604 if (ss->ssl3.hs.msg_len > 0) 11605 continue; 11606 } 11607 11608 /* 11609 * Header has been gathered and there is at least one byte of new 11610 * data available for this message. If it can be done right out 11611 * of the original buffer, then use it from there. 11612 */ 11613 if (ss->ssl3.hs.msg_body.len == 0 && buf->len >= ss->ssl3.hs.msg_len) { 11614 /* handle it from input buffer */ 11615 rv = ssl3_HandleHandshakeMessage(ss, buf->buf, ss->ssl3.hs.msg_len); 11616 if (rv == SECFailure) { 11617 /* This test wants to fall through on either 11618 * SECSuccess or SECWouldBlock. 11619 * ssl3_HandleHandshakeMessage MUST set the error code. 11620 */ 11621 return rv; 11622 } 11623 buf->buf += ss->ssl3.hs.msg_len; 11624 buf->len -= ss->ssl3.hs.msg_len; 11625 ss->ssl3.hs.msg_len = 0; 11626 ss->ssl3.hs.header_bytes = 0; 11627 if (rv != SECSuccess) { /* return if SECWouldBlock. */ 11628 return rv; 11629 } 11630 } else { 11631 /* must be copied to msg_body and dealt with from there */ 11632 unsigned int bytes; 11633 11634 PORT_Assert(ss->ssl3.hs.msg_body.len < ss->ssl3.hs.msg_len); 11635 bytes = PR_MIN(buf->len, ss->ssl3.hs.msg_len - ss->ssl3.hs.msg_body.len); 11636 11637 /* Grow the buffer if needed */ 11638 rv = sslBuffer_Grow(&ss->ssl3.hs.msg_body, ss->ssl3.hs.msg_len); 11639 if (rv != SECSuccess) { 11640 /* sslBuffer_Grow has set a memory error code. */ 11641 return SECFailure; 11642 } 11643 11644 PORT_Memcpy(ss->ssl3.hs.msg_body.buf + ss->ssl3.hs.msg_body.len, 11645 buf->buf, bytes); 11646 ss->ssl3.hs.msg_body.len += bytes; 11647 buf->buf += bytes; 11648 buf->len -= bytes; 11649 11650 PORT_Assert(ss->ssl3.hs.msg_body.len <= ss->ssl3.hs.msg_len); 11651 11652 /* if we have a whole message, do it */ 11653 if (ss->ssl3.hs.msg_body.len == ss->ssl3.hs.msg_len) { 11654 rv = ssl3_HandleHandshakeMessage( 11655 ss, ss->ssl3.hs.msg_body.buf, ss->ssl3.hs.msg_len); 11656 if (rv == SECFailure) { 11657 /* This test wants to fall through on either 11658 * SECSuccess or SECWouldBlock. 11659 * ssl3_HandleHandshakeMessage MUST set error code. 11660 */ 11661 return rv; 11662 } 11663 ss->ssl3.hs.msg_body.len = 0; 11664 ss->ssl3.hs.msg_len = 0; 11665 ss->ssl3.hs.header_bytes = 0; 11666 if (rv != SECSuccess) { /* return if SECWouldBlock. */ 11667 return rv; 11668 } 11669 } else { 11670 PORT_Assert(buf->len == 0); 11671 break; 11672 } 11673 } 11674 } /* end loop */ 11675 11676 origBuf->len = 0; /* So ssl3_GatherAppDataRecord will keep looping. */ 11677 buf->buf = NULL; /* not a leak. */ 11678 return SECSuccess; 11679 } 11680 11681 /* These macros return the given value with the MSB copied to all the other 11682 * bits. They use the fact that arithmetic shift shifts-in the sign bit. 11683 * However, this is not ensured by the C standard so you may need to replace 11684 * them with something else for odd compilers. */ 11685 #define DUPLICATE_MSB_TO_ALL(x) ( (unsigned)( (int)(x) >> (sizeof(int)*8-1) ) ) 11686 #define DUPLICATE_MSB_TO_ALL_8(x) ((unsigned char)(DUPLICATE_MSB_TO_ALL(x))) 11687 11688 /* SECStatusToMask returns, in constant time, a mask value of all ones if 11689 * rv == SECSuccess. Otherwise it returns zero. */ 11690 static unsigned int 11691 SECStatusToMask(SECStatus rv) 11692 { 11693 unsigned int good; 11694 /* rv ^ SECSuccess is zero iff rv == SECSuccess. Subtracting one results 11695 * in the MSB being set to one iff it was zero before. */ 11696 good = rv ^ SECSuccess; 11697 good--; 11698 return DUPLICATE_MSB_TO_ALL(good); 11699 } 11700 11701 /* ssl_ConstantTimeGE returns 0xff if a>=b and 0x00 otherwise. */ 11702 static unsigned char 11703 ssl_ConstantTimeGE(unsigned int a, unsigned int b) 11704 { 11705 a -= b; 11706 return DUPLICATE_MSB_TO_ALL(~a); 11707 } 11708 11709 /* ssl_ConstantTimeEQ8 returns 0xff if a==b and 0x00 otherwise. */ 11710 static unsigned char 11711 ssl_ConstantTimeEQ8(unsigned char a, unsigned char b) 11712 { 11713 unsigned int c = a ^ b; 11714 c--; 11715 return DUPLICATE_MSB_TO_ALL_8(c); 11716 } 11717 11718 static SECStatus 11719 ssl_RemoveSSLv3CBCPadding(sslBuffer *plaintext, 11720 unsigned int blockSize, 11721 unsigned int macSize) 11722 { 11723 unsigned int paddingLength, good, t; 11724 const unsigned int overhead = 1 /* padding length byte */ + macSize; 11725 11726 /* These lengths are all public so we can test them in non-constant 11727 * time. */ 11728 if (overhead > plaintext->len) { 11729 return SECFailure; 11730 } 11731 11732 paddingLength = plaintext->buf[plaintext->len-1]; 11733 /* SSLv3 padding bytes are random and cannot be checked. */ 11734 t = plaintext->len; 11735 t -= paddingLength+overhead; 11736 /* If len >= paddingLength+overhead then the MSB of t is zero. */ 11737 good = DUPLICATE_MSB_TO_ALL(~t); 11738 /* SSLv3 requires that the padding is minimal. */ 11739 t = blockSize - (paddingLength+1); 11740 good &= DUPLICATE_MSB_TO_ALL(~t); 11741 plaintext->len -= good & (paddingLength+1); 11742 return (good & SECSuccess) | (~good & SECFailure); 11743 } 11744 11745 static SECStatus 11746 ssl_RemoveTLSCBCPadding(sslBuffer *plaintext, unsigned int macSize) 11747 { 11748 unsigned int paddingLength, good, t, toCheck, i; 11749 const unsigned int overhead = 1 /* padding length byte */ + macSize; 11750 11751 /* These lengths are all public so we can test them in non-constant 11752 * time. */ 11753 if (overhead > plaintext->len) { 11754 return SECFailure; 11755 } 11756 11757 paddingLength = plaintext->buf[plaintext->len-1]; 11758 t = plaintext->len; 11759 t -= paddingLength+overhead; 11760 /* If len >= paddingLength+overhead then the MSB of t is zero. */ 11761 good = DUPLICATE_MSB_TO_ALL(~t); 11762 11763 /* The padding consists of a length byte at the end of the record and then 11764 * that many bytes of padding, all with the same value as the length byte. 11765 * Thus, with the length byte included, there are paddingLength+1 bytes of 11766 * padding. 11767 * 11768 * We can't check just |paddingLength+1| bytes because that leaks 11769 * decrypted information. Therefore we always have to check the maximum 11770 * amount of padding possible. (Again, the length of the record is 11771 * public information so we can use it.) */ 11772 toCheck = 255; /* maximum amount of padding. */ 11773 if (toCheck > plaintext->len-1) { 11774 toCheck = plaintext->len-1; 11775 } 11776 11777 for (i = 0; i < toCheck; i++) { 11778 unsigned int t = paddingLength - i; 11779 /* If i <= paddingLength then the MSB of t is zero and mask is 11780 * 0xff. Otherwise, mask is 0. */ 11781 unsigned char mask = DUPLICATE_MSB_TO_ALL(~t); 11782 unsigned char b = plaintext->buf[plaintext->len-1-i]; 11783 /* The final |paddingLength+1| bytes should all have the value 11784 * |paddingLength|. Therefore the XOR should be zero. */ 11785 good &= ~(mask&(paddingLength ^ b)); 11786 } 11787 11788 /* If any of the final |paddingLength+1| bytes had the wrong value, 11789 * one or more of the lower eight bits of |good| will be cleared. We 11790 * AND the bottom 8 bits together and duplicate the result to all the 11791 * bits. */ 11792 good &= good >> 4; 11793 good &= good >> 2; 11794 good &= good >> 1; 11795 good <<= sizeof(good)*8-1; 11796 good = DUPLICATE_MSB_TO_ALL(good); 11797 11798 plaintext->len -= good & (paddingLength+1); 11799 return (good & SECSuccess) | (~good & SECFailure); 11800 } 11801 11802 /* On entry: 11803 * originalLength >= macSize 11804 * macSize <= MAX_MAC_LENGTH 11805 * plaintext->len >= macSize 11806 */ 11807 static void 11808 ssl_CBCExtractMAC(sslBuffer *plaintext, 11809 unsigned int originalLength, 11810 SSL3Opaque* out, 11811 unsigned int macSize) 11812 { 11813 unsigned char rotatedMac[MAX_MAC_LENGTH]; 11814 /* macEnd is the index of |plaintext->buf| just after the end of the 11815 * MAC. */ 11816 unsigned macEnd = plaintext->len; 11817 unsigned macStart = macEnd - macSize; 11818 /* scanStart contains the number of bytes that we can ignore because 11819 * the MAC's position can only vary by 255 bytes. */ 11820 unsigned scanStart = 0; 11821 unsigned i, j, divSpoiler; 11822 unsigned char rotateOffset; 11823 11824 if (originalLength > macSize + 255 + 1) 11825 scanStart = originalLength - (macSize + 255 + 1); 11826 11827 /* divSpoiler contains a multiple of macSize that is used to cause the 11828 * modulo operation to be constant time. Without this, the time varies 11829 * based on the amount of padding when running on Intel chips at least. 11830 * 11831 * The aim of right-shifting macSize is so that the compiler doesn't 11832 * figure out that it can remove divSpoiler as that would require it 11833 * to prove that macSize is always even, which I hope is beyond it. */ 11834 divSpoiler = macSize >> 1; 11835 divSpoiler <<= (sizeof(divSpoiler)-1)*8; 11836 rotateOffset = (divSpoiler + macStart - scanStart) % macSize; 11837 11838 memset(rotatedMac, 0, macSize); 11839 for (i = scanStart; i < originalLength;) { 11840 for (j = 0; j < macSize && i < originalLength; i++, j++) { 11841 unsigned char macStarted = ssl_ConstantTimeGE(i, macStart); 11842 unsigned char macEnded = ssl_ConstantTimeGE(i, macEnd); 11843 unsigned char b = 0; 11844 b = plaintext->buf[i]; 11845 rotatedMac[j] |= b & macStarted & ~macEnded; 11846 } 11847 } 11848 11849 /* Now rotate the MAC. If we knew that the MAC fit into a CPU cache line 11850 * we could line-align |rotatedMac| and rotate in place. */ 11851 memset(out, 0, macSize); 11852 for (i = 0; i < macSize; i++) { 11853 unsigned char offset = 11854 (divSpoiler + macSize - rotateOffset + i) % macSize; 11855 for (j = 0; j < macSize; j++) { 11856 out[j] |= rotatedMac[i] & ssl_ConstantTimeEQ8(j, offset); 11857 } 11858 } 11859 } 11860 11861 /* if cText is non-null, then decipher, check MAC, and decompress the 11862 * SSL record from cText->buf (typically gs->inbuf) 11863 * into databuf (typically gs->buf), and any previous contents of databuf 11864 * is lost. Then handle databuf according to its SSL record type, 11865 * unless it's an application record. 11866 * 11867 * If cText is NULL, then the ciphertext has previously been deciphered and 11868 * checked, and is already sitting in databuf. It is processed as an SSL 11869 * Handshake message. 11870 * 11871 * DOES NOT process the decrypted/decompressed application data. 11872 * On return, databuf contains the decrypted/decompressed record. 11873 * 11874 * Called from ssl3_GatherCompleteHandshake 11875 * ssl3_RestartHandshakeAfterCertReq 11876 * 11877 * Caller must hold the RecvBufLock. 11878 * 11879 * This function aquires and releases the SSL3Handshake Lock, holding the 11880 * lock around any calls to functions that handle records other than 11881 * Application Data records. 11882 */ 11883 SECStatus 11884 ssl3_HandleRecord(sslSocket *ss, SSL3Ciphertext *cText, sslBuffer *databuf) 11885 { 11886 const ssl3BulkCipherDef *cipher_def; 11887 ssl3CipherSpec * crSpec; 11888 SECStatus rv; 11889 unsigned int hashBytes = MAX_MAC_LENGTH + 1; 11890 PRBool isTLS; 11891 SSL3ContentType rType; 11892 SSL3Opaque hash[MAX_MAC_LENGTH]; 11893 SSL3Opaque givenHashBuf[MAX_MAC_LENGTH]; 11894 SSL3Opaque *givenHash; 11895 sslBuffer *plaintext; 11896 sslBuffer temp_buf; 11897 PRUint64 dtls_seq_num; 11898 unsigned int ivLen = 0; 11899 unsigned int originalLen = 0; 11900 unsigned int good; 11901 unsigned int minLength; 11902 unsigned char header[13]; 11903 unsigned int headerLen; 11904 11905 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 11906 11907 if (!ss->ssl3.initialized) { 11908 ssl_GetSSL3HandshakeLock(ss); 11909 rv = ssl3_InitState(ss); 11910 ssl_ReleaseSSL3HandshakeLock(ss); 11911 if (rv != SECSuccess) { 11912 return rv; /* ssl3_InitState has set the error code. */ 11913 } 11914 } 11915 11916 /* check for Token Presence */ 11917 if (!ssl3_ClientAuthTokenPresent(ss->sec.ci.sid)) { 11918 PORT_SetError(SSL_ERROR_TOKEN_INSERTION_REMOVAL); 11919 return SECFailure; 11920 } 11921 11922 /* cText is NULL when we're called from ssl3_RestartHandshakeAfterXXX(). 11923 * This implies that databuf holds a previously deciphered SSL Handshake 11924 * message. 11925 */ 11926 if (cText == NULL) { 11927 SSL_DBG(("%d: SSL3[%d]: HandleRecord, resuming handshake", 11928 SSL_GETPID(), ss->fd)); 11929 rType = content_handshake; 11930 goto process_it; 11931 } 11932 11933 ssl_GetSpecReadLock(ss); /******************************************/ 11934 11935 crSpec = ss->ssl3.crSpec; 11936 cipher_def = crSpec->cipher_def; 11937 11938 /* 11939 * DTLS relevance checks: 11940 * Note that this code currently ignores all out-of-epoch packets, 11941 * which means we lose some in the case of rehandshake + 11942 * loss/reordering. Since DTLS is explicitly unreliable, this 11943 * seems like a good tradeoff for implementation effort and is 11944 * consistent with the guidance of RFC 6347 Sections 4.1 and 4.2.4.1 11945 */ 11946 if (IS_DTLS(ss)) { 11947 DTLSEpoch epoch = (cText->seq_num.high >> 16) & 0xffff; 11948 11949 if (crSpec->epoch != epoch) { 11950 ssl_ReleaseSpecReadLock(ss); 11951 SSL_DBG(("%d: SSL3[%d]: HandleRecord, received packet " 11952 "from irrelevant epoch %d", SSL_GETPID(), ss->fd, epoch)); 11953 /* Silently drop the packet */ 11954 databuf->len = 0; /* Needed to ensure data not left around */ 11955 return SECSuccess; 11956 } 11957 11958 dtls_seq_num = (((PRUint64)(cText->seq_num.high & 0xffff)) << 32) | 11959 ((PRUint64)cText->seq_num.low); 11960 11961 if (dtls_RecordGetRecvd(&crSpec->recvdRecords, dtls_seq_num) != 0) { 11962 ssl_ReleaseSpecReadLock(ss); 11963 SSL_DBG(("%d: SSL3[%d]: HandleRecord, rejecting " 11964 "potentially replayed packet", SSL_GETPID(), ss->fd)); 11965 /* Silently drop the packet */ 11966 databuf->len = 0; /* Needed to ensure data not left around */ 11967 return SECSuccess; 11968 } 11969 } 11970 11971 good = ~0U; 11972 minLength = crSpec->mac_size; 11973 if (cipher_def->type == type_block) { 11974 /* CBC records have a padding length byte at the end. */ 11975 minLength++; 11976 if (crSpec->version >= SSL_LIBRARY_VERSION_TLS_1_1) { 11977 /* With >= TLS 1.1, CBC records have an explicit IV. */ 11978 minLength += cipher_def->iv_size; 11979 } 11980 } else if (cipher_def->type == type_aead) { 11981 minLength = cipher_def->explicit_nonce_size + cipher_def->tag_size; 11982 } 11983 11984 /* We can perform this test in variable time because the record's total 11985 * length and the ciphersuite are both public knowledge. */ 11986 if (cText->buf->len < minLength) { 11987 goto decrypt_loser; 11988 } 11989 11990 if (cipher_def->type == type_block && 11991 crSpec->version >= SSL_LIBRARY_VERSION_TLS_1_1) { 11992 /* Consume the per-record explicit IV. RFC 4346 Section 6.2.3.2 states 11993 * "The receiver decrypts the entire GenericBlockCipher structure and 11994 * then discards the first cipher block corresponding to the IV 11995 * component." Instead, we decrypt the first cipher block and then 11996 * discard it before decrypting the rest. 11997 */ 11998 SSL3Opaque iv[MAX_IV_LENGTH]; 11999 int decoded; 12000 12001 ivLen = cipher_def->iv_size; 12002 if (ivLen < 8 || ivLen > sizeof(iv)) { 12003 ssl_ReleaseSpecReadLock(ss); 12004 PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); 12005 return SECFailure; 12006 } 12007 12008 PRINT_BUF(80, (ss, "IV (ciphertext):", cText->buf->buf, ivLen)); 12009 12010 /* The decryption result is garbage, but since we just throw away 12011 * the block it doesn't matter. The decryption of the next block 12012 * depends only on the ciphertext of the IV block. 12013 */ 12014 rv = crSpec->decode(crSpec->decodeContext, iv, &decoded, 12015 sizeof(iv), cText->buf->buf, ivLen); 12016 12017 good &= SECStatusToMask(rv); 12018 } 12019 12020 /* If we will be decompressing the buffer we need to decrypt somewhere 12021 * other than into databuf */ 12022 if (crSpec->decompressor) { 12023 temp_buf.buf = NULL; 12024 temp_buf.space = 0; 12025 plaintext = &temp_buf; 12026 } else { 12027 plaintext = databuf; 12028 } 12029 12030 plaintext->len = 0; /* filled in by decode call below. */ 12031 if (plaintext->space < MAX_FRAGMENT_LENGTH) { 12032 rv = sslBuffer_Grow(plaintext, MAX_FRAGMENT_LENGTH + 2048); 12033 if (rv != SECSuccess) { 12034 ssl_ReleaseSpecReadLock(ss); 12035 SSL_DBG(("%d: SSL3[%d]: HandleRecord, tried to get %d bytes", 12036 SSL_GETPID(), ss->fd, MAX_FRAGMENT_LENGTH + 2048)); 12037 /* sslBuffer_Grow has set a memory error code. */ 12038 /* Perhaps we should send an alert. (but we have no memory!) */ 12039 return SECFailure; 12040 } 12041 } 12042 12043 PRINT_BUF(80, (ss, "ciphertext:", cText->buf->buf + ivLen, 12044 cText->buf->len - ivLen)); 12045 12046 isTLS = (PRBool)(crSpec->version > SSL_LIBRARY_VERSION_3_0); 12047 12048 if (isTLS && cText->buf->len - ivLen > (MAX_FRAGMENT_LENGTH + 2048)) { 12049 ssl_ReleaseSpecReadLock(ss); 12050 SSL3_SendAlert(ss, alert_fatal, record_overflow); 12051 PORT_SetError(SSL_ERROR_RX_RECORD_TOO_LONG); 12052 return SECFailure; 12053 } 12054 12055 rType = cText->type; 12056 if (cipher_def->type == type_aead) { 12057 /* XXX For many AEAD ciphers, the plaintext is shorter than the 12058 * ciphertext by a fixed byte count, but it is not true in general. 12059 * Each AEAD cipher should provide a function that returns the 12060 * plaintext length for a given ciphertext. */ 12061 unsigned int decryptedLen = 12062 cText->buf->len - cipher_def->explicit_nonce_size - 12063 cipher_def->tag_size; 12064 headerLen = ssl3_BuildRecordPseudoHeader( 12065 header, IS_DTLS(ss) ? cText->seq_num : crSpec->read_seq_num, 12066 rType, isTLS, cText->version, IS_DTLS(ss), decryptedLen); 12067 PORT_Assert(headerLen <= sizeof(header)); 12068 rv = crSpec->aead( 12069 ss->sec.isServer ? &crSpec->client : &crSpec->server, 12070 PR_TRUE, /* do decrypt */ 12071 plaintext->buf, /* out */ 12072 (int*) &plaintext->len, /* outlen */ 12073 plaintext->space, /* maxout */ 12074 cText->buf->buf, /* in */ 12075 cText->buf->len, /* inlen */ 12076 header, headerLen); 12077 if (rv != SECSuccess) { 12078 good = 0; 12079 } 12080 } else { 12081 if (cipher_def->type == type_block && 12082 ((cText->buf->len - ivLen) % cipher_def->block_size) != 0) { 12083 goto decrypt_loser; 12084 } 12085 12086 /* decrypt from cText buf to plaintext. */ 12087 rv = crSpec->decode( 12088 crSpec->decodeContext, plaintext->buf, (int *)&plaintext->len, 12089 plaintext->space, cText->buf->buf + ivLen, cText->buf->len - ivLen); 12090 if (rv != SECSuccess) { 12091 goto decrypt_loser; 12092 } 12093 12094 PRINT_BUF(80, (ss, "cleartext:", plaintext->buf, plaintext->len)); 12095 12096 originalLen = plaintext->len; 12097 12098 /* If it's a block cipher, check and strip the padding. */ 12099 if (cipher_def->type == type_block) { 12100 const unsigned int blockSize = cipher_def->block_size; 12101 const unsigned int macSize = crSpec->mac_size; 12102 12103 if (!isTLS) { 12104 good &= SECStatusToMask(ssl_RemoveSSLv3CBCPadding( 12105 plaintext, blockSize, macSize)); 12106 } else { 12107 good &= SECStatusToMask(ssl_RemoveTLSCBCPadding( 12108 plaintext, macSize)); 12109 } 12110 } 12111 12112 /* compute the MAC */ 12113 headerLen = ssl3_BuildRecordPseudoHeader( 12114 header, IS_DTLS(ss) ? cText->seq_num : crSpec->read_seq_num, 12115 rType, isTLS, cText->version, IS_DTLS(ss), 12116 plaintext->len - crSpec->mac_size); 12117 PORT_Assert(headerLen <= sizeof(header)); 12118 if (cipher_def->type == type_block) { 12119 rv = ssl3_ComputeRecordMACConstantTime( 12120 crSpec, (PRBool)(!ss->sec.isServer), header, headerLen, 12121 plaintext->buf, plaintext->len, originalLen, 12122 hash, &hashBytes); 12123 12124 ssl_CBCExtractMAC(plaintext, originalLen, givenHashBuf, 12125 crSpec->mac_size); 12126 givenHash = givenHashBuf; 12127 12128 /* plaintext->len will always have enough space to remove the MAC 12129 * because in ssl_Remove{SSLv3|TLS}CBCPadding we only adjust 12130 * plaintext->len if the result has enough space for the MAC and we 12131 * tested the unadjusted size against minLength, above. */ 12132 plaintext->len -= crSpec->mac_size; 12133 } else { 12134 /* This is safe because we checked the minLength above. */ 12135 plaintext->len -= crSpec->mac_size; 12136 12137 rv = ssl3_ComputeRecordMAC( 12138 crSpec, (PRBool)(!ss->sec.isServer), header, headerLen, 12139 plaintext->buf, plaintext->len, hash, &hashBytes); 12140 12141 /* We can read the MAC directly from the record because its location 12142 * is public when a stream cipher is used. */ 12143 givenHash = plaintext->buf + plaintext->len; 12144 } 12145 12146 good &= SECStatusToMask(rv); 12147 12148 if (hashBytes != (unsigned)crSpec->mac_size || 12149 NSS_SecureMemcmp(givenHash, hash, crSpec->mac_size) != 0) { 12150 /* We're allowed to leak whether or not the MAC check was correct */ 12151 good = 0; 12152 } 12153 } 12154 12155 if (good == 0) { 12156 decrypt_loser: 12157 /* must not hold spec lock when calling SSL3_SendAlert. */ 12158 ssl_ReleaseSpecReadLock(ss); 12159 12160 SSL_DBG(("%d: SSL3[%d]: decryption failed", SSL_GETPID(), ss->fd)); 12161 12162 if (!IS_DTLS(ss)) { 12163 SSL3_SendAlert(ss, alert_fatal, bad_record_mac); 12164 /* always log mac error, in case attacker can read server logs. */ 12165 PORT_SetError(SSL_ERROR_BAD_MAC_READ); 12166 return SECFailure; 12167 } else { 12168 /* Silently drop the packet */ 12169 databuf->len = 0; /* Needed to ensure data not left around */ 12170 return SECSuccess; 12171 } 12172 } 12173 12174 if (!IS_DTLS(ss)) { 12175 ssl3_BumpSequenceNumber(&crSpec->read_seq_num); 12176 } else { 12177 dtls_RecordSetRecvd(&crSpec->recvdRecords, dtls_seq_num); 12178 } 12179 12180 ssl_ReleaseSpecReadLock(ss); /*****************************************/ 12181 12182 /* 12183 * The decrypted data is now in plaintext. 12184 */ 12185 12186 /* possibly decompress the record. If we aren't using compression then 12187 * plaintext == databuf and so the uncompressed data is already in 12188 * databuf. */ 12189 if (crSpec->decompressor) { 12190 if (databuf->space < plaintext->len + SSL3_COMPRESSION_MAX_EXPANSION) { 12191 rv = sslBuffer_Grow( 12192 databuf, plaintext->len + SSL3_COMPRESSION_MAX_EXPANSION); 12193 if (rv != SECSuccess) { 12194 SSL_DBG(("%d: SSL3[%d]: HandleRecord, tried to get %d bytes", 12195 SSL_GETPID(), ss->fd, 12196 plaintext->len + SSL3_COMPRESSION_MAX_EXPANSION)); 12197 /* sslBuffer_Grow has set a memory error code. */ 12198 /* Perhaps we should send an alert. (but we have no memory!) */ 12199 PORT_Free(plaintext->buf); 12200 return SECFailure; 12201 } 12202 } 12203 12204 rv = crSpec->decompressor(crSpec->decompressContext, 12205 databuf->buf, 12206 (int*) &databuf->len, 12207 databuf->space, 12208 plaintext->buf, 12209 plaintext->len); 12210 12211 if (rv != SECSuccess) { 12212 int err = ssl_MapLowLevelError(SSL_ERROR_DECOMPRESSION_FAILURE); 12213 SSL3_SendAlert(ss, alert_fatal, 12214 isTLS ? decompression_failure : bad_record_mac); 12215 12216 /* There appears to be a bug with (at least) Apache + OpenSSL where 12217 * resumed SSLv3 connections don't actually use compression. See 12218 * comments 93-95 of 12219 * https://bugzilla.mozilla.org/show_bug.cgi?id=275744 12220 * 12221 * So, if we get a decompression error, and the record appears to 12222 * be already uncompressed, then we return a more specific error 12223 * code to hopefully save somebody some debugging time in the 12224 * future. 12225 */ 12226 if (plaintext->len >= 4) { 12227 unsigned int len = ((unsigned int) plaintext->buf[1] << 16) | 12228 ((unsigned int) plaintext->buf[2] << 8) | 12229 (unsigned int) plaintext->buf[3]; 12230 if (len == plaintext->len - 4) { 12231 /* This appears to be uncompressed already */ 12232 err = SSL_ERROR_RX_UNEXPECTED_UNCOMPRESSED_RECORD; 12233 } 12234 } 12235 12236 PORT_Free(plaintext->buf); 12237 PORT_SetError(err); 12238 return SECFailure; 12239 } 12240 12241 PORT_Free(plaintext->buf); 12242 } 12243 12244 /* 12245 ** Having completed the decompression, check the length again. 12246 */ 12247 if (isTLS && databuf->len > (MAX_FRAGMENT_LENGTH + 1024)) { 12248 SSL3_SendAlert(ss, alert_fatal, record_overflow); 12249 PORT_SetError(SSL_ERROR_RX_RECORD_TOO_LONG); 12250 return SECFailure; 12251 } 12252 12253 /* Application data records are processed by the caller of this 12254 ** function, not by this function. 12255 */ 12256 if (rType == content_application_data) { 12257 if (ss->firstHsDone) 12258 return SECSuccess; 12259 (void)SSL3_SendAlert(ss, alert_fatal, unexpected_message); 12260 PORT_SetError(SSL_ERROR_RX_UNEXPECTED_APPLICATION_DATA); 12261 return SECFailure; 12262 } 12263 12264 /* It's a record that must be handled by ssl itself, not the application. 12265 */ 12266 process_it: 12267 /* XXX Get the xmit lock here. Odds are very high that we'll be xmiting 12268 * data ang getting the xmit lock here prevents deadlocks. 12269 */ 12270 ssl_GetSSL3HandshakeLock(ss); 12271 12272 /* All the functions called in this switch MUST set error code if 12273 ** they return SECFailure or SECWouldBlock. 12274 */ 12275 switch (rType) { 12276 case content_change_cipher_spec: 12277 rv = ssl3_HandleChangeCipherSpecs(ss, databuf); 12278 break; 12279 case content_alert: 12280 rv = ssl3_HandleAlert(ss, databuf); 12281 break; 12282 case content_handshake: 12283 if (!IS_DTLS(ss)) { 12284 rv = ssl3_HandleHandshake(ss, databuf); 12285 } else { 12286 rv = dtls_HandleHandshake(ss, databuf); 12287 } 12288 break; 12289 /* 12290 case content_application_data is handled before this switch 12291 */ 12292 default: 12293 SSL_DBG(("%d: SSL3[%d]: bogus content type=%d", 12294 SSL_GETPID(), ss->fd, cText->type)); 12295 /* XXX Send an alert ??? */ 12296 PORT_SetError(SSL_ERROR_RX_UNKNOWN_RECORD_TYPE); 12297 rv = SECFailure; 12298 break; 12299 } 12300 12301 ssl_ReleaseSSL3HandshakeLock(ss); 12302 return rv; 12303 } 12304 12305 /* 12306 * Initialization functions 12307 */ 12308 12309 /* Called from ssl3_InitState, immediately below. */ 12310 /* Caller must hold the SpecWriteLock. */ 12311 static void 12312 ssl3_InitCipherSpec(sslSocket *ss, ssl3CipherSpec *spec) 12313 { 12314 spec->cipher_def = &bulk_cipher_defs[cipher_null]; 12315 PORT_Assert(spec->cipher_def->cipher == cipher_null); 12316 spec->mac_def = &mac_defs[mac_null]; 12317 PORT_Assert(spec->mac_def->mac == mac_null); 12318 spec->encode = Null_Cipher; 12319 spec->decode = Null_Cipher; 12320 spec->destroy = NULL; 12321 spec->compressor = NULL; 12322 spec->decompressor = NULL; 12323 spec->destroyCompressContext = NULL; 12324 spec->destroyDecompressContext = NULL; 12325 spec->mac_size = 0; 12326 spec->master_secret = NULL; 12327 spec->bypassCiphers = PR_FALSE; 12328 12329 spec->msItem.data = NULL; 12330 spec->msItem.len = 0; 12331 12332 spec->client.write_key = NULL; 12333 spec->client.write_mac_key = NULL; 12334 spec->client.write_mac_context = NULL; 12335 12336 spec->server.write_key = NULL; 12337 spec->server.write_mac_key = NULL; 12338 spec->server.write_mac_context = NULL; 12339 12340 spec->write_seq_num.high = 0; 12341 spec->write_seq_num.low = 0; 12342 12343 spec->read_seq_num.high = 0; 12344 spec->read_seq_num.low = 0; 12345 12346 spec->epoch = 0; 12347 dtls_InitRecvdRecords(&spec->recvdRecords); 12348 12349 spec->version = ss->vrange.max; 12350 } 12351 12352 /* Called from: ssl3_SendRecord 12353 ** ssl3_StartHandshakeHash() <- ssl2_BeginClientHandshake() 12354 ** ssl3_SendClientHello() 12355 ** ssl3_HandleV2ClientHello() 12356 ** ssl3_HandleRecord() 12357 ** 12358 ** This function should perhaps acquire and release the SpecWriteLock. 12359 ** 12360 ** 12361 */ 12362 static SECStatus 12363 ssl3_InitState(sslSocket *ss) 12364 { 12365 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss)); 12366 12367 if (ss->ssl3.initialized) 12368 return SECSuccess; /* Function should be idempotent */ 12369 12370 ss->ssl3.policy = SSL_ALLOWED; 12371 12372 ssl_GetSpecWriteLock(ss); 12373 ss->ssl3.crSpec = ss->ssl3.cwSpec = &ss->ssl3.specs[0]; 12374 ss->ssl3.prSpec = ss->ssl3.pwSpec = &ss->ssl3.specs[1]; 12375 ss->ssl3.hs.sendingSCSV = PR_FALSE; 12376 ssl3_InitCipherSpec(ss, ss->ssl3.crSpec); 12377 ssl3_InitCipherSpec(ss, ss->ssl3.prSpec); 12378 12379 ss->ssl3.hs.ws = (ss->sec.isServer) ? wait_client_hello : wait_server_hello; 12380 #ifdef NSS_ENABLE_ECC 12381 ss->ssl3.hs.negotiatedECCurves = ssl3_GetSupportedECCurveMask(ss); 12382 #endif 12383 ssl_ReleaseSpecWriteLock(ss); 12384 12385 PORT_Memset(&ss->xtnData, 0, sizeof(TLSExtensionData)); 12386 12387 if (IS_DTLS(ss)) { 12388 ss->ssl3.hs.sendMessageSeq = 0; 12389 ss->ssl3.hs.recvMessageSeq = 0; 12390 ss->ssl3.hs.rtTimeoutMs = INITIAL_DTLS_TIMEOUT_MS; 12391 ss->ssl3.hs.rtRetries = 0; 12392 ss->ssl3.hs.recvdHighWater = -1; 12393 PR_INIT_CLIST(&ss->ssl3.hs.lastMessageFlight); 12394 dtls_SetMTU(ss, 0); /* Set the MTU to the highest plateau */ 12395 } 12396 12397 PORT_Assert(!ss->ssl3.hs.messages.buf && !ss->ssl3.hs.messages.space); 12398 ss->ssl3.hs.messages.buf = NULL; 12399 ss->ssl3.hs.messages.space = 0; 12400 12401 ss->ssl3.hs.receivedNewSessionTicket = PR_FALSE; 12402 PORT_Memset(&ss->ssl3.hs.newSessionTicket, 0, 12403 sizeof(ss->ssl3.hs.newSessionTicket)); 12404 12405 ss->ssl3.initialized = PR_TRUE; 12406 return SECSuccess; 12407 } 12408 12409 /* Returns a reference counted object that contains a key pair. 12410 * Or NULL on failure. Initial ref count is 1. 12411 * Uses the keys in the pair as input. 12412 */ 12413 ssl3KeyPair * 12414 ssl3_NewKeyPair( SECKEYPrivateKey * privKey, SECKEYPublicKey * pubKey) 12415 { 12416 ssl3KeyPair * pair; 12417 12418 if (!privKey || !pubKey) { 12419 PORT_SetError(PR_INVALID_ARGUMENT_ERROR); 12420 return NULL; 12421 } 12422 pair = PORT_ZNew(ssl3KeyPair); 12423 if (!pair) 12424 return NULL; /* error code is set. */ 12425 pair->refCount = 1; 12426 pair->privKey = privKey; 12427 pair->pubKey = pubKey; 12428 return pair; /* success */ 12429 } 12430 12431 ssl3KeyPair * 12432 ssl3_GetKeyPairRef(ssl3KeyPair * keyPair) 12433 { 12434 PR_ATOMIC_INCREMENT(&keyPair->refCount); 12435 return keyPair; 12436 } 12437 12438 void 12439 ssl3_FreeKeyPair(ssl3KeyPair * keyPair) 12440 { 12441 PRInt32 newCount = PR_ATOMIC_DECREMENT(&keyPair->refCount); 12442 if (!newCount) { 12443 if (keyPair->privKey) 12444 SECKEY_DestroyPrivateKey(keyPair->privKey); 12445 if (keyPair->pubKey) 12446 SECKEY_DestroyPublicKey( keyPair->pubKey); 12447 PORT_Free(keyPair); 12448 } 12449 } 12450 12451 12452 12453 /* 12454 * Creates the public and private RSA keys for SSL Step down. 12455 * Called from SSL_ConfigSecureServer in sslsecur.c 12456 */ 12457 SECStatus 12458 ssl3_CreateRSAStepDownKeys(sslSocket *ss) 12459 { 12460 SECStatus rv = SECSuccess; 12461 SECKEYPrivateKey * privKey; /* RSA step down key */ 12462 SECKEYPublicKey * pubKey; /* RSA step down key */ 12463 12464 if (ss->stepDownKeyPair) 12465 ssl3_FreeKeyPair(ss->stepDownKeyPair); 12466 ss->stepDownKeyPair = NULL; 12467 #ifndef HACKED_EXPORT_SERVER 12468 /* Sigh, should have a get key strength call for private keys */ 12469 if (PK11_GetPrivateModulusLen(ss->serverCerts[kt_rsa].SERVERKEY) > 12470 EXPORT_RSA_KEY_LENGTH) { 12471 /* need to ask for the key size in bits */ 12472 privKey = SECKEY_CreateRSAPrivateKey(EXPORT_RSA_KEY_LENGTH * BPB, 12473 &pubKey, NULL); 12474 if (!privKey || !pubKey || 12475 !(ss->stepDownKeyPair = ssl3_NewKeyPair(privKey, pubKey))) { 12476 ssl_MapLowLevelError(SEC_ERROR_KEYGEN_FAIL); 12477 rv = SECFailure; 12478 } 12479 } 12480 #endif 12481 return rv; 12482 } 12483 12484 12485 /* record the export policy for this cipher suite */ 12486 SECStatus 12487 ssl3_SetPolicy(ssl3CipherSuite which, int policy) 12488 { 12489 ssl3CipherSuiteCfg *suite; 12490 12491 suite = ssl_LookupCipherSuiteCfg(which, cipherSuites); 12492 if (suite == NULL) { 12493 return SECFailure; /* err code was set by ssl_LookupCipherSuiteCfg */ 12494 } 12495 suite->policy = policy; 12496 12497 return SECSuccess; 12498 } 12499 12500 SECStatus 12501 ssl3_GetPolicy(ssl3CipherSuite which, PRInt32 *oPolicy) 12502 { 12503 ssl3CipherSuiteCfg *suite; 12504 PRInt32 policy; 12505 SECStatus rv; 12506 12507 suite = ssl_LookupCipherSuiteCfg(which, cipherSuites); 12508 if (suite) { 12509 policy = suite->policy; 12510 rv = SECSuccess; 12511 } else { 12512 policy = SSL_NOT_ALLOWED; 12513 rv = SECFailure; /* err code was set by Lookup. */ 12514 } 12515 *oPolicy = policy; 12516 return rv; 12517 } 12518 12519 /* record the user preference for this suite */ 12520 SECStatus 12521 ssl3_CipherPrefSetDefault(ssl3CipherSuite which, PRBool enabled) 12522 { 12523 ssl3CipherSuiteCfg *suite; 12524 12525 suite = ssl_LookupCipherSuiteCfg(which, cipherSuites); 12526 if (suite == NULL) { 12527 return SECFailure; /* err code was set by ssl_LookupCipherSuiteCfg */ 12528 } 12529 suite->enabled = enabled; 12530 return SECSuccess; 12531 } 12532 12533 /* return the user preference for this suite */ 12534 SECStatus 12535 ssl3_CipherPrefGetDefault(ssl3CipherSuite which, PRBool *enabled) 12536 { 12537 ssl3CipherSuiteCfg *suite; 12538 PRBool pref; 12539 SECStatus rv; 12540 12541 suite = ssl_LookupCipherSuiteCfg(which, cipherSuites); 12542 if (suite) { 12543 pref = suite->enabled; 12544 rv = SECSuccess; 12545 } else { 12546 pref = SSL_NOT_ALLOWED; 12547 rv = SECFailure; /* err code was set by Lookup. */ 12548 } 12549 *enabled = pref; 12550 return rv; 12551 } 12552 12553 SECStatus 12554 ssl3_CipherPrefSet(sslSocket *ss, ssl3CipherSuite which, PRBool enabled) 12555 { 12556 ssl3CipherSuiteCfg *suite; 12557 12558 suite = ssl_LookupCipherSuiteCfg(which, ss->cipherSuites); 12559 if (suite == NULL) { 12560 return SECFailure; /* err code was set by ssl_LookupCipherSuiteCfg */ 12561 } 12562 suite->enabled = enabled; 12563 return SECSuccess; 12564 } 12565 12566 SECStatus 12567 ssl3_CipherPrefGet(sslSocket *ss, ssl3CipherSuite which, PRBool *enabled) 12568 { 12569 ssl3CipherSuiteCfg *suite; 12570 PRBool pref; 12571 SECStatus rv; 12572 12573 suite = ssl_LookupCipherSuiteCfg(which, ss->cipherSuites); 12574 if (suite) { 12575 pref = suite->enabled; 12576 rv = SECSuccess; 12577 } else { 12578 pref = SSL_NOT_ALLOWED; 12579 rv = SECFailure; /* err code was set by Lookup. */ 12580 } 12581 *enabled = pref; 12582 return rv; 12583 } 12584 12585 SECStatus 12586 ssl3_CipherOrderSet(sslSocket *ss, const ssl3CipherSuite *ciphers, unsigned int len) 12587 { 12588 /* |i| iterates over |ciphers| while |done| and |j| iterate over 12589 * |ss->cipherSuites|. */ 12590 unsigned int i, done; 12591 12592 for (i = done = 0; i < len; i++) { 12593 PRUint16 id = ciphers[i]; 12594 unsigned int existingIndex, j; 12595 PRBool found = PR_FALSE; 12596 12597 for (j = done; j < ssl_V3_SUITES_IMPLEMENTED; j++) { 12598 if (ss->cipherSuites[j].cipher_suite == id) { 12599 existingIndex = j; 12600 found = PR_TRUE; 12601 break; 12602 } 12603 } 12604 12605 if (!found) { 12606 continue; 12607 } 12608 12609 if (existingIndex != done) { 12610 const ssl3CipherSuiteCfg temp = ss->cipherSuites[done]; 12611 ss->cipherSuites[done] = ss->cipherSuites[existingIndex]; 12612 ss->cipherSuites[existingIndex] = temp; 12613 } 12614 done++; 12615 } 12616 12617 /* Disable all cipher suites that weren't included. */ 12618 for (; done < ssl_V3_SUITES_IMPLEMENTED; done++) { 12619 ss->cipherSuites[done].enabled = 0; 12620 } 12621 12622 return SECSuccess; 12623 } 12624 12625 /* copy global default policy into socket. */ 12626 void 12627 ssl3_InitSocketPolicy(sslSocket *ss) 12628 { 12629 PORT_Memcpy(ss->cipherSuites, cipherSuites, sizeof cipherSuites); 12630 } 12631 12632 SECStatus 12633 ssl3_GetTLSUniqueChannelBinding(sslSocket *ss, 12634 unsigned char *out, 12635 unsigned int *outLen, 12636 unsigned int outLenMax) { 12637 PRBool isTLS; 12638 int index = 0; 12639 unsigned int len; 12640 SECStatus rv = SECFailure; 12641 12642 *outLen = 0; 12643 12644 ssl_GetSSL3HandshakeLock(ss); 12645 12646 ssl_GetSpecReadLock(ss); 12647 isTLS = (PRBool)(ss->ssl3.cwSpec->version > SSL_LIBRARY_VERSION_3_0); 12648 ssl_ReleaseSpecReadLock(ss); 12649 12650 /* The tls-unique channel binding is the first Finished structure in the 12651 * handshake. In the case of a resumption, that's the server's Finished. 12652 * Otherwise, it's the client's Finished. */ 12653 len = ss->ssl3.hs.finishedBytes; 12654 12655 /* Sending or receiving a Finished message will set finishedBytes to a 12656 * non-zero value. */ 12657 if (len == 0) { 12658 PORT_SetError(SSL_ERROR_HANDSHAKE_NOT_COMPLETED); 12659 goto loser; 12660 } 12661 12662 /* If we are in the middle of a renegotiation then the channel binding 12663 * value is poorly defined and depends on the direction that it will be 12664 * used on. Therefore we simply return an error in this case. */ 12665 if (ss->firstHsDone && ss->ssl3.hs.ws != idle_handshake) { 12666 PORT_SetError(SSL_ERROR_RENEGOTIATION_NOT_ALLOWED); 12667 goto loser; 12668 } 12669 12670 /* If resuming, then we want the second Finished value in the array, which 12671 * is the server's */ 12672 if (ss->ssl3.hs.isResuming) 12673 index = 1; 12674 12675 *outLen = len; 12676 if (outLenMax < len) { 12677 PORT_SetError(SEC_ERROR_OUTPUT_LEN); 12678 goto loser; 12679 } 12680 12681 if (isTLS) { 12682 memcpy(out, &ss->ssl3.hs.finishedMsgs.tFinished[index], len); 12683 } else { 12684 memcpy(out, &ss->ssl3.hs.finishedMsgs.sFinished[index], len); 12685 } 12686 12687 rv = SECSuccess; 12688 12689 loser: 12690 ssl_ReleaseSSL3HandshakeLock(ss); 12691 return rv; 12692 } 12693 12694 /* ssl3_config_match_init must have already been called by 12695 * the caller of this function. 12696 */ 12697 SECStatus 12698 ssl3_ConstructV2CipherSpecsHack(sslSocket *ss, unsigned char *cs, int *size) 12699 { 12700 int i, count = 0; 12701 12702 PORT_Assert(ss != 0); 12703 if (!ss) { 12704 PORT_SetError(PR_INVALID_ARGUMENT_ERROR); 12705 return SECFailure; 12706 } 12707 if (SSL3_ALL_VERSIONS_DISABLED(&ss->vrange)) { 12708 *size = 0; 12709 return SECSuccess; 12710 } 12711 if (cs == NULL) { 12712 *size = count_cipher_suites(ss, SSL_ALLOWED, PR_TRUE); 12713 return SECSuccess; 12714 } 12715 12716 /* ssl3_config_match_init was called by the caller of this function. */ 12717 for (i = 0; i < ssl_V3_SUITES_IMPLEMENTED; i++) { 12718 ssl3CipherSuiteCfg *suite = &ss->cipherSuites[i]; 12719 if (config_match(suite, SSL_ALLOWED, PR_TRUE, &ss->vrange)) { 12720 if (cs != NULL) { 12721 *cs++ = 0x00; 12722 *cs++ = (suite->cipher_suite >> 8) & 0xFF; 12723 *cs++ = suite->cipher_suite & 0xFF; 12724 } 12725 count++; 12726 } 12727 } 12728 *size = count; 12729 return SECSuccess; 12730 } 12731 12732 /* 12733 ** If ssl3 socket has completed the first handshake, and is in idle state, 12734 ** then start a new handshake. 12735 ** If flushCache is true, the SID cache will be flushed first, forcing a 12736 ** "Full" handshake (not a session restart handshake), to be done. 12737 ** 12738 ** called from SSL_RedoHandshake(), which already holds the handshake locks. 12739 */ 12740 SECStatus 12741 ssl3_RedoHandshake(sslSocket *ss, PRBool flushCache) 12742 { 12743 sslSessionID * sid = ss->sec.ci.sid; 12744 SECStatus rv; 12745 12746 PORT_Assert( ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss) ); 12747 12748 if (!ss->firstHsDone || 12749 ((ss->version >= SSL_LIBRARY_VERSION_3_0) && 12750 ss->ssl3.initialized && 12751 (ss->ssl3.hs.ws != idle_handshake))) { 12752 PORT_SetError(SSL_ERROR_HANDSHAKE_NOT_COMPLETED); 12753 return SECFailure; 12754 } 12755 12756 if (IS_DTLS(ss)) { 12757 dtls_RehandshakeCleanup(ss); 12758 } 12759 12760 if (ss->opt.enableRenegotiation == SSL_RENEGOTIATE_NEVER) { 12761 PORT_SetError(SSL_ERROR_RENEGOTIATION_NOT_ALLOWED); 12762 return SECFailure; 12763 } 12764 if (sid && flushCache) { 12765 if (ss->sec.uncache) 12766 ss->sec.uncache(sid); /* remove it from whichever cache it's in. */ 12767 ssl_FreeSID(sid); /* dec ref count and free if zero. */ 12768 ss->sec.ci.sid = NULL; 12769 } 12770 12771 ssl_GetXmitBufLock(ss); /**************************************/ 12772 12773 /* start off a new handshake. */ 12774 rv = (ss->sec.isServer) ? ssl3_SendHelloRequest(ss) 12775 : ssl3_SendClientHello(ss, PR_FALSE); 12776 12777 ssl_ReleaseXmitBufLock(ss); /**************************************/ 12778 return rv; 12779 } 12780 12781 /* Called from ssl_DestroySocketContents() in sslsock.c */ 12782 void 12783 ssl3_DestroySSL3Info(sslSocket *ss) 12784 { 12785 12786 if (ss->ssl3.clientCertificate != NULL) 12787 CERT_DestroyCertificate(ss->ssl3.clientCertificate); 12788 12789 if (ss->ssl3.clientPrivateKey != NULL) 12790 SECKEY_DestroyPrivateKey(ss->ssl3.clientPrivateKey); 12791 #ifdef NSS_PLATFORM_CLIENT_AUTH 12792 if (ss->ssl3.platformClientKey) 12793 ssl_FreePlatformKey(ss->ssl3.platformClientKey); 12794 #endif /* NSS_PLATFORM_CLIENT_AUTH */ 12795 12796 if (ss->ssl3.channelID) 12797 SECKEY_DestroyPrivateKey(ss->ssl3.channelID); 12798 if (ss->ssl3.channelIDPub) 12799 SECKEY_DestroyPublicKey(ss->ssl3.channelIDPub); 12800 12801 if (ss->ssl3.peerCertArena != NULL) 12802 ssl3_CleanupPeerCerts(ss); 12803 12804 if (ss->ssl3.clientCertChain != NULL) { 12805 CERT_DestroyCertificateList(ss->ssl3.clientCertChain); 12806 ss->ssl3.clientCertChain = NULL; 12807 } 12808 12809 /* clean up handshake */ 12810 #ifndef NO_PKCS11_BYPASS 12811 if (ss->opt.bypassPKCS11) { 12812 if (ss->ssl3.hs.hashType == handshake_hash_combo) { 12813 SHA1_DestroyContext((SHA1Context *)ss->ssl3.hs.sha_cx, PR_FALSE); 12814 MD5_DestroyContext((MD5Context *)ss->ssl3.hs.md5_cx, PR_FALSE); 12815 } else if (ss->ssl3.hs.hashType == handshake_hash_single) { 12816 ss->ssl3.hs.sha_obj->destroy(ss->ssl3.hs.sha_cx, PR_FALSE); 12817 } 12818 } 12819 #endif 12820 if (ss->ssl3.hs.md5) { 12821 PK11_DestroyContext(ss->ssl3.hs.md5,PR_TRUE); 12822 } 12823 if (ss->ssl3.hs.sha) { 12824 PK11_DestroyContext(ss->ssl3.hs.sha,PR_TRUE); 12825 } 12826 if (ss->ssl3.hs.clientSigAndHash) { 12827 PORT_Free(ss->ssl3.hs.clientSigAndHash); 12828 } 12829 if (ss->ssl3.hs.messages.buf) { 12830 PORT_Free(ss->ssl3.hs.messages.buf); 12831 ss->ssl3.hs.messages.buf = NULL; 12832 ss->ssl3.hs.messages.len = 0; 12833 ss->ssl3.hs.messages.space = 0; 12834 } 12835 12836 /* free the SSL3Buffer (msg_body) */ 12837 PORT_Free(ss->ssl3.hs.msg_body.buf); 12838 12839 SECITEM_FreeItem(&ss->ssl3.hs.newSessionTicket.ticket, PR_FALSE); 12840 12841 /* free up the CipherSpecs */ 12842 ssl3_DestroyCipherSpec(&ss->ssl3.specs[0], PR_TRUE/*freeSrvName*/); 12843 ssl3_DestroyCipherSpec(&ss->ssl3.specs[1], PR_TRUE/*freeSrvName*/); 12844 12845 /* Destroy the DTLS data */ 12846 if (IS_DTLS(ss)) { 12847 dtls_FreeHandshakeMessages(&ss->ssl3.hs.lastMessageFlight); 12848 if (ss->ssl3.hs.recvdFragments.buf) { 12849 PORT_Free(ss->ssl3.hs.recvdFragments.buf); 12850 } 12851 } 12852 12853 ss->ssl3.initialized = PR_FALSE; 12854 12855 SECITEM_FreeItem(&ss->ssl3.nextProto, PR_FALSE); 12856 } 12857 12858 /* End of ssl3con.c */ 12859
