/src/nss/lib/ssl/sslsock.c
Line | Count | Source |
1 | | /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ |
2 | | /* |
3 | | * vtables (and methods that call through them) for the 4 types of |
4 | | * SSLSockets supported. Only one type is still supported. |
5 | | * Various other functions. |
6 | | * |
7 | | * This Source Code Form is subject to the terms of the Mozilla Public |
8 | | * License, v. 2.0. If a copy of the MPL was not distributed with this |
9 | | * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
10 | | #include "seccomon.h" |
11 | | #include "cert.h" |
12 | | #include "keyhi.h" |
13 | | #include "ssl.h" |
14 | | #include "sslexp.h" |
15 | | #include "sslimpl.h" |
16 | | #include "sslproto.h" |
17 | | #include "nspr.h" |
18 | | #include "private/pprio.h" |
19 | | #include "nss.h" |
20 | | #include "pk11pqg.h" |
21 | | #include "pk11pub.h" |
22 | | #include "tls13ech.h" |
23 | | #include "tls13psk.h" |
24 | | #include "tls13subcerts.h" |
25 | | |
26 | | static const sslSocketOps ssl_default_ops = { /* No SSL. */ |
27 | | ssl_DefConnect, |
28 | | NULL, |
29 | | ssl_DefBind, |
30 | | ssl_DefListen, |
31 | | ssl_DefShutdown, |
32 | | ssl_DefClose, |
33 | | ssl_DefRecv, |
34 | | ssl_DefSend, |
35 | | ssl_DefRead, |
36 | | ssl_DefWrite, |
37 | | ssl_DefGetpeername, |
38 | | ssl_DefGetsockname |
39 | | }; |
40 | | |
41 | | static const sslSocketOps ssl_secure_ops = { /* SSL. */ |
42 | | ssl_SecureConnect, |
43 | | NULL, |
44 | | ssl_DefBind, |
45 | | ssl_DefListen, |
46 | | ssl_SecureShutdown, |
47 | | ssl_SecureClose, |
48 | | ssl_SecureRecv, |
49 | | ssl_SecureSend, |
50 | | ssl_SecureRead, |
51 | | ssl_SecureWrite, |
52 | | ssl_DefGetpeername, |
53 | | ssl_DefGetsockname |
54 | | }; |
55 | | |
56 | | /* |
57 | | ** default settings for socket enables |
58 | | */ |
59 | | static sslOptions ssl_defaults = { |
60 | | .nextProtoNego = { siBuffer, NULL, 0 }, |
61 | | .maxEarlyDataSize = 1 << 16, |
62 | | .recordSizeLimit = MAX_FRAGMENT_LENGTH + 1, |
63 | | .useSecurity = PR_TRUE, |
64 | | .useSocks = PR_FALSE, |
65 | | .requestCertificate = PR_FALSE, |
66 | | .requireCertificate = SSL_REQUIRE_FIRST_HANDSHAKE, |
67 | | .handshakeAsClient = PR_FALSE, |
68 | | .handshakeAsServer = PR_FALSE, |
69 | | .noCache = PR_FALSE, |
70 | | .fdx = PR_FALSE, |
71 | | .detectRollBack = PR_TRUE, |
72 | | .noLocks = PR_FALSE, |
73 | | .enableSessionTickets = PR_FALSE, |
74 | | .enableDeflate = PR_FALSE, |
75 | | .enableRenegotiation = SSL_RENEGOTIATE_REQUIRES_XTN, |
76 | | .requireSafeNegotiation = PR_FALSE, |
77 | | .enableFalseStart = PR_FALSE, |
78 | | .cbcRandomIV = PR_TRUE, |
79 | | .enableOCSPStapling = PR_FALSE, |
80 | | .enableDelegatedCredentials = PR_FALSE, |
81 | | .enableALPN = PR_TRUE, |
82 | | .reuseServerECDHEKey = PR_FALSE, |
83 | | .enableFallbackSCSV = PR_FALSE, |
84 | | .enableServerDhe = PR_TRUE, |
85 | | .enableExtendedMS = PR_TRUE, |
86 | | .enableSignedCertTimestamps = PR_FALSE, |
87 | | .requireDHENamedGroups = PR_FALSE, |
88 | | .enable0RttData = PR_FALSE, |
89 | | .enableTls13CompatMode = PR_FALSE, |
90 | | .enableDtls13VersionCompat = PR_FALSE, |
91 | | .enableDtlsShortHeader = PR_FALSE, |
92 | | .enableHelloDowngradeCheck = PR_TRUE, |
93 | | .enableV2CompatibleHello = PR_FALSE, |
94 | | .enablePostHandshakeAuth = PR_FALSE, |
95 | | .suppressEndOfEarlyData = PR_FALSE, |
96 | | .enableTls13GreaseEch = PR_FALSE, |
97 | | .enableTls13BackendEch = PR_FALSE, |
98 | | .callExtensionWriterOnEchInner = PR_FALSE, |
99 | | .enableEchXtnCompression = PR_TRUE, |
100 | | .enableGrease = PR_FALSE, |
101 | | .enableChXtnPermutation = PR_FALSE, |
102 | | .dbLoadCertChain = PR_TRUE, |
103 | | .enablePlaintextResumptionExport = PR_FALSE, |
104 | | }; |
105 | | |
106 | | /* |
107 | | * default range of enabled SSL/TLS protocols |
108 | | */ |
109 | | static SSLVersionRange versions_defaults_stream = { |
110 | | SSL_LIBRARY_VERSION_TLS_1_2, |
111 | | SSL_LIBRARY_VERSION_TLS_1_3 |
112 | | }; |
113 | | |
114 | | static SSLVersionRange versions_defaults_datagram = { |
115 | | SSL_LIBRARY_VERSION_TLS_1_2, |
116 | | SSL_LIBRARY_VERSION_TLS_1_2 |
117 | | }; |
118 | | |
119 | | #define VERSIONS_DEFAULTS(variant) \ |
120 | 183k | (variant == ssl_variant_stream ? &versions_defaults_stream : &versions_defaults_datagram) |
121 | | #define VERSIONS_POLICY_MIN(variant) \ |
122 | 0 | (variant == ssl_variant_stream ? NSS_TLS_VERSION_MIN_POLICY : NSS_DTLS_VERSION_MIN_POLICY) |
123 | | #define VERSIONS_POLICY_MAX(variant) \ |
124 | 0 | (variant == ssl_variant_stream ? NSS_TLS_VERSION_MAX_POLICY : NSS_DTLS_VERSION_MAX_POLICY) |
125 | | |
126 | | sslSessionIDLookupFunc ssl_sid_lookup; |
127 | | |
128 | | static PRDescIdentity ssl_layer_id; |
129 | | |
130 | | static PRCallOnceType ssl_setDefaultsFromEnvironment = { 0 }; |
131 | | |
132 | | PRBool ssl_force_locks = PR_FALSE; |
133 | | int ssl_lock_readers = 1; /* default true. */ |
134 | | char ssl_debug; |
135 | | char ssl_trace; |
136 | | FILE *ssl_trace_iob; |
137 | | |
138 | | #ifdef NSS_ALLOW_SSLKEYLOGFILE |
139 | | FILE *ssl_keylog_iob; |
140 | | PRLock *ssl_keylog_lock; |
141 | | #endif |
142 | | |
143 | | /* SRTP_NULL_HMAC_SHA1_80 and SRTP_NULL_HMAC_SHA1_32 are not implemented. */ |
144 | | static const PRUint16 srtpCiphers[] = { |
145 | | SRTP_AES128_CM_HMAC_SHA1_80, |
146 | | SRTP_AES128_CM_HMAC_SHA1_32, |
147 | | 0 |
148 | | }; |
149 | | |
150 | | /* This list is in preference order. Note that while some smaller groups appear |
151 | | * early in the list, smaller groups are generally ignored when iterating |
152 | | * through this list. ffdhe_custom must not appear in this list. */ |
153 | | #define ECGROUP(name, size, oid, assumeSupported) \ |
154 | | { \ |
155 | | ssl_grp_ec_##name, size, ssl_kea_ecdh, \ |
156 | | SEC_OID_SECG_EC_##oid, assumeSupported \ |
157 | | } |
158 | | #define FFGROUP(size) \ |
159 | | { \ |
160 | | ssl_grp_ffdhe_##size, size, ssl_kea_dh, \ |
161 | | SEC_OID_TLS_FFDHE_##size, PR_TRUE \ |
162 | | } |
163 | | #define HYGROUP(first, second, size, first_oid, second_oid, assumeSupported) \ |
164 | | { \ |
165 | | ssl_grp_kem_##first##second, size, ssl_kea_ecdh_hybrid, \ |
166 | | SEC_OID_##first_oid##second_oid, assumeSupported \ |
167 | | } |
168 | | |
169 | | const sslNamedGroupDef ssl_named_groups[] = { |
170 | | /* Note that 256 for 25519 and x25519mlkem786 is a lie, but we only use it |
171 | | * for checking bit security and expect 256 bits there (not 255). */ |
172 | | HYGROUP(mlkem768, x25519, 256, MLKEM768, X25519, PR_TRUE), |
173 | | { ssl_grp_ec_curve25519, 256, ssl_kea_ecdh, SEC_OID_CURVE25519, PR_TRUE }, |
174 | | ECGROUP(secp256r1, 256, SECP256R1, PR_TRUE), |
175 | | ECGROUP(secp384r1, 384, SECP384R1, PR_TRUE), |
176 | | ECGROUP(secp521r1, 521, SECP521R1, PR_TRUE), |
177 | | HYGROUP(secp256r1, mlkem768, 256, SECP256R1, MLKEM768, PR_TRUE), |
178 | | HYGROUP(secp384r1, mlkem1024, 256, SECP384R1, MLKEM1024, PR_TRUE), |
179 | | { ssl_grp_kem_mlkem1024, 256, ssl_kea_kem, SEC_OID_ML_KEM_1024, PR_TRUE }, |
180 | | FFGROUP(2048), |
181 | | FFGROUP(3072), |
182 | | FFGROUP(4096), |
183 | | FFGROUP(6144), |
184 | | FFGROUP(8192), |
185 | | ECGROUP(secp192r1, 192, SECP192R1, PR_FALSE), |
186 | | ECGROUP(secp160r2, 160, SECP160R2, PR_FALSE), |
187 | | ECGROUP(secp160k1, 160, SECP160K1, PR_FALSE), |
188 | | ECGROUP(secp160r1, 160, SECP160R1, PR_FALSE), |
189 | | ECGROUP(sect163k1, 163, SECT163K1, PR_FALSE), |
190 | | ECGROUP(sect163r1, 163, SECT163R1, PR_FALSE), |
191 | | ECGROUP(sect163r2, 163, SECT163R2, PR_FALSE), |
192 | | ECGROUP(secp192k1, 192, SECP192K1, PR_FALSE), |
193 | | ECGROUP(sect193r1, 193, SECT193R1, PR_FALSE), |
194 | | ECGROUP(sect193r2, 193, SECT193R2, PR_FALSE), |
195 | | ECGROUP(secp224r1, 224, SECP224R1, PR_FALSE), |
196 | | ECGROUP(secp224k1, 224, SECP224K1, PR_FALSE), |
197 | | ECGROUP(sect233k1, 233, SECT233K1, PR_FALSE), |
198 | | ECGROUP(sect233r1, 233, SECT233R1, PR_FALSE), |
199 | | ECGROUP(sect239k1, 239, SECT239K1, PR_FALSE), |
200 | | ECGROUP(secp256k1, 256, SECP256K1, PR_FALSE), |
201 | | ECGROUP(sect283k1, 283, SECT283K1, PR_FALSE), |
202 | | ECGROUP(sect283r1, 283, SECT283R1, PR_FALSE), |
203 | | ECGROUP(sect409k1, 409, SECT409K1, PR_FALSE), |
204 | | ECGROUP(sect409r1, 409, SECT409R1, PR_FALSE), |
205 | | ECGROUP(sect571k1, 571, SECT571K1, PR_FALSE), |
206 | | ECGROUP(sect571r1, 571, SECT571R1, PR_FALSE), |
207 | | }; |
208 | | PR_STATIC_ASSERT(SSL_NAMED_GROUP_COUNT == PR_ARRAY_SIZE(ssl_named_groups)); |
209 | | |
210 | | #undef ECGROUP |
211 | | #undef FFGROUP |
212 | | #undef HYGROUP |
213 | | |
214 | | /* forward declarations. */ |
215 | | static sslSocket *ssl_NewSocket(PRBool makeLocks, SSLProtocolVariant variant); |
216 | | static SECStatus ssl_MakeLocks(sslSocket *ss); |
217 | | static PRStatus ssl_SetDefaultsFromEnvironmentCallOnce(void); |
218 | | static void ssl_SetDefaultsFromEnvironment(void); |
219 | | static PRStatus ssl_PushIOLayer(sslSocket *ns, PRFileDesc *stack, |
220 | | PRDescIdentity id); |
221 | | |
222 | | /************************************************************************/ |
223 | | |
224 | | /* |
225 | | ** Lookup a socket structure from a file descriptor. |
226 | | ** Only functions called through the PRIOMethods table should use this. |
227 | | ** Other app-callable functions should use ssl_FindSocket. |
228 | | */ |
229 | | static sslSocket * |
230 | | ssl_GetPrivate(PRFileDesc *fd) |
231 | 1.52M | { |
232 | 1.52M | sslSocket *ss; |
233 | | |
234 | 1.52M | PORT_Assert(fd != NULL); |
235 | 1.52M | PORT_Assert(fd->methods->file_type == PR_DESC_LAYERED); |
236 | 1.52M | PORT_Assert(fd->identity == ssl_layer_id); |
237 | | |
238 | 1.52M | if (fd->methods->file_type != PR_DESC_LAYERED || |
239 | 1.52M | fd->identity != ssl_layer_id) { |
240 | 0 | PORT_SetError(PR_BAD_DESCRIPTOR_ERROR); |
241 | 0 | return NULL; |
242 | 0 | } |
243 | | |
244 | 1.52M | ss = (sslSocket *)fd->secret; |
245 | | /* Set ss->fd lazily. We can't rely on the value of ss->fd set by |
246 | | * ssl_PushIOLayer because another PR_PushIOLayer call will switch the |
247 | | * contents of the PRFileDesc pointed by ss->fd and the new layer. |
248 | | * See bug 807250. |
249 | | */ |
250 | 1.52M | ss->fd = fd; |
251 | 1.52M | return ss; |
252 | 1.52M | } |
253 | | |
254 | | /* This function tries to find the SSL layer in the stack. |
255 | | * It searches for the first SSL layer at or below the argument fd, |
256 | | * and failing that, it searches for the nearest SSL layer above the |
257 | | * argument fd. It returns the private sslSocket from the found layer. |
258 | | */ |
259 | | sslSocket * |
260 | | ssl_FindSocket(PRFileDesc *fd) |
261 | 6.45M | { |
262 | 6.45M | PRFileDesc *layer; |
263 | 6.45M | sslSocket *ss; |
264 | | |
265 | 6.45M | PORT_Assert(fd != NULL); |
266 | 6.45M | PORT_Assert(ssl_layer_id != 0); |
267 | | |
268 | 6.45M | layer = PR_GetIdentitiesLayer(fd, ssl_layer_id); |
269 | 6.45M | if (layer == NULL) { |
270 | 0 | PORT_SetError(PR_BAD_DESCRIPTOR_ERROR); |
271 | 0 | return NULL; |
272 | 0 | } |
273 | | |
274 | 6.45M | ss = (sslSocket *)layer->secret; |
275 | | /* Set ss->fd lazily. We can't rely on the value of ss->fd set by |
276 | | * ssl_PushIOLayer because another PR_PushIOLayer call will switch the |
277 | | * contents of the PRFileDesc pointed by ss->fd and the new layer. |
278 | | * See bug 807250. |
279 | | */ |
280 | 6.45M | ss->fd = layer; |
281 | 6.45M | return ss; |
282 | 6.45M | } |
283 | | |
284 | | /* |
285 | | * Copy all model-copyable socket configuration from |src| to |dst|. |
286 | | * |
287 | | * This covers options, cipher suites, certificates, keys, ECH, PSK, |
288 | | * anti-replay, trust anchors, callbacks, and protocol settings — i.e. |
289 | | * everything that SSL_ImportFD (via ssl_DupSocket) and SSL_ReconfigFD |
290 | | * need to transfer from a model socket. |
291 | | * |
292 | | * For heap-owned fields, any existing resources in |dst| are freed |
293 | | * before replacement, so this is safe to call on both freshly-created |
294 | | * and live sockets. |
295 | | * |
296 | | * If |replaceCallbacks| is true, all callbacks are copied unconditionally |
297 | | * (appropriate for ssl_DupSocket where |dst| is freshly created). |
298 | | * If false, each callback is only overwritten when |src| has a non-NULL |
299 | | * value, preserving any existing callbacks on |dst| (appropriate for |
300 | | * SSL_ReconfigFD where the application has already registered callbacks |
301 | | * on the live socket). |
302 | | * |
303 | | * Connection-level state (peerID, url, timeouts, security info, |
304 | | * handshake state) is NOT copied — callers handle those as needed. |
305 | | */ |
306 | | static SECStatus |
307 | | ssl_CopySocketConfig(sslSocket *dst, sslSocket *src, PRBool replaceCallbacks) |
308 | 31.2k | { |
309 | 31.2k | SECStatus rv; |
310 | | |
311 | | /* Options — struct copy, then deep-copy the nextProtoNego SECItem |
312 | | * to give each socket its own buffer (avoids double-free). |
313 | | * Zero the SECItem before the deep copy so that on allocation |
314 | | * failure dst does not retain a shallow pointer to src's buffer |
315 | | * (which would cause a double-free when dst is freed). */ |
316 | 31.2k | SECITEM_FreeItem(&dst->opt.nextProtoNego, PR_FALSE); |
317 | 31.2k | dst->opt = src->opt; |
318 | 31.2k | dst->opt.nextProtoNego.data = NULL; |
319 | 31.2k | dst->opt.nextProtoNego.len = 0; |
320 | 31.2k | rv = SECITEM_CopyItem(NULL, &dst->opt.nextProtoNego, |
321 | 31.2k | &src->opt.nextProtoNego); |
322 | 31.2k | if (rv != SECSuccess) { |
323 | 0 | return SECFailure; |
324 | 0 | } |
325 | | |
326 | 31.2k | dst->vrange = src->vrange; |
327 | 31.2k | dst->now = src->now; |
328 | 31.2k | dst->nowArg = src->nowArg; |
329 | | |
330 | | /* Cipher suite configuration (all fixed-size value arrays). */ |
331 | 31.2k | PORT_Memcpy(dst->cipherSuites, src->cipherSuites, |
332 | 31.2k | sizeof(src->cipherSuites)); |
333 | 31.2k | PORT_Memcpy(dst->ssl3.dtlsSRTPCiphers, src->ssl3.dtlsSRTPCiphers, |
334 | 31.2k | sizeof(PRUint16) * src->ssl3.dtlsSRTPCipherCount); |
335 | 31.2k | dst->ssl3.dtlsSRTPCipherCount = src->ssl3.dtlsSRTPCipherCount; |
336 | 31.2k | PORT_Memcpy(dst->ssl3.signatureSchemes, src->ssl3.signatureSchemes, |
337 | 31.2k | sizeof(dst->ssl3.signatureSchemes[0]) * |
338 | 31.2k | src->ssl3.signatureSchemeCount); |
339 | 31.2k | dst->ssl3.signatureSchemeCount = src->ssl3.signatureSchemeCount; |
340 | 31.2k | dst->ssl3.downgradeCheckVersion = src->ssl3.downgradeCheckVersion; |
341 | 31.2k | dst->ssl3.dheWeakGroupEnabled = src->ssl3.dheWeakGroupEnabled; |
342 | | |
343 | 31.2k | PORT_Memcpy(dst->ssl3.supportedCertCompressionAlgorithms, |
344 | 31.2k | src->ssl3.supportedCertCompressionAlgorithms, |
345 | 31.2k | sizeof(dst->ssl3.supportedCertCompressionAlgorithms[0]) * |
346 | 31.2k | src->ssl3.supportedCertCompressionAlgorithmsCount); |
347 | 31.2k | dst->ssl3.supportedCertCompressionAlgorithmsCount = |
348 | 31.2k | src->ssl3.supportedCertCompressionAlgorithmsCount; |
349 | | |
350 | 31.2k | if (dst->opt.useSecurity) { |
351 | 31.2k | PRCList *cursor; |
352 | | |
353 | | /* Server certificates (free old, deep-copy new). */ |
354 | 31.2k | while (!PR_CLIST_IS_EMPTY(&dst->serverCerts)) { |
355 | 0 | cursor = PR_LIST_TAIL(&dst->serverCerts); |
356 | 0 | PR_REMOVE_LINK(cursor); |
357 | 0 | ssl_FreeServerCert((sslServerCert *)cursor); |
358 | 0 | } |
359 | 31.2k | for (cursor = PR_NEXT_LINK(&src->serverCerts); |
360 | 156k | cursor != &src->serverCerts; |
361 | 124k | cursor = PR_NEXT_LINK(cursor)) { |
362 | 124k | sslServerCert *sc = ssl_CopyServerCert((sslServerCert *)cursor); |
363 | 124k | if (!sc) { |
364 | 0 | return SECFailure; |
365 | 0 | } |
366 | 124k | PR_APPEND_LINK(&sc->link, &dst->serverCerts); |
367 | 124k | } |
368 | | |
369 | | /* Ephemeral key pairs (free old, deep-copy new). */ |
370 | 31.2k | ssl_FreeEphemeralKeyPairs(dst); |
371 | 31.2k | for (cursor = PR_NEXT_LINK(&src->ephemeralKeyPairs); |
372 | 31.2k | cursor != &src->ephemeralKeyPairs; |
373 | 31.2k | cursor = PR_NEXT_LINK(cursor)) { |
374 | 0 | sslEphemeralKeyPair *skp = ssl_CopyEphemeralKeyPair( |
375 | 0 | (sslEphemeralKeyPair *)cursor); |
376 | 0 | if (!skp) { |
377 | 0 | return SECFailure; |
378 | 0 | } |
379 | 0 | PR_APPEND_LINK(&skp->link, &dst->ephemeralKeyPairs); |
380 | 0 | } |
381 | | |
382 | | /* Extension hooks (free old, deep-copy new). */ |
383 | 31.2k | while (!PR_CLIST_IS_EMPTY(&dst->extensionHooks)) { |
384 | 0 | cursor = PR_LIST_TAIL(&dst->extensionHooks); |
385 | 0 | PR_REMOVE_LINK(cursor); |
386 | 0 | PORT_Free(cursor); |
387 | 0 | } |
388 | 31.2k | for (cursor = PR_NEXT_LINK(&src->extensionHooks); |
389 | 31.2k | cursor != &src->extensionHooks; |
390 | 31.2k | cursor = PR_NEXT_LINK(cursor)) { |
391 | 0 | sslCustomExtensionHooks *sh = PORT_ZNew(sslCustomExtensionHooks); |
392 | 0 | if (!sh) { |
393 | 0 | return SECFailure; |
394 | 0 | } |
395 | 0 | *sh = *(sslCustomExtensionHooks *)cursor; |
396 | 0 | PR_APPEND_LINK(&sh->link, &dst->extensionHooks); |
397 | 0 | } |
398 | | |
399 | 31.2k | PORT_Memcpy((void *)dst->namedGroupPreferences, |
400 | 31.2k | src->namedGroupPreferences, |
401 | 31.2k | sizeof(dst->namedGroupPreferences)); |
402 | 31.2k | dst->additionalShares = src->additionalShares; |
403 | | |
404 | | /* Trust anchor names (free old, deep-copy new). */ |
405 | 31.2k | if (dst->ssl3.ca_list) { |
406 | 0 | CERT_FreeDistNames(dst->ssl3.ca_list); |
407 | 0 | dst->ssl3.ca_list = NULL; |
408 | 0 | } |
409 | 31.2k | if (src->ssl3.ca_list) { |
410 | 0 | dst->ssl3.ca_list = CERT_DupDistNames(src->ssl3.ca_list); |
411 | 0 | if (!dst->ssl3.ca_list) { |
412 | 0 | return SECFailure; |
413 | 0 | } |
414 | 0 | } |
415 | | |
416 | | /* ECH configuration (free old, deep-copy new). */ |
417 | 31.2k | tls13_DestroyEchConfigs(&dst->echConfigs); |
418 | 31.2k | SECKEY_DestroyPrivateKey(dst->echPrivKey); |
419 | 31.2k | SECKEY_DestroyPublicKey(dst->echPubKey); |
420 | 31.2k | dst->echPrivKey = NULL; |
421 | 31.2k | dst->echPubKey = NULL; |
422 | 31.2k | rv = tls13_CopyEchConfigs(&src->echConfigs, &dst->echConfigs); |
423 | 31.2k | if (rv != SECSuccess) { |
424 | 0 | return SECFailure; |
425 | 0 | } |
426 | 31.2k | if (src->echPrivKey && src->echPubKey) { |
427 | 0 | dst->echPrivKey = SECKEY_CopyPrivateKey(src->echPrivKey); |
428 | 0 | dst->echPubKey = SECKEY_CopyPublicKey(src->echPubKey); |
429 | 0 | if (!dst->echPrivKey || !dst->echPubKey) { |
430 | 0 | return SECFailure; |
431 | 0 | } |
432 | 0 | } |
433 | | |
434 | | /* Anti-replay context (refcounted). */ |
435 | 31.2k | if (dst->antiReplay) { |
436 | 0 | tls13_ReleaseAntiReplayContext(dst->antiReplay); |
437 | 0 | dst->antiReplay = NULL; |
438 | 0 | } |
439 | 31.2k | if (src->antiReplay) { |
440 | 0 | dst->antiReplay = tls13_RefAntiReplayContext(src->antiReplay); |
441 | 0 | PORT_Assert(dst->antiReplay); |
442 | 0 | if (!dst->antiReplay) { |
443 | 0 | return SECFailure; |
444 | 0 | } |
445 | 0 | } |
446 | | |
447 | | /* External PSK (free old, deep-copy new). */ |
448 | 31.2k | if (dst->psk) { |
449 | 0 | tls13_DestroyPsk(dst->psk); |
450 | 0 | dst->psk = NULL; |
451 | 0 | } |
452 | 31.2k | if (src->psk) { |
453 | 0 | dst->psk = tls13_CopyPsk(src->psk); |
454 | 0 | if (!dst->psk) { |
455 | 0 | return SECFailure; |
456 | 0 | } |
457 | 0 | } |
458 | | |
459 | | /* Callbacks — not owned by the socket, shallow copy. |
460 | | * When replaceCallbacks is false (SSL_ReconfigFD), only |
461 | | * overwrite if the model has a non-NULL value, so that the |
462 | | * application's existing callbacks on the live socket are |
463 | | * preserved for any callback the model does not set. */ |
464 | 31.2k | if (replaceCallbacks || src->authCertificate) { |
465 | 31.2k | dst->authCertificate = src->authCertificate; |
466 | 31.2k | dst->authCertificateArg = src->authCertificateArg; |
467 | 31.2k | } |
468 | 31.2k | if (replaceCallbacks || src->getClientAuthData) { |
469 | 31.2k | dst->getClientAuthData = src->getClientAuthData; |
470 | 31.2k | dst->getClientAuthDataArg = src->getClientAuthDataArg; |
471 | 31.2k | } |
472 | 31.2k | if (replaceCallbacks || src->sniSocketConfig) { |
473 | 31.2k | dst->sniSocketConfig = src->sniSocketConfig; |
474 | 31.2k | dst->sniSocketConfigArg = src->sniSocketConfigArg; |
475 | 31.2k | } |
476 | 31.2k | if (replaceCallbacks || src->alertReceivedCallback) { |
477 | 31.2k | dst->alertReceivedCallback = src->alertReceivedCallback; |
478 | 31.2k | dst->alertReceivedCallbackArg = src->alertReceivedCallbackArg; |
479 | 31.2k | } |
480 | 31.2k | if (replaceCallbacks || src->alertSentCallback) { |
481 | 31.2k | dst->alertSentCallback = src->alertSentCallback; |
482 | 31.2k | dst->alertSentCallbackArg = src->alertSentCallbackArg; |
483 | 31.2k | } |
484 | 31.2k | if (replaceCallbacks || src->handleBadCert) { |
485 | 31.2k | dst->handleBadCert = src->handleBadCert; |
486 | 31.2k | dst->badCertArg = src->badCertArg; |
487 | 31.2k | } |
488 | 31.2k | if (replaceCallbacks || src->handshakeCallback) { |
489 | 31.2k | dst->handshakeCallback = src->handshakeCallback; |
490 | 31.2k | dst->handshakeCallbackData = src->handshakeCallbackData; |
491 | 31.2k | } |
492 | 31.2k | if (replaceCallbacks || src->pkcs11PinArg) |
493 | 31.2k | dst->pkcs11PinArg = src->pkcs11PinArg; |
494 | | |
495 | | /* These callbacks are part of protocol configuration (set via |
496 | | * SSL_SetNextProtoNego, SSL_SetCanFalseStartCallback, etc.) |
497 | | * rather than event handlers, so always copy them. */ |
498 | 31.2k | dst->nextProtoCallback = src->nextProtoCallback; |
499 | 31.2k | dst->nextProtoArg = src->nextProtoArg; |
500 | 31.2k | dst->canFalseStartCallback = src->canFalseStartCallback; |
501 | 31.2k | dst->canFalseStartCallbackData = src->canFalseStartCallbackData; |
502 | 31.2k | dst->resumptionTokenCallback = src->resumptionTokenCallback; |
503 | 31.2k | dst->resumptionTokenContext = src->resumptionTokenContext; |
504 | 31.2k | } |
505 | | |
506 | 31.2k | return SECSuccess; |
507 | 31.2k | } |
508 | | |
509 | | static sslSocket * |
510 | | ssl_DupSocket(sslSocket *os) |
511 | 31.2k | { |
512 | 31.2k | sslSocket *ss; |
513 | 31.2k | SECStatus rv; |
514 | | |
515 | 31.2k | ss = ssl_NewSocket((PRBool)(!os->opt.noLocks), os->protocolVariant); |
516 | 31.2k | if (!ss) { |
517 | 0 | return NULL; |
518 | 0 | } |
519 | | |
520 | 31.2k | rv = ssl_CopySocketConfig(ss, os, PR_TRUE); |
521 | 31.2k | if (rv != SECSuccess) { |
522 | 0 | goto loser; |
523 | 0 | } |
524 | 31.2k | ss->opt.useSocks = PR_FALSE; |
525 | | |
526 | 31.2k | ss->peerID = !os->peerID ? NULL : PORT_Strdup(os->peerID); |
527 | 31.2k | ss->url = !os->url ? NULL : PORT_Strdup(os->url); |
528 | | |
529 | 31.2k | ss->ops = os->ops; |
530 | 31.2k | ss->rTimeout = os->rTimeout; |
531 | 31.2k | ss->wTimeout = os->wTimeout; |
532 | 31.2k | ss->cTimeout = os->cTimeout; |
533 | 31.2k | ss->dbHandle = os->dbHandle; |
534 | | |
535 | 31.2k | if (ss->opt.useSecurity) { |
536 | 31.2k | rv = ssl_CopySecurityInfo(ss, os); |
537 | 31.2k | if (rv != SECSuccess) { |
538 | 0 | goto loser; |
539 | 0 | } |
540 | 31.2k | } |
541 | | |
542 | 31.2k | return ss; |
543 | | |
544 | 0 | loser: |
545 | 0 | ssl_FreeSocket(ss); |
546 | 0 | return NULL; |
547 | 31.2k | } |
548 | | |
549 | | static void |
550 | | ssl_DestroyLocks(sslSocket *ss) |
551 | 91.0k | { |
552 | | /* Destroy locks. */ |
553 | 91.0k | if (ss->firstHandshakeLock) { |
554 | 61.2k | PR_DestroyMonitor(ss->firstHandshakeLock); |
555 | 61.2k | ss->firstHandshakeLock = NULL; |
556 | 61.2k | } |
557 | 91.0k | if (ss->ssl3HandshakeLock) { |
558 | 61.2k | PR_DestroyMonitor(ss->ssl3HandshakeLock); |
559 | 61.2k | ss->ssl3HandshakeLock = NULL; |
560 | 61.2k | } |
561 | 91.0k | if (ss->specLock) { |
562 | 61.2k | NSSRWLock_Destroy(ss->specLock); |
563 | 61.2k | ss->specLock = NULL; |
564 | 61.2k | } |
565 | | |
566 | 91.0k | if (ss->recvLock) { |
567 | 61.2k | PR_DestroyLock(ss->recvLock); |
568 | 61.2k | ss->recvLock = NULL; |
569 | 61.2k | } |
570 | 91.0k | if (ss->sendLock) { |
571 | 61.2k | PR_DestroyLock(ss->sendLock); |
572 | 61.2k | ss->sendLock = NULL; |
573 | 61.2k | } |
574 | 91.0k | if (ss->xmitBufLock) { |
575 | 61.2k | PR_DestroyMonitor(ss->xmitBufLock); |
576 | 61.2k | ss->xmitBufLock = NULL; |
577 | 61.2k | } |
578 | 91.0k | if (ss->recvBufLock) { |
579 | 61.2k | PR_DestroyMonitor(ss->recvBufLock); |
580 | 61.2k | ss->recvBufLock = NULL; |
581 | 61.2k | } |
582 | 91.0k | } |
583 | | |
584 | | /* Caller holds any relevant locks */ |
585 | | static void |
586 | | ssl_DestroySocketContents(sslSocket *ss) |
587 | 61.2k | { |
588 | 61.2k | PRCList *cursor; |
589 | | |
590 | | /* Free up socket */ |
591 | 61.2k | ssl_DestroySecurityInfo(&ss->sec); |
592 | | |
593 | 61.2k | ssl3_DestroySSL3Info(ss); |
594 | | |
595 | 61.2k | PORT_Free(ss->saveBuf.buf); |
596 | 61.2k | PORT_Free(ss->pendingBuf.buf); |
597 | 61.2k | ssl3_DestroyGather(&ss->gs); |
598 | | |
599 | 61.2k | if (ss->peerID != NULL) |
600 | 0 | PORT_Free(ss->peerID); |
601 | 61.2k | if (ss->url != NULL) |
602 | 61.2k | PORT_Free((void *)ss->url); /* CONST */ |
603 | | |
604 | | /* Clean up server certificates and sundries. */ |
605 | 186k | while (!PR_CLIST_IS_EMPTY(&ss->serverCerts)) { |
606 | 124k | cursor = PR_LIST_TAIL(&ss->serverCerts); |
607 | 124k | PR_REMOVE_LINK(cursor); |
608 | 124k | ssl_FreeServerCert((sslServerCert *)cursor); |
609 | 124k | } |
610 | | |
611 | | /* Remove extension handlers. */ |
612 | 61.2k | ssl_ClearPRCList(&ss->extensionHooks, NULL); |
613 | | |
614 | 61.2k | ssl_FreeEphemeralKeyPairs(ss); |
615 | 61.2k | SECITEM_FreeItem(&ss->opt.nextProtoNego, PR_FALSE); |
616 | 61.2k | ssl3_FreeSniNameArray(&ss->xtnData); |
617 | | |
618 | 61.2k | ssl_ClearPRCList(&ss->ssl3.hs.dtlsSentHandshake, NULL); |
619 | 61.2k | ssl_ClearPRCList(&ss->ssl3.hs.dtlsRcvdHandshake, NULL); |
620 | 61.2k | tls13_DestroyPskList(&ss->ssl3.hs.psks); |
621 | | |
622 | 61.2k | tls13_ReleaseAntiReplayContext(ss->antiReplay); |
623 | | |
624 | 61.2k | tls13_DestroyPsk(ss->psk); |
625 | | |
626 | 61.2k | tls13_DestroyEchConfigs(&ss->echConfigs); |
627 | 61.2k | SECKEY_DestroyPrivateKey(ss->echPrivKey); |
628 | 61.2k | SECKEY_DestroyPublicKey(ss->echPubKey); |
629 | 61.2k | } |
630 | | |
631 | | /* |
632 | | * free an sslSocket struct, and all the stuff that hangs off of it |
633 | | */ |
634 | | void |
635 | | ssl_FreeSocket(sslSocket *ss) |
636 | 61.2k | { |
637 | | /* Get every lock you can imagine! |
638 | | ** Caller already holds these: |
639 | | ** SSL_LOCK_READER(ss); |
640 | | ** SSL_LOCK_WRITER(ss); |
641 | | */ |
642 | 61.2k | ssl_Get1stHandshakeLock(ss); |
643 | 61.2k | ssl_GetRecvBufLock(ss); |
644 | 61.2k | ssl_GetSSL3HandshakeLock(ss); |
645 | 61.2k | ssl_GetXmitBufLock(ss); |
646 | 61.2k | ssl_GetSpecWriteLock(ss); |
647 | | |
648 | 61.2k | ssl_DestroySocketContents(ss); |
649 | | |
650 | | /* Release all the locks acquired above. */ |
651 | 61.2k | SSL_UNLOCK_READER(ss); |
652 | 61.2k | SSL_UNLOCK_WRITER(ss); |
653 | 61.2k | ssl_Release1stHandshakeLock(ss); |
654 | 61.2k | ssl_ReleaseRecvBufLock(ss); |
655 | 61.2k | ssl_ReleaseSSL3HandshakeLock(ss); |
656 | 61.2k | ssl_ReleaseXmitBufLock(ss); |
657 | 61.2k | ssl_ReleaseSpecWriteLock(ss); |
658 | | |
659 | 61.2k | ssl_DestroyLocks(ss); |
660 | | |
661 | 61.2k | #ifdef DEBUG |
662 | 61.2k | PORT_Memset(ss, 0x1f, sizeof *ss); |
663 | 61.2k | #endif |
664 | 61.2k | PORT_Free(ss); |
665 | 61.2k | return; |
666 | 61.2k | } |
667 | | |
668 | | /************************************************************************/ |
669 | | SECStatus |
670 | | ssl_EnableNagleDelay(sslSocket *ss, PRBool enabled) |
671 | 4.70k | { |
672 | 4.70k | PRFileDesc *osfd = ss->fd->lower; |
673 | 4.70k | SECStatus rv = SECFailure; |
674 | 4.70k | PRSocketOptionData opt; |
675 | | |
676 | 4.70k | opt.option = PR_SockOpt_NoDelay; |
677 | 4.70k | opt.value.no_delay = (PRBool)!enabled; |
678 | | |
679 | 4.70k | if (osfd->methods->setsocketoption) { |
680 | 4.70k | rv = (SECStatus)osfd->methods->setsocketoption(osfd, &opt); |
681 | 4.70k | } else { |
682 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
683 | 0 | } |
684 | | |
685 | 4.70k | return rv; |
686 | 4.70k | } |
687 | | |
688 | | static void |
689 | | ssl_ChooseOps(sslSocket *ss) |
690 | 61.2k | { |
691 | 61.2k | ss->ops = ss->opt.useSecurity ? &ssl_secure_ops : &ssl_default_ops; |
692 | 61.2k | } |
693 | | |
694 | | /* Called from SSL_Enable (immediately below) */ |
695 | | static SECStatus |
696 | | PrepareSocket(sslSocket *ss) |
697 | 0 | { |
698 | 0 | SECStatus rv = SECSuccess; |
699 | |
|
700 | 0 | ssl_ChooseOps(ss); |
701 | 0 | return rv; |
702 | 0 | } |
703 | | |
704 | | SECStatus |
705 | | SSL_Enable(PRFileDesc *fd, int which, PRIntn on) |
706 | 0 | { |
707 | 0 | return SSL_OptionSet(fd, which, on); |
708 | 0 | } |
709 | | |
710 | | static PRBool ssl_VersionIsSupportedByPolicy( |
711 | | SSLProtocolVariant protocolVariant, SSL3ProtocolVersion version); |
712 | | |
713 | | /* Implements the semantics for SSL_OptionSet(SSL_ENABLE_TLS, on) described in |
714 | | * ssl.h in the section "SSL version range setting API". |
715 | | */ |
716 | | static void |
717 | | ssl_EnableTLS(SSLVersionRange *vrange, PRIntn enable) |
718 | 0 | { |
719 | 0 | if (enable) { |
720 | | /* don't turn it on if tls1.0 disallowed by by policy */ |
721 | 0 | if (!ssl_VersionIsSupportedByPolicy(ssl_variant_stream, |
722 | 0 | SSL_LIBRARY_VERSION_TLS_1_0)) { |
723 | 0 | return; |
724 | 0 | } |
725 | 0 | } |
726 | 0 | if (SSL_ALL_VERSIONS_DISABLED(vrange)) { |
727 | 0 | if (enable) { |
728 | 0 | vrange->min = SSL_LIBRARY_VERSION_TLS_1_0; |
729 | 0 | vrange->max = SSL_LIBRARY_VERSION_TLS_1_0; |
730 | 0 | } /* else don't change anything */ |
731 | 0 | return; |
732 | 0 | } |
733 | | |
734 | 0 | if (enable) { |
735 | | /* Expand the range of enabled version to include TLS 1.0 */ |
736 | 0 | vrange->min = PR_MIN(vrange->min, SSL_LIBRARY_VERSION_TLS_1_0); |
737 | 0 | vrange->max = PR_MAX(vrange->max, SSL_LIBRARY_VERSION_TLS_1_0); |
738 | 0 | } else { |
739 | | /* Disable all TLS versions, leaving only SSL 3.0 if it was enabled */ |
740 | 0 | if (vrange->min == SSL_LIBRARY_VERSION_3_0) { |
741 | 0 | vrange->max = SSL_LIBRARY_VERSION_3_0; |
742 | 0 | } else { |
743 | | /* Only TLS was enabled, so now no versions are. */ |
744 | 0 | vrange->min = SSL_LIBRARY_VERSION_NONE; |
745 | 0 | vrange->max = SSL_LIBRARY_VERSION_NONE; |
746 | 0 | } |
747 | 0 | } |
748 | 0 | } |
749 | | |
750 | | /* Implements the semantics for SSL_OptionSet(SSL_ENABLE_SSL3, on) described in |
751 | | * ssl.h in the section "SSL version range setting API". |
752 | | */ |
753 | | static void |
754 | | ssl_EnableSSL3(SSLVersionRange *vrange, PRIntn enable) |
755 | 0 | { |
756 | 0 | if (enable) { |
757 | | /* don't turn it on if ssl3 disallowed by by policy */ |
758 | 0 | if (!ssl_VersionIsSupportedByPolicy(ssl_variant_stream, |
759 | 0 | SSL_LIBRARY_VERSION_3_0)) { |
760 | 0 | return; |
761 | 0 | } |
762 | 0 | } |
763 | 0 | if (SSL_ALL_VERSIONS_DISABLED(vrange)) { |
764 | 0 | if (enable) { |
765 | 0 | vrange->min = SSL_LIBRARY_VERSION_3_0; |
766 | 0 | vrange->max = SSL_LIBRARY_VERSION_3_0; |
767 | 0 | } /* else don't change anything */ |
768 | 0 | return; |
769 | 0 | } |
770 | | |
771 | 0 | if (enable) { |
772 | | /* Expand the range of enabled versions to include SSL 3.0. We know |
773 | | * SSL 3.0 or some version of TLS is already enabled at this point, so |
774 | | * we don't need to change vrange->max. |
775 | | */ |
776 | 0 | vrange->min = SSL_LIBRARY_VERSION_3_0; |
777 | 0 | } else { |
778 | | /* Disable SSL 3.0, leaving TLS unaffected. */ |
779 | 0 | if (vrange->max > SSL_LIBRARY_VERSION_3_0) { |
780 | 0 | vrange->min = PR_MAX(vrange->min, SSL_LIBRARY_VERSION_TLS_1_0); |
781 | 0 | } else { |
782 | | /* Only SSL 3.0 was enabled, so now no versions are. */ |
783 | 0 | vrange->min = SSL_LIBRARY_VERSION_NONE; |
784 | 0 | vrange->max = SSL_LIBRARY_VERSION_NONE; |
785 | 0 | } |
786 | 0 | } |
787 | 0 | } |
788 | | |
789 | | SECStatus |
790 | | SSL_OptionSet(PRFileDesc *fd, PRInt32 which, PRIntn val) |
791 | 1.28M | { |
792 | 1.28M | sslSocket *ss = ssl_FindSocket(fd); |
793 | 1.28M | SECStatus rv = SECSuccess; |
794 | 1.28M | PRBool holdingLocks; |
795 | | |
796 | 1.28M | if (!ss) { |
797 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in Enable", SSL_GETPID(), fd)); |
798 | 0 | return SECFailure; |
799 | 0 | } |
800 | | |
801 | 1.28M | holdingLocks = (!ss->opt.noLocks); |
802 | 1.28M | ssl_Get1stHandshakeLock(ss); |
803 | 1.28M | ssl_GetSSL3HandshakeLock(ss); |
804 | | |
805 | 1.28M | switch (which) { |
806 | 0 | case SSL_SOCKS: |
807 | 0 | ss->opt.useSocks = PR_FALSE; |
808 | 0 | rv = PrepareSocket(ss); |
809 | 0 | if (val) { |
810 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
811 | 0 | rv = SECFailure; |
812 | 0 | } |
813 | 0 | break; |
814 | | |
815 | 0 | case SSL_SECURITY: |
816 | 0 | ss->opt.useSecurity = val; |
817 | 0 | rv = PrepareSocket(ss); |
818 | 0 | break; |
819 | | |
820 | 31.2k | case SSL_REQUEST_CERTIFICATE: |
821 | 31.2k | ss->opt.requestCertificate = val; |
822 | 31.2k | break; |
823 | | |
824 | 31.2k | case SSL_REQUIRE_CERTIFICATE: |
825 | 31.2k | ss->opt.requireCertificate = val; |
826 | 31.2k | break; |
827 | | |
828 | 0 | case SSL_HANDSHAKE_AS_CLIENT: |
829 | 0 | if (ss->opt.handshakeAsServer && val) { |
830 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
831 | 0 | rv = SECFailure; |
832 | 0 | break; |
833 | 0 | } |
834 | 0 | ss->opt.handshakeAsClient = val; |
835 | 0 | break; |
836 | | |
837 | 0 | case SSL_HANDSHAKE_AS_SERVER: |
838 | 0 | if (ss->opt.handshakeAsClient && val) { |
839 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
840 | 0 | rv = SECFailure; |
841 | 0 | break; |
842 | 0 | } |
843 | 0 | ss->opt.handshakeAsServer = val; |
844 | 0 | break; |
845 | | |
846 | 0 | case SSL_ENABLE_TLS: |
847 | 0 | if (IS_DTLS(ss)) { |
848 | 0 | if (val) { |
849 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
850 | 0 | rv = SECFailure; /* not allowed */ |
851 | 0 | } |
852 | 0 | break; |
853 | 0 | } |
854 | 0 | ssl_EnableTLS(&ss->vrange, val); |
855 | 0 | break; |
856 | | |
857 | 0 | case SSL_ENABLE_SSL3: |
858 | 0 | if (IS_DTLS(ss)) { |
859 | 0 | if (val) { |
860 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
861 | 0 | rv = SECFailure; /* not allowed */ |
862 | 0 | } |
863 | 0 | break; |
864 | 0 | } |
865 | 0 | ssl_EnableSSL3(&ss->vrange, val); |
866 | 0 | break; |
867 | | |
868 | 0 | case SSL_ENABLE_SSL2: |
869 | 0 | case SSL_V2_COMPATIBLE_HELLO: |
870 | | /* We no longer support SSL v2. |
871 | | * However, if an old application requests to disable SSL v2, |
872 | | * we shouldn't fail. |
873 | | */ |
874 | 0 | if (val) { |
875 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
876 | 0 | rv = SECFailure; |
877 | 0 | } |
878 | 0 | break; |
879 | | |
880 | 61.2k | case SSL_NO_CACHE: |
881 | 61.2k | ss->opt.noCache = val; |
882 | 61.2k | break; |
883 | | |
884 | 0 | case SSL_ENABLE_FDX: |
885 | 0 | if (val && ss->opt.noLocks) { |
886 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
887 | 0 | rv = SECFailure; |
888 | 0 | } |
889 | 0 | ss->opt.fdx = val; |
890 | 0 | break; |
891 | | |
892 | 0 | case SSL_ROLLBACK_DETECTION: |
893 | 0 | ss->opt.detectRollBack = val; |
894 | 0 | break; |
895 | | |
896 | 0 | case SSL_NO_STEP_DOWN: |
897 | 0 | break; |
898 | | |
899 | 0 | case SSL_BYPASS_PKCS11: |
900 | 0 | break; |
901 | | |
902 | 61.2k | case SSL_NO_LOCKS: |
903 | 61.2k | if (val && ss->opt.fdx) { |
904 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
905 | 0 | rv = SECFailure; |
906 | 0 | } |
907 | 61.2k | if (val && ssl_force_locks) |
908 | 0 | val = PR_FALSE; /* silent override */ |
909 | 61.2k | ss->opt.noLocks = val; |
910 | | |
911 | 61.2k | if (val && holdingLocks) { |
912 | | /* If we're disabling locks and locks were previously enabled. */ |
913 | 29.7k | PR_ExitMonitor((ss)->ssl3HandshakeLock); |
914 | 29.7k | PR_ExitMonitor((ss)->firstHandshakeLock); |
915 | 29.7k | ssl_DestroyLocks(ss); |
916 | 29.7k | holdingLocks = PR_FALSE; |
917 | 31.5k | } else if (!val && !holdingLocks) { |
918 | | /* If we're enabling locks and locks were previously disabled. */ |
919 | 0 | rv = ssl_MakeLocks(ss); |
920 | 0 | if (rv != SECSuccess) { |
921 | 0 | ss->opt.noLocks = PR_TRUE; |
922 | 0 | } |
923 | 0 | } |
924 | 61.2k | break; |
925 | | |
926 | 61.2k | case SSL_ENABLE_SESSION_TICKETS: |
927 | 61.2k | ss->opt.enableSessionTickets = val; |
928 | 61.2k | break; |
929 | | |
930 | 61.2k | case SSL_ENABLE_DEFLATE: |
931 | 61.2k | ss->opt.enableDeflate = val; |
932 | 61.2k | break; |
933 | | |
934 | 31.8k | case SSL_ENABLE_RENEGOTIATION: |
935 | 31.8k | if (IS_DTLS(ss) && val != SSL_RENEGOTIATE_NEVER) { |
936 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
937 | 0 | rv = SECFailure; |
938 | 0 | break; |
939 | 0 | } |
940 | 31.8k | ss->opt.enableRenegotiation = val; |
941 | 31.8k | break; |
942 | | |
943 | 61.2k | case SSL_REQUIRE_SAFE_NEGOTIATION: |
944 | 61.2k | ss->opt.requireSafeNegotiation = val; |
945 | 61.2k | break; |
946 | | |
947 | 30.0k | case SSL_ENABLE_FALSE_START: |
948 | 30.0k | ss->opt.enableFalseStart = val; |
949 | 30.0k | break; |
950 | | |
951 | 61.2k | case SSL_CBC_RANDOM_IV: |
952 | 61.2k | ss->opt.cbcRandomIV = val; |
953 | 61.2k | break; |
954 | | |
955 | 61.2k | case SSL_ENABLE_OCSP_STAPLING: |
956 | 61.2k | ss->opt.enableOCSPStapling = val; |
957 | 61.2k | break; |
958 | | |
959 | 61.2k | case SSL_ENABLE_DELEGATED_CREDENTIALS: |
960 | 61.2k | ss->opt.enableDelegatedCredentials = val; |
961 | 61.2k | break; |
962 | | |
963 | 0 | case SSL_ENABLE_NPN: |
964 | 0 | break; |
965 | | |
966 | 61.2k | case SSL_ENABLE_ALPN: |
967 | 61.2k | ss->opt.enableALPN = val; |
968 | 61.2k | break; |
969 | | |
970 | 0 | case SSL_REUSE_SERVER_ECDHE_KEY: |
971 | 0 | ss->opt.reuseServerECDHEKey = val; |
972 | 0 | break; |
973 | | |
974 | 61.2k | case SSL_ENABLE_FALLBACK_SCSV: |
975 | 61.2k | ss->opt.enableFallbackSCSV = val; |
976 | 61.2k | break; |
977 | | |
978 | 0 | case SSL_ENABLE_SERVER_DHE: |
979 | 0 | ss->opt.enableServerDhe = val; |
980 | 0 | break; |
981 | | |
982 | 61.2k | case SSL_ENABLE_EXTENDED_MASTER_SECRET: |
983 | 61.2k | ss->opt.enableExtendedMS = val; |
984 | 61.2k | break; |
985 | | |
986 | 61.2k | case SSL_ENABLE_SIGNED_CERT_TIMESTAMPS: |
987 | 61.2k | ss->opt.enableSignedCertTimestamps = val; |
988 | 61.2k | break; |
989 | | |
990 | 61.2k | case SSL_REQUIRE_DH_NAMED_GROUPS: |
991 | 61.2k | ss->opt.requireDHENamedGroups = val; |
992 | 61.2k | break; |
993 | | |
994 | 61.2k | case SSL_ENABLE_0RTT_DATA: |
995 | 61.2k | ss->opt.enable0RttData = val; |
996 | 61.2k | break; |
997 | | |
998 | 28.8k | case SSL_RECORD_SIZE_LIMIT: |
999 | 28.8k | if (val < 64 || val > (MAX_FRAGMENT_LENGTH + 1)) { |
1000 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1001 | 0 | rv = SECFailure; |
1002 | 28.8k | } else { |
1003 | 28.8k | ss->opt.recordSizeLimit = val; |
1004 | 28.8k | } |
1005 | 28.8k | break; |
1006 | | |
1007 | 61.2k | case SSL_ENABLE_TLS13_COMPAT_MODE: |
1008 | 61.2k | ss->opt.enableTls13CompatMode = val; |
1009 | 61.2k | break; |
1010 | | |
1011 | 61.2k | case SSL_ENABLE_DTLS_SHORT_HEADER: |
1012 | 61.2k | ss->opt.enableDtlsShortHeader = val; |
1013 | 61.2k | break; |
1014 | | |
1015 | 0 | case SSL_ENABLE_HELLO_DOWNGRADE_CHECK: |
1016 | 0 | ss->opt.enableHelloDowngradeCheck = val; |
1017 | 0 | break; |
1018 | | |
1019 | 0 | case SSL_ENABLE_V2_COMPATIBLE_HELLO: |
1020 | 0 | ss->opt.enableV2CompatibleHello = val; |
1021 | 0 | break; |
1022 | | |
1023 | 61.2k | case SSL_ENABLE_POST_HANDSHAKE_AUTH: |
1024 | 61.2k | ss->opt.enablePostHandshakeAuth = val; |
1025 | 61.2k | break; |
1026 | | |
1027 | 0 | case SSL_SUPPRESS_END_OF_EARLY_DATA: |
1028 | | /* DTLS has no EndOfEarlyData to suppress (RFC 9147, Section 5.6). */ |
1029 | 0 | if (IS_DTLS(ss) && val) { |
1030 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1031 | 0 | rv = SECFailure; |
1032 | 0 | break; |
1033 | 0 | } |
1034 | 0 | ss->opt.suppressEndOfEarlyData = val; |
1035 | 0 | break; |
1036 | | |
1037 | 61.2k | case SSL_ENABLE_GREASE: |
1038 | 61.2k | ss->opt.enableGrease = val; |
1039 | 61.2k | break; |
1040 | | |
1041 | 30.0k | case SSL_ENABLE_CH_EXTENSION_PERMUTATION: |
1042 | 30.0k | ss->opt.enableChXtnPermutation = val; |
1043 | 30.0k | break; |
1044 | | |
1045 | 0 | case SSL_DB_LOAD_CERTIFICATE_CHAIN: |
1046 | 0 | ss->opt.dbLoadCertChain = val; |
1047 | 0 | break; |
1048 | | |
1049 | 0 | default: |
1050 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1051 | 0 | rv = SECFailure; |
1052 | 1.28M | } |
1053 | | |
1054 | | /* We can't use the macros for releasing the locks here, |
1055 | | * because ss->opt.noLocks might have changed just above. |
1056 | | * We must release these locks (monitors) here, if we aquired them above, |
1057 | | * regardless of the current value of ss->opt.noLocks. |
1058 | | */ |
1059 | 1.28M | if (holdingLocks) { |
1060 | 1.07M | PR_ExitMonitor((ss)->ssl3HandshakeLock); |
1061 | 1.07M | PR_ExitMonitor((ss)->firstHandshakeLock); |
1062 | 1.07M | } |
1063 | | |
1064 | 1.28M | return rv; |
1065 | 1.28M | } |
1066 | | |
1067 | | SECStatus |
1068 | | SSL_OptionGet(PRFileDesc *fd, PRInt32 which, PRIntn *pVal) |
1069 | 0 | { |
1070 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
1071 | 0 | SECStatus rv = SECSuccess; |
1072 | 0 | PRIntn val = PR_FALSE; |
1073 | |
|
1074 | 0 | if (!pVal) { |
1075 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1076 | 0 | return SECFailure; |
1077 | 0 | } |
1078 | 0 | if (!ss) { |
1079 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in Enable", SSL_GETPID(), fd)); |
1080 | 0 | *pVal = PR_FALSE; |
1081 | 0 | return SECFailure; |
1082 | 0 | } |
1083 | | |
1084 | 0 | ssl_Get1stHandshakeLock(ss); |
1085 | 0 | ssl_GetSSL3HandshakeLock(ss); |
1086 | |
|
1087 | 0 | switch (which) { |
1088 | 0 | case SSL_SOCKS: |
1089 | 0 | val = PR_FALSE; |
1090 | 0 | break; |
1091 | 0 | case SSL_SECURITY: |
1092 | 0 | val = ss->opt.useSecurity; |
1093 | 0 | break; |
1094 | 0 | case SSL_REQUEST_CERTIFICATE: |
1095 | 0 | val = ss->opt.requestCertificate; |
1096 | 0 | break; |
1097 | 0 | case SSL_REQUIRE_CERTIFICATE: |
1098 | 0 | val = ss->opt.requireCertificate; |
1099 | 0 | break; |
1100 | 0 | case SSL_HANDSHAKE_AS_CLIENT: |
1101 | 0 | val = ss->opt.handshakeAsClient; |
1102 | 0 | break; |
1103 | 0 | case SSL_HANDSHAKE_AS_SERVER: |
1104 | 0 | val = ss->opt.handshakeAsServer; |
1105 | 0 | break; |
1106 | 0 | case SSL_ENABLE_TLS: |
1107 | 0 | val = ss->vrange.max >= SSL_LIBRARY_VERSION_TLS_1_0; |
1108 | 0 | break; |
1109 | 0 | case SSL_ENABLE_SSL3: |
1110 | 0 | val = ss->vrange.min == SSL_LIBRARY_VERSION_3_0; |
1111 | 0 | break; |
1112 | 0 | case SSL_ENABLE_SSL2: |
1113 | 0 | case SSL_V2_COMPATIBLE_HELLO: |
1114 | 0 | val = PR_FALSE; |
1115 | 0 | break; |
1116 | 0 | case SSL_NO_CACHE: |
1117 | 0 | val = ss->opt.noCache; |
1118 | 0 | break; |
1119 | 0 | case SSL_ENABLE_FDX: |
1120 | 0 | val = ss->opt.fdx; |
1121 | 0 | break; |
1122 | 0 | case SSL_ROLLBACK_DETECTION: |
1123 | 0 | val = ss->opt.detectRollBack; |
1124 | 0 | break; |
1125 | 0 | case SSL_NO_STEP_DOWN: |
1126 | 0 | val = PR_FALSE; |
1127 | 0 | break; |
1128 | 0 | case SSL_BYPASS_PKCS11: |
1129 | 0 | val = PR_FALSE; |
1130 | 0 | break; |
1131 | 0 | case SSL_NO_LOCKS: |
1132 | 0 | val = ss->opt.noLocks; |
1133 | 0 | break; |
1134 | 0 | case SSL_ENABLE_SESSION_TICKETS: |
1135 | 0 | val = ss->opt.enableSessionTickets; |
1136 | 0 | break; |
1137 | 0 | case SSL_ENABLE_DEFLATE: |
1138 | 0 | val = ss->opt.enableDeflate; |
1139 | 0 | break; |
1140 | 0 | case SSL_ENABLE_RENEGOTIATION: |
1141 | 0 | val = ss->opt.enableRenegotiation; |
1142 | 0 | break; |
1143 | 0 | case SSL_REQUIRE_SAFE_NEGOTIATION: |
1144 | 0 | val = ss->opt.requireSafeNegotiation; |
1145 | 0 | break; |
1146 | 0 | case SSL_ENABLE_FALSE_START: |
1147 | 0 | val = ss->opt.enableFalseStart; |
1148 | 0 | break; |
1149 | 0 | case SSL_CBC_RANDOM_IV: |
1150 | 0 | val = ss->opt.cbcRandomIV; |
1151 | 0 | break; |
1152 | 0 | case SSL_ENABLE_OCSP_STAPLING: |
1153 | 0 | val = ss->opt.enableOCSPStapling; |
1154 | 0 | break; |
1155 | 0 | case SSL_ENABLE_DELEGATED_CREDENTIALS: |
1156 | 0 | val = ss->opt.enableDelegatedCredentials; |
1157 | 0 | break; |
1158 | 0 | case SSL_ENABLE_NPN: |
1159 | 0 | val = PR_FALSE; |
1160 | 0 | break; |
1161 | 0 | case SSL_ENABLE_ALPN: |
1162 | 0 | val = ss->opt.enableALPN; |
1163 | 0 | break; |
1164 | 0 | case SSL_REUSE_SERVER_ECDHE_KEY: |
1165 | 0 | val = ss->opt.reuseServerECDHEKey; |
1166 | 0 | break; |
1167 | 0 | case SSL_ENABLE_FALLBACK_SCSV: |
1168 | 0 | val = ss->opt.enableFallbackSCSV; |
1169 | 0 | break; |
1170 | 0 | case SSL_ENABLE_SERVER_DHE: |
1171 | 0 | val = ss->opt.enableServerDhe; |
1172 | 0 | break; |
1173 | 0 | case SSL_ENABLE_EXTENDED_MASTER_SECRET: |
1174 | 0 | val = ss->opt.enableExtendedMS; |
1175 | 0 | break; |
1176 | 0 | case SSL_ENABLE_SIGNED_CERT_TIMESTAMPS: |
1177 | 0 | val = ss->opt.enableSignedCertTimestamps; |
1178 | 0 | break; |
1179 | 0 | case SSL_REQUIRE_DH_NAMED_GROUPS: |
1180 | 0 | val = ss->opt.requireDHENamedGroups; |
1181 | 0 | break; |
1182 | 0 | case SSL_ENABLE_0RTT_DATA: |
1183 | 0 | val = ss->opt.enable0RttData; |
1184 | 0 | break; |
1185 | 0 | case SSL_RECORD_SIZE_LIMIT: |
1186 | 0 | val = ss->opt.recordSizeLimit; |
1187 | 0 | break; |
1188 | 0 | case SSL_ENABLE_TLS13_COMPAT_MODE: |
1189 | 0 | val = ss->opt.enableTls13CompatMode; |
1190 | 0 | break; |
1191 | 0 | case SSL_ENABLE_DTLS_SHORT_HEADER: |
1192 | 0 | val = ss->opt.enableDtlsShortHeader; |
1193 | 0 | break; |
1194 | 0 | case SSL_ENABLE_HELLO_DOWNGRADE_CHECK: |
1195 | 0 | val = ss->opt.enableHelloDowngradeCheck; |
1196 | 0 | break; |
1197 | 0 | case SSL_ENABLE_V2_COMPATIBLE_HELLO: |
1198 | 0 | val = ss->opt.enableV2CompatibleHello; |
1199 | 0 | break; |
1200 | 0 | case SSL_ENABLE_POST_HANDSHAKE_AUTH: |
1201 | 0 | val = ss->opt.enablePostHandshakeAuth; |
1202 | 0 | break; |
1203 | 0 | case SSL_SUPPRESS_END_OF_EARLY_DATA: |
1204 | 0 | val = ss->opt.suppressEndOfEarlyData; |
1205 | 0 | break; |
1206 | 0 | case SSL_ENABLE_GREASE: |
1207 | 0 | val = ss->opt.enableGrease; |
1208 | 0 | break; |
1209 | 0 | case SSL_ENABLE_CH_EXTENSION_PERMUTATION: |
1210 | 0 | val = ss->opt.enableChXtnPermutation; |
1211 | 0 | break; |
1212 | 0 | case SSL_DB_LOAD_CERTIFICATE_CHAIN: |
1213 | 0 | val = ss->opt.dbLoadCertChain; |
1214 | 0 | break; |
1215 | 0 | default: |
1216 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1217 | 0 | rv = SECFailure; |
1218 | 0 | } |
1219 | | |
1220 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
1221 | 0 | ssl_Release1stHandshakeLock(ss); |
1222 | |
|
1223 | 0 | *pVal = val; |
1224 | 0 | return rv; |
1225 | 0 | } |
1226 | | |
1227 | | SECStatus |
1228 | | SSL_OptionGetDefault(PRInt32 which, PRIntn *pVal) |
1229 | 0 | { |
1230 | 0 | SECStatus rv = SECSuccess; |
1231 | 0 | PRIntn val = PR_FALSE; |
1232 | |
|
1233 | 0 | if (!pVal) { |
1234 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1235 | 0 | return SECFailure; |
1236 | 0 | } |
1237 | | |
1238 | 0 | ssl_SetDefaultsFromEnvironment(); |
1239 | |
|
1240 | 0 | switch (which) { |
1241 | 0 | case SSL_SOCKS: |
1242 | 0 | val = PR_FALSE; |
1243 | 0 | break; |
1244 | 0 | case SSL_SECURITY: |
1245 | 0 | val = ssl_defaults.useSecurity; |
1246 | 0 | break; |
1247 | 0 | case SSL_REQUEST_CERTIFICATE: |
1248 | 0 | val = ssl_defaults.requestCertificate; |
1249 | 0 | break; |
1250 | 0 | case SSL_REQUIRE_CERTIFICATE: |
1251 | 0 | val = ssl_defaults.requireCertificate; |
1252 | 0 | break; |
1253 | 0 | case SSL_HANDSHAKE_AS_CLIENT: |
1254 | 0 | val = ssl_defaults.handshakeAsClient; |
1255 | 0 | break; |
1256 | 0 | case SSL_HANDSHAKE_AS_SERVER: |
1257 | 0 | val = ssl_defaults.handshakeAsServer; |
1258 | 0 | break; |
1259 | 0 | case SSL_ENABLE_TLS: |
1260 | 0 | val = versions_defaults_stream.max >= SSL_LIBRARY_VERSION_TLS_1_0; |
1261 | 0 | break; |
1262 | 0 | case SSL_ENABLE_SSL3: |
1263 | 0 | val = versions_defaults_stream.min == SSL_LIBRARY_VERSION_3_0; |
1264 | 0 | break; |
1265 | 0 | case SSL_ENABLE_SSL2: |
1266 | 0 | case SSL_V2_COMPATIBLE_HELLO: |
1267 | 0 | val = PR_FALSE; |
1268 | 0 | break; |
1269 | 0 | case SSL_NO_CACHE: |
1270 | 0 | val = ssl_defaults.noCache; |
1271 | 0 | break; |
1272 | 0 | case SSL_ENABLE_FDX: |
1273 | 0 | val = ssl_defaults.fdx; |
1274 | 0 | break; |
1275 | 0 | case SSL_ROLLBACK_DETECTION: |
1276 | 0 | val = ssl_defaults.detectRollBack; |
1277 | 0 | break; |
1278 | 0 | case SSL_NO_STEP_DOWN: |
1279 | 0 | val = PR_FALSE; |
1280 | 0 | break; |
1281 | 0 | case SSL_BYPASS_PKCS11: |
1282 | 0 | val = PR_FALSE; |
1283 | 0 | break; |
1284 | 0 | case SSL_NO_LOCKS: |
1285 | 0 | val = ssl_defaults.noLocks; |
1286 | 0 | break; |
1287 | 0 | case SSL_ENABLE_SESSION_TICKETS: |
1288 | 0 | val = ssl_defaults.enableSessionTickets; |
1289 | 0 | break; |
1290 | 0 | case SSL_ENABLE_DEFLATE: |
1291 | 0 | val = ssl_defaults.enableDeflate; |
1292 | 0 | break; |
1293 | 0 | case SSL_ENABLE_RENEGOTIATION: |
1294 | 0 | val = ssl_defaults.enableRenegotiation; |
1295 | 0 | break; |
1296 | 0 | case SSL_REQUIRE_SAFE_NEGOTIATION: |
1297 | 0 | val = ssl_defaults.requireSafeNegotiation; |
1298 | 0 | break; |
1299 | 0 | case SSL_ENABLE_FALSE_START: |
1300 | 0 | val = ssl_defaults.enableFalseStart; |
1301 | 0 | break; |
1302 | 0 | case SSL_CBC_RANDOM_IV: |
1303 | 0 | val = ssl_defaults.cbcRandomIV; |
1304 | 0 | break; |
1305 | 0 | case SSL_ENABLE_OCSP_STAPLING: |
1306 | 0 | val = ssl_defaults.enableOCSPStapling; |
1307 | 0 | break; |
1308 | 0 | case SSL_ENABLE_DELEGATED_CREDENTIALS: |
1309 | 0 | val = ssl_defaults.enableDelegatedCredentials; |
1310 | 0 | break; |
1311 | 0 | case SSL_ENABLE_NPN: |
1312 | 0 | val = PR_FALSE; |
1313 | 0 | break; |
1314 | 0 | case SSL_ENABLE_ALPN: |
1315 | 0 | val = ssl_defaults.enableALPN; |
1316 | 0 | break; |
1317 | 0 | case SSL_REUSE_SERVER_ECDHE_KEY: |
1318 | 0 | val = ssl_defaults.reuseServerECDHEKey; |
1319 | 0 | break; |
1320 | 0 | case SSL_ENABLE_FALLBACK_SCSV: |
1321 | 0 | val = ssl_defaults.enableFallbackSCSV; |
1322 | 0 | break; |
1323 | 0 | case SSL_ENABLE_SERVER_DHE: |
1324 | 0 | val = ssl_defaults.enableServerDhe; |
1325 | 0 | break; |
1326 | 0 | case SSL_ENABLE_EXTENDED_MASTER_SECRET: |
1327 | 0 | val = ssl_defaults.enableExtendedMS; |
1328 | 0 | break; |
1329 | 0 | case SSL_ENABLE_SIGNED_CERT_TIMESTAMPS: |
1330 | 0 | val = ssl_defaults.enableSignedCertTimestamps; |
1331 | 0 | break; |
1332 | 0 | case SSL_REQUIRE_DH_NAMED_GROUPS: |
1333 | 0 | val = ssl_defaults.requireDHENamedGroups; |
1334 | 0 | break; |
1335 | 0 | case SSL_ENABLE_0RTT_DATA: |
1336 | 0 | val = ssl_defaults.enable0RttData; |
1337 | 0 | break; |
1338 | 0 | case SSL_RECORD_SIZE_LIMIT: |
1339 | 0 | val = ssl_defaults.recordSizeLimit; |
1340 | 0 | break; |
1341 | 0 | case SSL_ENABLE_TLS13_COMPAT_MODE: |
1342 | 0 | val = ssl_defaults.enableTls13CompatMode; |
1343 | 0 | break; |
1344 | 0 | case SSL_ENABLE_DTLS_SHORT_HEADER: |
1345 | 0 | val = ssl_defaults.enableDtlsShortHeader; |
1346 | 0 | break; |
1347 | 0 | case SSL_ENABLE_HELLO_DOWNGRADE_CHECK: |
1348 | 0 | val = ssl_defaults.enableHelloDowngradeCheck; |
1349 | 0 | break; |
1350 | 0 | case SSL_ENABLE_V2_COMPATIBLE_HELLO: |
1351 | 0 | val = ssl_defaults.enableV2CompatibleHello; |
1352 | 0 | break; |
1353 | 0 | case SSL_ENABLE_POST_HANDSHAKE_AUTH: |
1354 | 0 | val = ssl_defaults.enablePostHandshakeAuth; |
1355 | 0 | break; |
1356 | 0 | case SSL_SUPPRESS_END_OF_EARLY_DATA: |
1357 | 0 | val = ssl_defaults.suppressEndOfEarlyData; |
1358 | 0 | break; |
1359 | 0 | case SSL_ENABLE_GREASE: |
1360 | 0 | val = ssl_defaults.enableGrease; |
1361 | 0 | break; |
1362 | 0 | case SSL_ENABLE_CH_EXTENSION_PERMUTATION: |
1363 | 0 | val = ssl_defaults.enableChXtnPermutation; |
1364 | 0 | break; |
1365 | 0 | case SSL_DB_LOAD_CERTIFICATE_CHAIN: |
1366 | 0 | val = ssl_defaults.dbLoadCertChain; |
1367 | 0 | break; |
1368 | 0 | default: |
1369 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1370 | 0 | rv = SECFailure; |
1371 | 0 | } |
1372 | | |
1373 | 0 | *pVal = val; |
1374 | 0 | return rv; |
1375 | 0 | } |
1376 | | |
1377 | | /* XXX Use Global Lock to protect this stuff. */ |
1378 | | SECStatus |
1379 | | SSL_EnableDefault(int which, PRIntn val) |
1380 | 0 | { |
1381 | 0 | return SSL_OptionSetDefault(which, val); |
1382 | 0 | } |
1383 | | |
1384 | | SECStatus |
1385 | | SSL_OptionSetDefault(PRInt32 which, PRIntn val) |
1386 | 0 | { |
1387 | 0 | SECStatus status = ssl_Init(); |
1388 | |
|
1389 | 0 | if (status != SECSuccess) { |
1390 | 0 | return status; |
1391 | 0 | } |
1392 | | |
1393 | 0 | ssl_SetDefaultsFromEnvironment(); |
1394 | |
|
1395 | 0 | switch (which) { |
1396 | 0 | case SSL_SOCKS: |
1397 | 0 | ssl_defaults.useSocks = PR_FALSE; |
1398 | 0 | if (val) { |
1399 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1400 | 0 | return SECFailure; |
1401 | 0 | } |
1402 | 0 | break; |
1403 | | |
1404 | 0 | case SSL_SECURITY: |
1405 | 0 | ssl_defaults.useSecurity = val; |
1406 | 0 | break; |
1407 | | |
1408 | 0 | case SSL_REQUEST_CERTIFICATE: |
1409 | 0 | ssl_defaults.requestCertificate = val; |
1410 | 0 | break; |
1411 | | |
1412 | 0 | case SSL_REQUIRE_CERTIFICATE: |
1413 | 0 | ssl_defaults.requireCertificate = val; |
1414 | 0 | break; |
1415 | | |
1416 | 0 | case SSL_HANDSHAKE_AS_CLIENT: |
1417 | 0 | if (ssl_defaults.handshakeAsServer && val) { |
1418 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1419 | 0 | return SECFailure; |
1420 | 0 | } |
1421 | 0 | ssl_defaults.handshakeAsClient = val; |
1422 | 0 | break; |
1423 | | |
1424 | 0 | case SSL_HANDSHAKE_AS_SERVER: |
1425 | 0 | if (ssl_defaults.handshakeAsClient && val) { |
1426 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1427 | 0 | return SECFailure; |
1428 | 0 | } |
1429 | 0 | ssl_defaults.handshakeAsServer = val; |
1430 | 0 | break; |
1431 | | |
1432 | 0 | case SSL_ENABLE_TLS: |
1433 | 0 | ssl_EnableTLS(&versions_defaults_stream, val); |
1434 | 0 | break; |
1435 | | |
1436 | 0 | case SSL_ENABLE_SSL3: |
1437 | 0 | ssl_EnableSSL3(&versions_defaults_stream, val); |
1438 | 0 | break; |
1439 | | |
1440 | 0 | case SSL_ENABLE_SSL2: |
1441 | 0 | case SSL_V2_COMPATIBLE_HELLO: |
1442 | | /* We no longer support SSL v2. |
1443 | | * However, if an old application requests to disable SSL v2, |
1444 | | * we shouldn't fail. |
1445 | | */ |
1446 | 0 | if (val) { |
1447 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1448 | 0 | return SECFailure; |
1449 | 0 | } |
1450 | 0 | break; |
1451 | | |
1452 | 0 | case SSL_NO_CACHE: |
1453 | 0 | ssl_defaults.noCache = val; |
1454 | 0 | break; |
1455 | | |
1456 | 0 | case SSL_ENABLE_FDX: |
1457 | 0 | if (val && ssl_defaults.noLocks) { |
1458 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1459 | 0 | return SECFailure; |
1460 | 0 | } |
1461 | 0 | ssl_defaults.fdx = val; |
1462 | 0 | break; |
1463 | | |
1464 | 0 | case SSL_ROLLBACK_DETECTION: |
1465 | 0 | ssl_defaults.detectRollBack = val; |
1466 | 0 | break; |
1467 | | |
1468 | 0 | case SSL_NO_STEP_DOWN: |
1469 | 0 | break; |
1470 | | |
1471 | 0 | case SSL_BYPASS_PKCS11: |
1472 | 0 | break; |
1473 | | |
1474 | 0 | case SSL_NO_LOCKS: |
1475 | 0 | if (val && ssl_defaults.fdx) { |
1476 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1477 | 0 | return SECFailure; |
1478 | 0 | } |
1479 | 0 | if (val && ssl_force_locks) |
1480 | 0 | val = PR_FALSE; /* silent override */ |
1481 | 0 | ssl_defaults.noLocks = val; |
1482 | 0 | break; |
1483 | | |
1484 | 0 | case SSL_ENABLE_SESSION_TICKETS: |
1485 | 0 | ssl_defaults.enableSessionTickets = val; |
1486 | 0 | break; |
1487 | | |
1488 | 0 | case SSL_ENABLE_DEFLATE: |
1489 | 0 | ssl_defaults.enableDeflate = val; |
1490 | 0 | break; |
1491 | | |
1492 | 0 | case SSL_ENABLE_RENEGOTIATION: |
1493 | 0 | ssl_defaults.enableRenegotiation = val; |
1494 | 0 | break; |
1495 | | |
1496 | 0 | case SSL_REQUIRE_SAFE_NEGOTIATION: |
1497 | 0 | ssl_defaults.requireSafeNegotiation = val; |
1498 | 0 | break; |
1499 | | |
1500 | 0 | case SSL_ENABLE_FALSE_START: |
1501 | 0 | ssl_defaults.enableFalseStart = val; |
1502 | 0 | break; |
1503 | | |
1504 | 0 | case SSL_CBC_RANDOM_IV: |
1505 | 0 | ssl_defaults.cbcRandomIV = val; |
1506 | 0 | break; |
1507 | | |
1508 | 0 | case SSL_ENABLE_OCSP_STAPLING: |
1509 | 0 | ssl_defaults.enableOCSPStapling = val; |
1510 | 0 | break; |
1511 | | |
1512 | 0 | case SSL_ENABLE_DELEGATED_CREDENTIALS: |
1513 | 0 | ssl_defaults.enableDelegatedCredentials = val; |
1514 | 0 | break; |
1515 | | |
1516 | 0 | case SSL_ENABLE_NPN: |
1517 | 0 | break; |
1518 | | |
1519 | 0 | case SSL_ENABLE_ALPN: |
1520 | 0 | ssl_defaults.enableALPN = val; |
1521 | 0 | break; |
1522 | | |
1523 | 0 | case SSL_REUSE_SERVER_ECDHE_KEY: |
1524 | 0 | ssl_defaults.reuseServerECDHEKey = val; |
1525 | 0 | break; |
1526 | | |
1527 | 0 | case SSL_ENABLE_FALLBACK_SCSV: |
1528 | 0 | ssl_defaults.enableFallbackSCSV = val; |
1529 | 0 | break; |
1530 | | |
1531 | 0 | case SSL_ENABLE_SERVER_DHE: |
1532 | 0 | ssl_defaults.enableServerDhe = val; |
1533 | 0 | break; |
1534 | | |
1535 | 0 | case SSL_ENABLE_EXTENDED_MASTER_SECRET: |
1536 | 0 | ssl_defaults.enableExtendedMS = val; |
1537 | 0 | break; |
1538 | | |
1539 | 0 | case SSL_ENABLE_SIGNED_CERT_TIMESTAMPS: |
1540 | 0 | ssl_defaults.enableSignedCertTimestamps = val; |
1541 | 0 | break; |
1542 | 0 | case SSL_REQUIRE_DH_NAMED_GROUPS: |
1543 | 0 | ssl_defaults.requireDHENamedGroups = val; |
1544 | 0 | break; |
1545 | 0 | case SSL_ENABLE_0RTT_DATA: |
1546 | 0 | ssl_defaults.enable0RttData = val; |
1547 | 0 | break; |
1548 | | |
1549 | 0 | case SSL_RECORD_SIZE_LIMIT: |
1550 | 0 | if (val < 64 || val > (MAX_FRAGMENT_LENGTH + 1)) { |
1551 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1552 | 0 | return SECFailure; |
1553 | 0 | } |
1554 | 0 | ssl_defaults.recordSizeLimit = val; |
1555 | 0 | break; |
1556 | | |
1557 | 0 | case SSL_ENABLE_TLS13_COMPAT_MODE: |
1558 | 0 | ssl_defaults.enableTls13CompatMode = val; |
1559 | 0 | break; |
1560 | | |
1561 | 0 | case SSL_ENABLE_DTLS_SHORT_HEADER: |
1562 | 0 | ssl_defaults.enableDtlsShortHeader = val; |
1563 | 0 | break; |
1564 | | |
1565 | 0 | case SSL_ENABLE_HELLO_DOWNGRADE_CHECK: |
1566 | 0 | ssl_defaults.enableHelloDowngradeCheck = val; |
1567 | 0 | break; |
1568 | | |
1569 | 0 | case SSL_ENABLE_V2_COMPATIBLE_HELLO: |
1570 | 0 | ssl_defaults.enableV2CompatibleHello = val; |
1571 | 0 | break; |
1572 | | |
1573 | 0 | case SSL_ENABLE_POST_HANDSHAKE_AUTH: |
1574 | 0 | ssl_defaults.enablePostHandshakeAuth = val; |
1575 | 0 | break; |
1576 | | |
1577 | 0 | case SSL_SUPPRESS_END_OF_EARLY_DATA: |
1578 | 0 | ssl_defaults.suppressEndOfEarlyData = val; |
1579 | 0 | break; |
1580 | 0 | case SSL_ENABLE_GREASE: |
1581 | 0 | ssl_defaults.enableGrease = val; |
1582 | 0 | break; |
1583 | 0 | case SSL_ENABLE_CH_EXTENSION_PERMUTATION: |
1584 | 0 | ssl_defaults.enableChXtnPermutation = val; |
1585 | 0 | break; |
1586 | 0 | case SSL_DB_LOAD_CERTIFICATE_CHAIN: |
1587 | 0 | ssl_defaults.dbLoadCertChain = val; |
1588 | 0 | break; |
1589 | 0 | default: |
1590 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1591 | 0 | return SECFailure; |
1592 | 0 | } |
1593 | 0 | return SECSuccess; |
1594 | 0 | } |
1595 | | |
1596 | | SECStatus |
1597 | | SSLExp_SetMaxEarlyDataSize(PRFileDesc *fd, PRUint32 size) |
1598 | 0 | { |
1599 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
1600 | 0 | if (!ss) { |
1601 | 0 | return SECFailure; /* Error code already set. */ |
1602 | 0 | } |
1603 | | |
1604 | 0 | ss->opt.maxEarlyDataSize = size; |
1605 | 0 | return SECSuccess; |
1606 | 0 | } |
1607 | | |
1608 | | /* function tells us if the cipher suite is one that we no longer support. */ |
1609 | | static PRBool |
1610 | | ssl_IsRemovedCipherSuite(PRInt32 suite) |
1611 | 4.35M | { |
1612 | 4.35M | switch (suite) { |
1613 | 0 | case SSL_FORTEZZA_DMS_WITH_NULL_SHA: |
1614 | 0 | case SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA: |
1615 | 0 | case SSL_FORTEZZA_DMS_WITH_RC4_128_SHA: |
1616 | 0 | return PR_TRUE; |
1617 | 4.35M | default: |
1618 | 4.35M | return PR_FALSE; |
1619 | 4.35M | } |
1620 | 4.35M | } |
1621 | | |
1622 | | /* Part of the public NSS API. |
1623 | | * Since this is a global (not per-socket) setting, we cannot use the |
1624 | | * HandshakeLock to protect this. Probably want a global lock. |
1625 | | */ |
1626 | | SECStatus |
1627 | | SSL_SetPolicy(long which, int policy) |
1628 | 0 | { |
1629 | 0 | if (ssl_IsRemovedCipherSuite(which)) |
1630 | 0 | return SECSuccess; |
1631 | 0 | return SSL_CipherPolicySet(which, policy); |
1632 | 0 | } |
1633 | | |
1634 | | SECStatus |
1635 | | ssl_CipherPolicySet(PRInt32 which, PRInt32 policy) |
1636 | 0 | { |
1637 | 0 | SECStatus rv = SECSuccess; |
1638 | |
|
1639 | 0 | if (ssl_IsRemovedCipherSuite(which)) { |
1640 | 0 | rv = SECSuccess; |
1641 | 0 | } else { |
1642 | 0 | rv = ssl3_SetPolicy((ssl3CipherSuite)which, policy); |
1643 | 0 | } |
1644 | 0 | return rv; |
1645 | 0 | } |
1646 | | SECStatus |
1647 | | SSL_CipherPolicySet(PRInt32 which, PRInt32 policy) |
1648 | 0 | { |
1649 | 0 | SECStatus rv = ssl_Init(); |
1650 | |
|
1651 | 0 | if (rv != SECSuccess) { |
1652 | 0 | return rv; |
1653 | 0 | } |
1654 | 0 | if (NSS_IsPolicyLocked()) { |
1655 | 0 | PORT_SetError(SEC_ERROR_POLICY_LOCKED); |
1656 | 0 | return SECFailure; |
1657 | 0 | } |
1658 | 0 | return ssl_CipherPolicySet(which, policy); |
1659 | 0 | } |
1660 | | |
1661 | | SECStatus |
1662 | | SSL_CipherPolicyGet(PRInt32 which, PRInt32 *oPolicy) |
1663 | 0 | { |
1664 | 0 | SECStatus rv; |
1665 | |
|
1666 | 0 | if (!oPolicy) { |
1667 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1668 | 0 | return SECFailure; |
1669 | 0 | } |
1670 | 0 | if (ssl_IsRemovedCipherSuite(which)) { |
1671 | 0 | *oPolicy = SSL_NOT_ALLOWED; |
1672 | 0 | rv = SECSuccess; |
1673 | 0 | } else { |
1674 | 0 | rv = ssl3_GetPolicy((ssl3CipherSuite)which, oPolicy); |
1675 | 0 | } |
1676 | 0 | return rv; |
1677 | 0 | } |
1678 | | |
1679 | | /* Part of the public NSS API. |
1680 | | * Since this is a global (not per-socket) setting, we cannot use the |
1681 | | * HandshakeLock to protect this. Probably want a global lock. |
1682 | | * These changes have no effect on any sslSockets already created. |
1683 | | */ |
1684 | | SECStatus |
1685 | | SSL_EnableCipher(long which, PRBool enabled) |
1686 | 0 | { |
1687 | 0 | if (ssl_IsRemovedCipherSuite(which)) |
1688 | 0 | return SECSuccess; |
1689 | 0 | return SSL_CipherPrefSetDefault(which, enabled); |
1690 | 0 | } |
1691 | | |
1692 | | SECStatus |
1693 | | ssl_CipherPrefSetDefault(PRInt32 which, PRBool enabled) |
1694 | 0 | { |
1695 | 0 | if (ssl_IsRemovedCipherSuite(which)) |
1696 | 0 | return SECSuccess; |
1697 | 0 | return ssl3_CipherPrefSetDefault((ssl3CipherSuite)which, enabled); |
1698 | 0 | } |
1699 | | |
1700 | | SECStatus |
1701 | | SSL_CipherPrefSetDefault(PRInt32 which, PRBool enabled) |
1702 | 0 | { |
1703 | 0 | SECStatus rv = ssl_Init(); |
1704 | 0 | PRInt32 locks; |
1705 | |
|
1706 | 0 | if (rv != SECSuccess) { |
1707 | 0 | return rv; |
1708 | 0 | } |
1709 | 0 | rv = NSS_OptionGet(NSS_DEFAULT_LOCKS, &locks); |
1710 | 0 | if ((rv == SECSuccess) && (locks & NSS_DEFAULT_SSL_LOCK)) { |
1711 | 0 | return SECSuccess; |
1712 | 0 | } |
1713 | 0 | return ssl_CipherPrefSetDefault(which, enabled); |
1714 | 0 | } |
1715 | | |
1716 | | SECStatus |
1717 | | SSL_CipherPrefGetDefault(PRInt32 which, PRBool *enabled) |
1718 | 0 | { |
1719 | 0 | SECStatus rv; |
1720 | |
|
1721 | 0 | if (!enabled) { |
1722 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1723 | 0 | return SECFailure; |
1724 | 0 | } |
1725 | 0 | if (ssl_IsRemovedCipherSuite(which)) { |
1726 | 0 | *enabled = PR_FALSE; |
1727 | 0 | rv = SECSuccess; |
1728 | 0 | } else { |
1729 | 0 | rv = ssl3_CipherPrefGetDefault((ssl3CipherSuite)which, enabled); |
1730 | 0 | } |
1731 | 0 | return rv; |
1732 | 0 | } |
1733 | | |
1734 | | SECStatus |
1735 | | SSL_CipherPrefSet(PRFileDesc *fd, PRInt32 which, PRBool enabled) |
1736 | 4.35M | { |
1737 | 4.35M | sslSocket *ss = ssl_FindSocket(fd); |
1738 | 4.35M | PRInt32 locks; |
1739 | 4.35M | SECStatus rv; |
1740 | | |
1741 | 4.35M | if (!ss) { |
1742 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in CipherPrefSet", SSL_GETPID(), fd)); |
1743 | 0 | return SECFailure; |
1744 | 0 | } |
1745 | 4.35M | rv = NSS_OptionGet(NSS_DEFAULT_LOCKS, &locks); |
1746 | 4.35M | if ((rv == SECSuccess) && (locks & NSS_DEFAULT_SSL_LOCK)) { |
1747 | 0 | return SECSuccess; |
1748 | 0 | } |
1749 | 4.35M | if (ssl_IsRemovedCipherSuite(which)) |
1750 | 0 | return SECSuccess; |
1751 | 4.35M | return ssl3_CipherPrefSet(ss, (ssl3CipherSuite)which, enabled); |
1752 | 4.35M | } |
1753 | | |
1754 | | SECStatus |
1755 | | SSL_CipherPrefGet(PRFileDesc *fd, PRInt32 which, PRBool *enabled) |
1756 | 0 | { |
1757 | 0 | SECStatus rv; |
1758 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
1759 | |
|
1760 | 0 | if (!enabled) { |
1761 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1762 | 0 | return SECFailure; |
1763 | 0 | } |
1764 | 0 | if (!ss) { |
1765 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in CipherPrefGet", SSL_GETPID(), fd)); |
1766 | 0 | *enabled = PR_FALSE; |
1767 | 0 | return SECFailure; |
1768 | 0 | } |
1769 | 0 | if (ssl_IsRemovedCipherSuite(which)) { |
1770 | 0 | *enabled = PR_FALSE; |
1771 | 0 | rv = SECSuccess; |
1772 | 0 | } else { |
1773 | 0 | rv = ssl3_CipherPrefGet(ss, (ssl3CipherSuite)which, enabled); |
1774 | 0 | } |
1775 | 0 | return rv; |
1776 | 0 | } |
1777 | | |
1778 | | /* The client can call this function to be aware of the current |
1779 | | * CipherSuites order. */ |
1780 | | SECStatus |
1781 | | SSLExp_CipherSuiteOrderGet(PRFileDesc *fd, PRUint16 *cipherOrder, |
1782 | | unsigned int *numCiphers) |
1783 | 0 | { |
1784 | 0 | if (!fd) { |
1785 | 0 | SSL_DBG(("%d: SSL: file descriptor in CipherSuiteOrderGet is null", |
1786 | 0 | SSL_GETPID())); |
1787 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1788 | 0 | return SECFailure; |
1789 | 0 | } |
1790 | 0 | if (!cipherOrder || !numCiphers) { |
1791 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1792 | 0 | return SECFailure; |
1793 | 0 | } |
1794 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
1795 | 0 | if (!ss) { |
1796 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in CipherSuiteOrderGet", SSL_GETPID(), |
1797 | 0 | fd)); |
1798 | 0 | return SECFailure; /* Error code already set. */ |
1799 | 0 | } |
1800 | | |
1801 | 0 | unsigned int enabled = 0; |
1802 | 0 | ssl_Get1stHandshakeLock(ss); |
1803 | 0 | ssl_GetSSL3HandshakeLock(ss); |
1804 | 0 | for (unsigned int i = 0; i < ssl_V3_SUITES_IMPLEMENTED; i++) { |
1805 | 0 | const ssl3CipherSuiteCfg *suiteCfg = &ss->cipherSuites[i]; |
1806 | 0 | if (suiteCfg && suiteCfg->enabled && |
1807 | 0 | suiteCfg->policy != SSL_NOT_ALLOWED) { |
1808 | 0 | cipherOrder[enabled++] = suiteCfg->cipher_suite; |
1809 | 0 | } |
1810 | 0 | } |
1811 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
1812 | 0 | ssl_Release1stHandshakeLock(ss); |
1813 | 0 | *numCiphers = enabled; |
1814 | 0 | return SECSuccess; |
1815 | 0 | } |
1816 | | |
1817 | | /* This function permits reorder the CipherSuites List for the Handshake |
1818 | | * (Client Hello). */ |
1819 | | SECStatus |
1820 | | SSLExp_CipherSuiteOrderSet(PRFileDesc *fd, const PRUint16 *cipherOrder, |
1821 | | PRUint16 numCiphers) |
1822 | 0 | { |
1823 | 0 | if (!fd) { |
1824 | 0 | SSL_DBG(("%d: SSL: file descriptor in CipherSuiteOrderGet is null", |
1825 | 0 | SSL_GETPID())); |
1826 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1827 | 0 | return SECFailure; |
1828 | 0 | } |
1829 | 0 | if (!cipherOrder || !numCiphers || numCiphers > ssl_V3_SUITES_IMPLEMENTED) { |
1830 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1831 | 0 | return SECFailure; |
1832 | 0 | } |
1833 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
1834 | 0 | if (!ss) { |
1835 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in CipherSuiteOrderSet", SSL_GETPID(), |
1836 | 0 | fd)); |
1837 | 0 | return SECFailure; /* Error code already set. */ |
1838 | 0 | } |
1839 | 0 | ssl3CipherSuiteCfg tmpSuiteCfg[ssl_V3_SUITES_IMPLEMENTED]; |
1840 | 0 | ssl_Get1stHandshakeLock(ss); |
1841 | 0 | ssl_GetSSL3HandshakeLock(ss); |
1842 | | /* For each cipherSuite given as input, verify that it is |
1843 | | * known to NSS and only present in the list once. */ |
1844 | 0 | for (unsigned int i = 0; i < numCiphers; i++) { |
1845 | 0 | const ssl3CipherSuiteCfg *suiteCfg = |
1846 | 0 | ssl_LookupCipherSuiteCfg(cipherOrder[i], ss->cipherSuites); |
1847 | 0 | if (!suiteCfg) { |
1848 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1849 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
1850 | 0 | ssl_Release1stHandshakeLock(ss); |
1851 | 0 | return SECFailure; |
1852 | 0 | } |
1853 | 0 | for (unsigned int j = i + 1; j < numCiphers; j++) { |
1854 | | /* This is a duplicate entry. */ |
1855 | 0 | if (cipherOrder[i] == cipherOrder[j]) { |
1856 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1857 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
1858 | 0 | ssl_Release1stHandshakeLock(ss); |
1859 | 0 | return SECFailure; |
1860 | 0 | } |
1861 | 0 | } |
1862 | 0 | tmpSuiteCfg[i] = *suiteCfg; |
1863 | 0 | tmpSuiteCfg[i].enabled = PR_TRUE; |
1864 | 0 | } |
1865 | | /* Find all defined ciphersuites not present in the input list and append |
1866 | | * them after the preferred. This guarantees that the socket will always |
1867 | | * have a complete list of size ssl_V3_SUITES_IMPLEMENTED */ |
1868 | 0 | unsigned int cfgIdx = numCiphers; |
1869 | 0 | for (unsigned int i = 0; i < ssl_V3_SUITES_IMPLEMENTED; i++) { |
1870 | 0 | PRBool received = PR_FALSE; |
1871 | 0 | for (unsigned int j = 0; j < numCiphers; j++) { |
1872 | 0 | if (ss->cipherSuites[i].cipher_suite == |
1873 | 0 | tmpSuiteCfg[j].cipher_suite) { |
1874 | 0 | received = PR_TRUE; |
1875 | 0 | break; |
1876 | 0 | } |
1877 | 0 | } |
1878 | 0 | if (!received) { |
1879 | 0 | tmpSuiteCfg[cfgIdx] = ss->cipherSuites[i]; |
1880 | 0 | tmpSuiteCfg[cfgIdx++].enabled = PR_FALSE; |
1881 | 0 | } |
1882 | 0 | } |
1883 | 0 | PORT_Assert(cfgIdx == ssl_V3_SUITES_IMPLEMENTED); |
1884 | | /* now we can rewrite the socket with the desired order */ |
1885 | 0 | PORT_Memcpy(ss->cipherSuites, tmpSuiteCfg, sizeof(tmpSuiteCfg)); |
1886 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
1887 | 0 | ssl_Release1stHandshakeLock(ss); |
1888 | 0 | return SECSuccess; |
1889 | 0 | } |
1890 | | |
1891 | | SECStatus |
1892 | | NSS_SetDomesticPolicy(void) |
1893 | 0 | { |
1894 | 0 | SECStatus status = SECSuccess; |
1895 | 0 | const PRUint16 *cipher; |
1896 | 0 | SECStatus rv; |
1897 | 0 | PRUint32 policy; |
1898 | | |
1899 | | /* If we've already defined some policy oids, skip changing them */ |
1900 | 0 | rv = NSS_GetAlgorithmPolicy(SEC_OID_APPLY_SSL_POLICY, &policy); |
1901 | 0 | if ((rv == SECSuccess) && (policy & NSS_USE_POLICY_IN_SSL)) { |
1902 | 0 | return ssl_Init(); /* make sure the policies have been loaded */ |
1903 | 0 | } |
1904 | | |
1905 | 0 | for (cipher = SSL_ImplementedCiphers; *cipher != 0; ++cipher) { |
1906 | 0 | status = SSL_SetPolicy(*cipher, SSL_ALLOWED); |
1907 | 0 | if (status != SECSuccess) |
1908 | 0 | break; |
1909 | 0 | } |
1910 | 0 | return status; |
1911 | 0 | } |
1912 | | |
1913 | | SECStatus |
1914 | | NSS_SetExportPolicy(void) |
1915 | 0 | { |
1916 | 0 | return NSS_SetDomesticPolicy(); |
1917 | 0 | } |
1918 | | |
1919 | | SECStatus |
1920 | | NSS_SetFrancePolicy(void) |
1921 | 0 | { |
1922 | 0 | return NSS_SetDomesticPolicy(); |
1923 | 0 | } |
1924 | | |
1925 | | SECStatus |
1926 | | SSL_NamedGroupConfig(PRFileDesc *fd, const SSLNamedGroup *groups, |
1927 | | unsigned int numGroups) |
1928 | 0 | { |
1929 | 0 | unsigned int i; |
1930 | 0 | unsigned int j = 0; |
1931 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
1932 | |
|
1933 | 0 | if (!ss) { |
1934 | 0 | PORT_SetError(SEC_ERROR_NOT_INITIALIZED); |
1935 | 0 | return SECFailure; |
1936 | 0 | } |
1937 | | |
1938 | 0 | if (!groups) { |
1939 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1940 | 0 | return SECFailure; |
1941 | 0 | } |
1942 | 0 | if (numGroups > SSL_NAMED_GROUP_COUNT) { |
1943 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1944 | 0 | return SECFailure; |
1945 | 0 | } |
1946 | | |
1947 | 0 | memset((void *)ss->namedGroupPreferences, 0, |
1948 | 0 | sizeof(ss->namedGroupPreferences)); |
1949 | 0 | for (i = 0; i < numGroups; ++i) { |
1950 | 0 | const sslNamedGroupDef *groupDef = ssl_LookupNamedGroup(groups[i]); |
1951 | 0 | if (!ssl_NamedGroupEnabled(ss, groupDef)) { |
1952 | 0 | ss->namedGroupPreferences[j++] = groupDef; |
1953 | 0 | } |
1954 | 0 | } |
1955 | |
|
1956 | 0 | return SECSuccess; |
1957 | 0 | } |
1958 | | |
1959 | | SECStatus |
1960 | | SSL_DHEGroupPrefSet(PRFileDesc *fd, const SSLDHEGroupType *groups, |
1961 | | PRUint16 num_groups) |
1962 | 0 | { |
1963 | 0 | sslSocket *ss; |
1964 | 0 | const SSLDHEGroupType *list; |
1965 | 0 | unsigned int count; |
1966 | 0 | int i, k, j; |
1967 | 0 | const sslNamedGroupDef *enabled[SSL_NAMED_GROUP_COUNT] = { 0 }; |
1968 | 0 | static const SSLDHEGroupType default_dhe_groups[] = { |
1969 | 0 | ssl_ff_dhe_2048_group |
1970 | 0 | }; |
1971 | |
|
1972 | 0 | if ((num_groups && !groups) || (!num_groups && groups) || |
1973 | 0 | num_groups > SSL_NAMED_GROUP_COUNT) { |
1974 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
1975 | 0 | return SECFailure; |
1976 | 0 | } |
1977 | | |
1978 | 0 | ss = ssl_FindSocket(fd); |
1979 | 0 | if (!ss) { |
1980 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_DHEGroupPrefSet", SSL_GETPID(), fd)); |
1981 | 0 | return SECFailure; |
1982 | 0 | } |
1983 | | |
1984 | 0 | if (groups) { |
1985 | 0 | list = groups; |
1986 | 0 | count = num_groups; |
1987 | 0 | } else { |
1988 | 0 | list = default_dhe_groups; |
1989 | 0 | count = PR_ARRAY_SIZE(default_dhe_groups); |
1990 | 0 | } |
1991 | | |
1992 | | /* save enabled ec groups and clear ss->namedGroupPreferences */ |
1993 | 0 | k = 0; |
1994 | 0 | for (i = 0; i < SSL_NAMED_GROUP_COUNT; ++i) { |
1995 | 0 | if (ss->namedGroupPreferences[i] && |
1996 | 0 | ss->namedGroupPreferences[i]->keaType != ssl_kea_dh) { |
1997 | 0 | enabled[k++] = ss->namedGroupPreferences[i]; |
1998 | 0 | } |
1999 | 0 | ss->namedGroupPreferences[i] = NULL; |
2000 | 0 | } |
2001 | |
|
2002 | 0 | ss->ssl3.dhePreferredGroup = NULL; |
2003 | 0 | for (i = 0; i < count; ++i) { |
2004 | 0 | PRBool duplicate = PR_FALSE; |
2005 | 0 | SSLNamedGroup name; |
2006 | 0 | const sslNamedGroupDef *groupDef; |
2007 | 0 | switch (list[i]) { |
2008 | 0 | case ssl_ff_dhe_2048_group: |
2009 | 0 | name = ssl_grp_ffdhe_2048; |
2010 | 0 | break; |
2011 | 0 | case ssl_ff_dhe_3072_group: |
2012 | 0 | name = ssl_grp_ffdhe_3072; |
2013 | 0 | break; |
2014 | 0 | case ssl_ff_dhe_4096_group: |
2015 | 0 | name = ssl_grp_ffdhe_4096; |
2016 | 0 | break; |
2017 | 0 | case ssl_ff_dhe_6144_group: |
2018 | 0 | name = ssl_grp_ffdhe_6144; |
2019 | 0 | break; |
2020 | 0 | case ssl_ff_dhe_8192_group: |
2021 | 0 | name = ssl_grp_ffdhe_8192; |
2022 | 0 | break; |
2023 | 0 | default: |
2024 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2025 | 0 | return SECFailure; |
2026 | 0 | } |
2027 | 0 | groupDef = ssl_LookupNamedGroup(name); |
2028 | 0 | PORT_Assert(groupDef); |
2029 | 0 | if (!ss->ssl3.dhePreferredGroup) { |
2030 | 0 | ss->ssl3.dhePreferredGroup = groupDef; |
2031 | 0 | } |
2032 | 0 | PORT_Assert(k < SSL_NAMED_GROUP_COUNT); |
2033 | 0 | for (j = 0; j < k; ++j) { |
2034 | | /* skip duplicates */ |
2035 | 0 | if (enabled[j] == groupDef) { |
2036 | 0 | duplicate = PR_TRUE; |
2037 | 0 | break; |
2038 | 0 | } |
2039 | 0 | } |
2040 | 0 | if (!duplicate) { |
2041 | 0 | enabled[k++] = groupDef; |
2042 | 0 | } |
2043 | 0 | } |
2044 | 0 | for (i = 0; i < k; ++i) { |
2045 | 0 | ss->namedGroupPreferences[i] = enabled[i]; |
2046 | 0 | } |
2047 | |
|
2048 | 0 | return SECSuccess; |
2049 | 0 | } |
2050 | | |
2051 | | PRCallOnceType gWeakDHParamsRegisterOnce; |
2052 | | int gWeakDHParamsRegisterError; |
2053 | | |
2054 | | PRCallOnceType gWeakDHParamsOnce; |
2055 | | int gWeakDHParamsError; |
2056 | | /* As our code allocates type PQGParams, we'll keep it around, |
2057 | | * even though we only make use of it's parameters through gWeakDHParam. */ |
2058 | | static PQGParams *gWeakParamsPQG; |
2059 | | static ssl3DHParams *gWeakDHParams; |
2060 | 4.05k | #define WEAK_DHE_SIZE 1024 |
2061 | | |
2062 | | static PRStatus |
2063 | | ssl3_CreateWeakDHParams(void) |
2064 | 0 | { |
2065 | 0 | PQGVerify *vfy; |
2066 | 0 | SECStatus rv, passed; |
2067 | |
|
2068 | 0 | PORT_Assert(!gWeakDHParams && !gWeakParamsPQG); |
2069 | |
|
2070 | 0 | rv = PK11_PQG_ParamGenV2(WEAK_DHE_SIZE, 160, 64 /*maximum seed that will work*/, |
2071 | 0 | &gWeakParamsPQG, &vfy); |
2072 | 0 | if (rv != SECSuccess) { |
2073 | 0 | gWeakDHParamsError = PORT_GetError(); |
2074 | 0 | return PR_FAILURE; |
2075 | 0 | } |
2076 | | |
2077 | 0 | rv = PK11_PQG_VerifyParams(gWeakParamsPQG, vfy, &passed); |
2078 | 0 | if (rv != SECSuccess || passed != SECSuccess) { |
2079 | 0 | SSL_DBG(("%d: PK11_PQG_VerifyParams failed in ssl3_CreateWeakDHParams", |
2080 | 0 | SSL_GETPID())); |
2081 | 0 | gWeakDHParamsError = PORT_GetError(); |
2082 | 0 | return PR_FAILURE; |
2083 | 0 | } |
2084 | | |
2085 | 0 | gWeakDHParams = PORT_ArenaNew(gWeakParamsPQG->arena, ssl3DHParams); |
2086 | 0 | if (!gWeakDHParams) { |
2087 | 0 | gWeakDHParamsError = PORT_GetError(); |
2088 | 0 | return PR_FAILURE; |
2089 | 0 | } |
2090 | | |
2091 | 0 | gWeakDHParams->name = ssl_grp_ffdhe_custom; |
2092 | 0 | gWeakDHParams->prime.data = gWeakParamsPQG->prime.data; |
2093 | 0 | gWeakDHParams->prime.len = gWeakParamsPQG->prime.len; |
2094 | 0 | gWeakDHParams->base.data = gWeakParamsPQG->base.data; |
2095 | 0 | gWeakDHParams->base.len = gWeakParamsPQG->base.len; |
2096 | |
|
2097 | 0 | PK11_PQG_DestroyVerify(vfy); |
2098 | 0 | return PR_SUCCESS; |
2099 | 0 | } |
2100 | | |
2101 | | static SECStatus |
2102 | | ssl3_WeakDHParamsShutdown(void *appData, void *nssData) |
2103 | 0 | { |
2104 | 0 | if (gWeakParamsPQG) { |
2105 | 0 | PK11_PQG_DestroyParams(gWeakParamsPQG); |
2106 | 0 | gWeakParamsPQG = NULL; |
2107 | 0 | gWeakDHParams = NULL; |
2108 | 0 | } |
2109 | 0 | return SECSuccess; |
2110 | 0 | } |
2111 | | |
2112 | | static PRStatus |
2113 | | ssl3_WeakDHParamsRegisterShutdown(void) |
2114 | 0 | { |
2115 | 0 | SECStatus rv; |
2116 | 0 | rv = NSS_RegisterShutdown(ssl3_WeakDHParamsShutdown, NULL); |
2117 | 0 | if (rv != SECSuccess) { |
2118 | 0 | gWeakDHParamsRegisterError = PORT_GetError(); |
2119 | 0 | } |
2120 | 0 | return (PRStatus)rv; |
2121 | 0 | } |
2122 | | |
2123 | | /* global init strategy inspired by ssl3_CreateECDHEphemeralKeys */ |
2124 | | SECStatus |
2125 | | SSL_EnableWeakDHEPrimeGroup(PRFileDesc *fd, PRBool enabled) |
2126 | 0 | { |
2127 | 0 | sslSocket *ss; |
2128 | 0 | PRStatus status; |
2129 | |
|
2130 | 0 | if (enabled) { |
2131 | 0 | status = PR_CallOnce(&gWeakDHParamsRegisterOnce, |
2132 | 0 | ssl3_WeakDHParamsRegisterShutdown); |
2133 | 0 | if (status != PR_SUCCESS) { |
2134 | 0 | PORT_SetError(gWeakDHParamsRegisterError); |
2135 | 0 | return SECFailure; |
2136 | 0 | } |
2137 | | |
2138 | 0 | status = PR_CallOnce(&gWeakDHParamsOnce, ssl3_CreateWeakDHParams); |
2139 | 0 | if (status != PR_SUCCESS) { |
2140 | 0 | PORT_SetError(gWeakDHParamsError); |
2141 | 0 | return SECFailure; |
2142 | 0 | } |
2143 | 0 | } |
2144 | | |
2145 | 0 | if (!fd) |
2146 | 0 | return SECSuccess; |
2147 | | |
2148 | 0 | ss = ssl_FindSocket(fd); |
2149 | 0 | if (!ss) { |
2150 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_DHEGroupPrefSet", SSL_GETPID(), fd)); |
2151 | 0 | return SECFailure; |
2152 | 0 | } |
2153 | | |
2154 | 0 | ss->ssl3.dheWeakGroupEnabled = enabled; |
2155 | 0 | return SECSuccess; |
2156 | 0 | } |
2157 | | |
2158 | | #include "dhe-param.c" |
2159 | | |
2160 | | const ssl3DHParams * |
2161 | | ssl_GetDHEParams(const sslNamedGroupDef *groupDef) |
2162 | 7.12k | { |
2163 | 7.12k | switch (groupDef->name) { |
2164 | 4.57k | case ssl_grp_ffdhe_2048: |
2165 | 4.57k | return &ff_dhe_2048_params; |
2166 | 1.26k | case ssl_grp_ffdhe_3072: |
2167 | 1.26k | return &ff_dhe_3072_params; |
2168 | 222 | case ssl_grp_ffdhe_4096: |
2169 | 222 | return &ff_dhe_4096_params; |
2170 | 300 | case ssl_grp_ffdhe_6144: |
2171 | 300 | return &ff_dhe_6144_params; |
2172 | 768 | case ssl_grp_ffdhe_8192: |
2173 | 768 | return &ff_dhe_8192_params; |
2174 | 0 | case ssl_grp_ffdhe_custom: |
2175 | 0 | PORT_Assert(gWeakDHParams); |
2176 | 0 | return gWeakDHParams; |
2177 | 0 | default: |
2178 | 0 | PORT_Assert(0); |
2179 | 7.12k | } |
2180 | 0 | return NULL; |
2181 | 7.12k | } |
2182 | | |
2183 | | /* This validates dh_Ys against the group prime. */ |
2184 | | PRBool |
2185 | | ssl_IsValidDHEShare(const SECItem *dh_p, const SECItem *dh_Ys) |
2186 | 8.06k | { |
2187 | 8.06k | unsigned int size_p = SECKEY_BigIntegerBitLength(dh_p); |
2188 | 8.06k | unsigned int size_y = SECKEY_BigIntegerBitLength(dh_Ys); |
2189 | 8.06k | unsigned int commonPart; |
2190 | 8.06k | int cmp; |
2191 | | |
2192 | 8.06k | if (dh_p->len == 0 || dh_Ys->len == 0) { |
2193 | 15 | return PR_FALSE; |
2194 | 15 | } |
2195 | | /* Check that the prime is at least odd. */ |
2196 | 8.04k | if ((dh_p->data[dh_p->len - 1] & 0x01) == 0) { |
2197 | 5 | return PR_FALSE; |
2198 | 5 | } |
2199 | | /* dh_Ys can't be 1, or bigger than dh_p. */ |
2200 | 8.04k | if (size_y <= 1 || size_y > size_p) { |
2201 | 69 | return PR_FALSE; |
2202 | 69 | } |
2203 | | /* If dh_Ys is shorter, then it's definitely smaller than p-1. */ |
2204 | 7.97k | if (size_y < size_p) { |
2205 | 6.44k | return PR_TRUE; |
2206 | 6.44k | } |
2207 | | |
2208 | | /* Compare the common part of each, minus the final octet. */ |
2209 | 1.52k | commonPart = (size_p + 7) / 8; |
2210 | 1.52k | PORT_Assert(commonPart <= dh_Ys->len); |
2211 | 1.52k | PORT_Assert(commonPart <= dh_p->len); |
2212 | 1.52k | cmp = PORT_Memcmp(dh_Ys->data + dh_Ys->len - commonPart, |
2213 | 1.52k | dh_p->data + dh_p->len - commonPart, commonPart - 1); |
2214 | 1.52k | if (cmp < 0) { |
2215 | 1.45k | return PR_TRUE; |
2216 | 1.45k | } |
2217 | 73 | if (cmp > 0) { |
2218 | 34 | return PR_FALSE; |
2219 | 34 | } |
2220 | | |
2221 | | /* The last octet of the prime is the only thing that is different and that |
2222 | | * has to be two greater than the share, otherwise we have Ys == p - 1, |
2223 | | * and that means small subgroups. */ |
2224 | 39 | if (dh_Ys->data[dh_Ys->len - 1] >= (dh_p->data[dh_p->len - 1] - 1)) { |
2225 | 6 | return PR_FALSE; |
2226 | 6 | } |
2227 | | |
2228 | 33 | return PR_TRUE; |
2229 | 39 | } |
2230 | | |
2231 | | /* Checks that the provided DH parameters match those in one of the named groups |
2232 | | * that we have enabled. The groups are defined in dhe-param.c and are those |
2233 | | * defined in Appendix A of draft-ietf-tls-negotiated-ff-dhe. |
2234 | | * |
2235 | | * |groupDef| and |dhParams| are optional outparams that identify the group and |
2236 | | * its parameters respectively (if this is successful). */ |
2237 | | SECStatus |
2238 | | ssl_ValidateDHENamedGroup(sslSocket *ss, |
2239 | | const SECItem *dh_p, |
2240 | | const SECItem *dh_g, |
2241 | | const sslNamedGroupDef **groupDef, |
2242 | | const ssl3DHParams **dhParams) |
2243 | 142 | { |
2244 | 142 | unsigned int i; |
2245 | | |
2246 | 3.93k | for (i = 0; i < SSL_NAMED_GROUP_COUNT; ++i) { |
2247 | 3.84k | const ssl3DHParams *params; |
2248 | 3.84k | if (!ss->namedGroupPreferences[i]) { |
2249 | 2.29k | continue; |
2250 | 2.29k | } |
2251 | 1.54k | if (ss->namedGroupPreferences[i]->keaType != ssl_kea_dh) { |
2252 | 994 | continue; |
2253 | 994 | } |
2254 | | |
2255 | 549 | params = ssl_GetDHEParams(ss->namedGroupPreferences[i]); |
2256 | 549 | PORT_Assert(params); |
2257 | 549 | if (SECITEM_ItemsAreEqual(¶ms->prime, dh_p)) { |
2258 | 44 | if (!SECITEM_ItemsAreEqual(¶ms->base, dh_g)) { |
2259 | 11 | return SECFailure; |
2260 | 11 | } |
2261 | 33 | if (groupDef) |
2262 | 4 | *groupDef = ss->namedGroupPreferences[i]; |
2263 | 33 | if (dhParams) |
2264 | 4 | *dhParams = params; |
2265 | 33 | return SECSuccess; |
2266 | 44 | } |
2267 | 549 | } |
2268 | | |
2269 | 98 | return SECFailure; |
2270 | 142 | } |
2271 | | |
2272 | | /* Ensure DH parameters have been selected. This just picks the first enabled |
2273 | | * FFDHE group in ssl_named_groups, or the weak one if it was enabled. */ |
2274 | | SECStatus |
2275 | | ssl_SelectDHEGroup(sslSocket *ss, const sslNamedGroupDef **groupDef) |
2276 | 4.05k | { |
2277 | 4.05k | unsigned int i; |
2278 | 4.05k | static const sslNamedGroupDef weak_group_def = { |
2279 | 4.05k | ssl_grp_ffdhe_custom, WEAK_DHE_SIZE, ssl_kea_dh, |
2280 | 4.05k | SEC_OID_TLS_DHE_CUSTOM, PR_TRUE |
2281 | 4.05k | }; |
2282 | 4.05k | PRInt32 minDH; |
2283 | 4.05k | SECStatus rv; |
2284 | | |
2285 | | // make sure we select a group consistent with our |
2286 | | // current policy policy |
2287 | 4.05k | rv = NSS_OptionGet(NSS_DH_MIN_KEY_SIZE, &minDH); |
2288 | 4.05k | if (rv != SECSuccess || minDH <= 0) { |
2289 | 0 | minDH = DH_MIN_P_BITS; |
2290 | 0 | } |
2291 | | |
2292 | | /* Only select weak groups in TLS 1.2 and earlier, but not if the client has |
2293 | | * indicated that it supports an FFDHE named group. */ |
2294 | 4.05k | if (ss->ssl3.dheWeakGroupEnabled && |
2295 | 0 | ss->version < SSL_LIBRARY_VERSION_TLS_1_3 && |
2296 | 0 | !ss->xtnData.peerSupportsFfdheGroups && |
2297 | 0 | weak_group_def.bits >= minDH) { |
2298 | 0 | *groupDef = &weak_group_def; |
2299 | 0 | return SECSuccess; |
2300 | 0 | } |
2301 | 4.05k | if (ss->ssl3.dhePreferredGroup && |
2302 | 0 | ssl_NamedGroupEnabled(ss, ss->ssl3.dhePreferredGroup) && |
2303 | 0 | ss->ssl3.dhePreferredGroup->bits >= minDH) { |
2304 | 0 | *groupDef = ss->ssl3.dhePreferredGroup; |
2305 | 0 | return SECSuccess; |
2306 | 0 | } |
2307 | 37.8k | for (i = 0; i < SSL_NAMED_GROUP_COUNT; ++i) { |
2308 | 37.8k | if (ss->namedGroupPreferences[i] && |
2309 | 18.5k | ss->namedGroupPreferences[i]->keaType == ssl_kea_dh && |
2310 | 4.05k | ss->namedGroupPreferences[i]->bits >= minDH) { |
2311 | 4.05k | *groupDef = ss->namedGroupPreferences[i]; |
2312 | 4.05k | return SECSuccess; |
2313 | 4.05k | } |
2314 | 37.8k | } |
2315 | | |
2316 | 0 | *groupDef = NULL; |
2317 | 0 | PORT_SetError(SSL_ERROR_NO_CYPHER_OVERLAP); |
2318 | 0 | return SECFailure; |
2319 | 4.05k | } |
2320 | | |
2321 | | /* LOCKS ??? XXX */ |
2322 | | static PRFileDesc * |
2323 | | ssl_ImportFD(PRFileDesc *model, PRFileDesc *fd, SSLProtocolVariant variant) |
2324 | 61.2k | { |
2325 | 61.2k | sslSocket *ns = NULL; |
2326 | 61.2k | PRStatus rv; |
2327 | 61.2k | PRNetAddr addr; |
2328 | 61.2k | SECStatus status = ssl_Init(); |
2329 | | |
2330 | 61.2k | if (status != SECSuccess) { |
2331 | 0 | return NULL; |
2332 | 0 | } |
2333 | | |
2334 | 61.2k | if (model == NULL) { |
2335 | | /* Just create a default socket if we're given NULL for the model */ |
2336 | 30.0k | ns = ssl_NewSocket((PRBool)(!ssl_defaults.noLocks), variant); |
2337 | 31.2k | } else { |
2338 | 31.2k | sslSocket *ss = ssl_FindSocket(model); |
2339 | 31.2k | if (ss == NULL || ss->protocolVariant != variant) { |
2340 | 0 | SSL_DBG(("%d: SSL[%d]: bad model socket in ssl_ImportFD", |
2341 | 0 | SSL_GETPID(), model)); |
2342 | 0 | return NULL; |
2343 | 0 | } |
2344 | 31.2k | ns = ssl_DupSocket(ss); |
2345 | 31.2k | } |
2346 | 61.2k | if (ns == NULL) |
2347 | 0 | return NULL; |
2348 | | |
2349 | 61.2k | rv = ssl_PushIOLayer(ns, fd, PR_TOP_IO_LAYER); |
2350 | 61.2k | if (rv != PR_SUCCESS) { |
2351 | 0 | ssl_FreeSocket(ns); |
2352 | 0 | PORT_SetError(SEC_ERROR_LIBRARY_FAILURE); |
2353 | 0 | return NULL; |
2354 | 0 | } |
2355 | 61.2k | #if defined(DEBUG) || defined(FORCE_PR_ASSERT) |
2356 | 61.2k | { |
2357 | 61.2k | sslSocket *ss = ssl_FindSocket(fd); |
2358 | 61.2k | PORT_Assert(ss == ns); |
2359 | 61.2k | } |
2360 | 61.2k | #endif |
2361 | 61.2k | ns->TCPconnected = (PR_SUCCESS == ssl_DefGetpeername(ns, &addr)); |
2362 | 61.2k | return fd; |
2363 | 61.2k | } |
2364 | | |
2365 | | PRFileDesc * |
2366 | | SSL_ImportFD(PRFileDesc *model, PRFileDesc *fd) |
2367 | 31.8k | { |
2368 | 31.8k | return ssl_ImportFD(model, fd, ssl_variant_stream); |
2369 | 31.8k | } |
2370 | | |
2371 | | PRFileDesc * |
2372 | | DTLS_ImportFD(PRFileDesc *model, PRFileDesc *fd) |
2373 | 29.4k | { |
2374 | 29.4k | return ssl_ImportFD(model, fd, ssl_variant_datagram); |
2375 | 29.4k | } |
2376 | | |
2377 | | /* SSL_SetNextProtoCallback is used to select an application protocol |
2378 | | * for ALPN. */ |
2379 | | SECStatus |
2380 | | SSL_SetNextProtoCallback(PRFileDesc *fd, SSLNextProtoCallback callback, |
2381 | | void *arg) |
2382 | 30.6k | { |
2383 | 30.6k | sslSocket *ss = ssl_FindSocket(fd); |
2384 | | |
2385 | 30.6k | if (!ss) { |
2386 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetNextProtoCallback", SSL_GETPID(), |
2387 | 0 | fd)); |
2388 | 0 | return SECFailure; |
2389 | 0 | } |
2390 | | |
2391 | 30.6k | ssl_GetSSL3HandshakeLock(ss); |
2392 | 30.6k | ss->nextProtoCallback = callback; |
2393 | 30.6k | ss->nextProtoArg = arg; |
2394 | 30.6k | ssl_ReleaseSSL3HandshakeLock(ss); |
2395 | | |
2396 | 30.6k | return SECSuccess; |
2397 | 30.6k | } |
2398 | | |
2399 | | /* ssl_NextProtoNegoCallback is set as an ALPN callback when |
2400 | | * SSL_SetNextProtoNego is used. |
2401 | | */ |
2402 | | static SECStatus |
2403 | | ssl_NextProtoNegoCallback(void *arg, PRFileDesc *fd, |
2404 | | const unsigned char *protos, unsigned int protos_len, |
2405 | | unsigned char *protoOut, unsigned int *protoOutLen, |
2406 | | unsigned int protoMaxLen) |
2407 | 145 | { |
2408 | 145 | unsigned int i, j; |
2409 | 145 | sslSocket *ss = ssl_FindSocket(fd); |
2410 | 145 | if (!ss) { |
2411 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in ssl_NextProtoNegoCallback", |
2412 | 0 | SSL_GETPID(), fd)); |
2413 | 0 | return SECFailure; |
2414 | 0 | } |
2415 | 145 | if (ss->opt.nextProtoNego.len == 0) { |
2416 | 0 | SSL_DBG(("%d: SSL[%d]: ssl_NextProtoNegoCallback ALPN disabled", |
2417 | 0 | SSL_GETPID(), fd)); |
2418 | 0 | SSL3_SendAlert(ss, alert_fatal, unsupported_extension); |
2419 | 0 | return SECFailure; |
2420 | 0 | } |
2421 | | |
2422 | 145 | PORT_Assert(protoMaxLen <= 255); |
2423 | 145 | if (protoMaxLen > 255) { |
2424 | 0 | PORT_SetError(SEC_ERROR_OUTPUT_LEN); |
2425 | 0 | return SECFailure; |
2426 | 0 | } |
2427 | | |
2428 | | /* For each protocol in client preference, see if we support it. */ |
2429 | 419 | for (j = 0; j < ss->opt.nextProtoNego.len;) { |
2430 | 8.04k | for (i = 0; i < protos_len;) { |
2431 | 7.76k | if (protos[i] == ss->opt.nextProtoNego.data[j] && |
2432 | 2.18k | PORT_Memcmp(&protos[i + 1], &ss->opt.nextProtoNego.data[j + 1], |
2433 | 2.18k | protos[i]) == 0) { |
2434 | | /* We found a match. */ |
2435 | 13 | const unsigned char *result = &protos[i]; |
2436 | 13 | memcpy(protoOut, result + 1, result[0]); |
2437 | 13 | *protoOutLen = result[0]; |
2438 | 13 | return SECSuccess; |
2439 | 13 | } |
2440 | 7.75k | i += 1 + (unsigned int)protos[i]; |
2441 | 7.75k | } |
2442 | 274 | j += 1 + (unsigned int)ss->opt.nextProtoNego.data[j]; |
2443 | 274 | } |
2444 | | |
2445 | 132 | return SECSuccess; |
2446 | 145 | } |
2447 | | |
2448 | | SECStatus |
2449 | | SSL_SetNextProtoNego(PRFileDesc *fd, const unsigned char *data, |
2450 | | unsigned int length) |
2451 | 30.6k | { |
2452 | 30.6k | sslSocket *ss; |
2453 | | |
2454 | 30.6k | ss = ssl_FindSocket(fd); |
2455 | 30.6k | if (!ss) { |
2456 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetNextProtoNego", |
2457 | 0 | SSL_GETPID(), fd)); |
2458 | 0 | return SECFailure; |
2459 | 0 | } |
2460 | | |
2461 | 30.6k | if (length > 0 && ssl3_ValidateAppProtocol(data, length) != SECSuccess) { |
2462 | 0 | return SECFailure; |
2463 | 0 | } |
2464 | | |
2465 | | /* NPN required that the client's fallback protocol is first in the |
2466 | | * list. However, ALPN sends protocols in preference order. So move the |
2467 | | * first protocol to the end of the list. */ |
2468 | 30.6k | ssl_GetSSL3HandshakeLock(ss); |
2469 | 30.6k | SECITEM_FreeItem(&ss->opt.nextProtoNego, PR_FALSE); |
2470 | 30.6k | if (length > 0) { |
2471 | 30.6k | SECITEM_AllocItem(NULL, &ss->opt.nextProtoNego, length); |
2472 | 30.6k | size_t firstLen = data[0] + 1; |
2473 | | /* firstLen <= length is ensured by ssl3_ValidateAppProtocol. */ |
2474 | 30.6k | PORT_Memcpy(ss->opt.nextProtoNego.data + (length - firstLen), data, firstLen); |
2475 | 30.6k | PORT_Memcpy(ss->opt.nextProtoNego.data, data + firstLen, length - firstLen); |
2476 | 30.6k | } |
2477 | 30.6k | ssl_ReleaseSSL3HandshakeLock(ss); |
2478 | | |
2479 | 30.6k | return SSL_SetNextProtoCallback(fd, ssl_NextProtoNegoCallback, NULL); |
2480 | 30.6k | } |
2481 | | |
2482 | | SECStatus |
2483 | | SSL_GetNextProto(PRFileDesc *fd, SSLNextProtoState *state, unsigned char *buf, |
2484 | | unsigned int *bufLen, unsigned int bufLenMax) |
2485 | 0 | { |
2486 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
2487 | |
|
2488 | 0 | if (!ss) { |
2489 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_GetNextProto", SSL_GETPID(), |
2490 | 0 | fd)); |
2491 | 0 | return SECFailure; |
2492 | 0 | } |
2493 | | |
2494 | 0 | if (!state || !buf || !bufLen) { |
2495 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2496 | 0 | return SECFailure; |
2497 | 0 | } |
2498 | | |
2499 | 0 | *state = ss->xtnData.nextProtoState; |
2500 | |
|
2501 | 0 | if (ss->xtnData.nextProtoState != SSL_NEXT_PROTO_NO_SUPPORT && |
2502 | 0 | ss->xtnData.nextProto.data) { |
2503 | 0 | if (ss->xtnData.nextProto.len > bufLenMax) { |
2504 | 0 | PORT_SetError(SEC_ERROR_OUTPUT_LEN); |
2505 | 0 | return SECFailure; |
2506 | 0 | } |
2507 | 0 | PORT_Memcpy(buf, ss->xtnData.nextProto.data, ss->xtnData.nextProto.len); |
2508 | 0 | *bufLen = ss->xtnData.nextProto.len; |
2509 | 0 | } else { |
2510 | 0 | *bufLen = 0; |
2511 | 0 | } |
2512 | | |
2513 | 0 | return SECSuccess; |
2514 | 0 | } |
2515 | | |
2516 | | SECStatus |
2517 | | SSL_SetSRTPCiphers(PRFileDesc *fd, |
2518 | | const PRUint16 *ciphers, |
2519 | | unsigned int numCiphers) |
2520 | 0 | { |
2521 | 0 | sslSocket *ss; |
2522 | 0 | unsigned int i; |
2523 | |
|
2524 | 0 | ss = ssl_FindSocket(fd); |
2525 | 0 | if (!ss || !IS_DTLS(ss)) { |
2526 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetSRTPCiphers", |
2527 | 0 | SSL_GETPID(), fd)); |
2528 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2529 | 0 | return SECFailure; |
2530 | 0 | } |
2531 | | |
2532 | 0 | if (numCiphers > MAX_DTLS_SRTP_CIPHER_SUITES) { |
2533 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2534 | 0 | return SECFailure; |
2535 | 0 | } |
2536 | | |
2537 | 0 | ss->ssl3.dtlsSRTPCipherCount = 0; |
2538 | 0 | for (i = 0; i < numCiphers; i++) { |
2539 | 0 | const PRUint16 *srtpCipher = srtpCiphers; |
2540 | |
|
2541 | 0 | while (*srtpCipher) { |
2542 | 0 | if (ciphers[i] == *srtpCipher) |
2543 | 0 | break; |
2544 | 0 | srtpCipher++; |
2545 | 0 | } |
2546 | 0 | if (*srtpCipher) { |
2547 | 0 | ss->ssl3.dtlsSRTPCiphers[ss->ssl3.dtlsSRTPCipherCount++] = |
2548 | 0 | ciphers[i]; |
2549 | 0 | } else { |
2550 | 0 | SSL_DBG(("%d: SSL[%d]: invalid or unimplemented SRTP cipher " |
2551 | 0 | "suite specified: 0x%04hx", |
2552 | 0 | SSL_GETPID(), fd, |
2553 | 0 | ciphers[i])); |
2554 | 0 | } |
2555 | 0 | } |
2556 | |
|
2557 | 0 | if (ss->ssl3.dtlsSRTPCipherCount == 0) { |
2558 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2559 | 0 | return SECFailure; |
2560 | 0 | } |
2561 | | |
2562 | 0 | return SECSuccess; |
2563 | 0 | } |
2564 | | |
2565 | | SECStatus |
2566 | | SSL_GetSRTPCipher(PRFileDesc *fd, PRUint16 *cipher) |
2567 | 0 | { |
2568 | 0 | sslSocket *ss; |
2569 | |
|
2570 | 0 | ss = ssl_FindSocket(fd); |
2571 | 0 | if (!ss) { |
2572 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_GetSRTPCipher", |
2573 | 0 | SSL_GETPID(), fd)); |
2574 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2575 | 0 | return SECFailure; |
2576 | 0 | } |
2577 | | |
2578 | 0 | if (!ss->xtnData.dtlsSRTPCipherSuite) { |
2579 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2580 | 0 | return SECFailure; |
2581 | 0 | } |
2582 | | |
2583 | 0 | *cipher = ss->xtnData.dtlsSRTPCipherSuite; |
2584 | 0 | return SECSuccess; |
2585 | 0 | } |
2586 | | |
2587 | | PRFileDesc * |
2588 | | SSL_ReconfigFD(PRFileDesc *model, PRFileDesc *fd) |
2589 | 0 | { |
2590 | 0 | sslSocket *sm = NULL, *ss = NULL; |
2591 | 0 | SECStatus rv; |
2592 | |
|
2593 | 0 | if (model == NULL) { |
2594 | 0 | PR_SetError(SEC_ERROR_INVALID_ARGS, 0); |
2595 | 0 | return NULL; |
2596 | 0 | } |
2597 | 0 | sm = ssl_FindSocket(model); |
2598 | 0 | if (sm == NULL) { |
2599 | 0 | SSL_DBG(("%d: SSL[%d]: bad model socket in ssl_ReconfigFD", |
2600 | 0 | SSL_GETPID(), model)); |
2601 | 0 | return NULL; |
2602 | 0 | } |
2603 | 0 | ss = ssl_FindSocket(fd); |
2604 | 0 | PORT_Assert(ss); |
2605 | 0 | if (ss == NULL) { |
2606 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2607 | 0 | return NULL; |
2608 | 0 | } |
2609 | | |
2610 | 0 | rv = ssl_CopySocketConfig(ss, sm, PR_FALSE); |
2611 | 0 | if (rv != SECSuccess) { |
2612 | 0 | return NULL; |
2613 | 0 | } |
2614 | | |
2615 | 0 | if (!ss->opt.useSecurity) { |
2616 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2617 | 0 | return NULL; |
2618 | 0 | } |
2619 | | |
2620 | | /* Reset handshake PSKs on the target socket, re-populating from |
2621 | | * the (newly copied) external PSK if present. Pass |ss| (not |
2622 | | * |sm|) so that selectedPsk is cleared on the correct socket. |
2623 | | * ss->ssl3.hs.psks and ss->xtnData are handshake state, so take the |
2624 | | * handshake locks, as SSLExp_{Add,Remove}ExternalPsk do. */ |
2625 | 0 | ssl_Get1stHandshakeLock(ss); |
2626 | 0 | ssl_GetSSL3HandshakeLock(ss); |
2627 | 0 | ss->xtnData.selectedPsk = NULL; |
2628 | 0 | rv = tls13_ResetHandshakePsks(ss, &ss->ssl3.hs.psks); |
2629 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
2630 | 0 | ssl_Release1stHandshakeLock(ss); |
2631 | 0 | if (rv != SECSuccess) { |
2632 | 0 | return NULL; |
2633 | 0 | } |
2634 | | |
2635 | 0 | return fd; |
2636 | 0 | } |
2637 | | |
2638 | | SECStatus |
2639 | | ssl3_GetEffectiveVersionPolicy(SSLProtocolVariant variant, |
2640 | | SSLVersionRange *effectivePolicy) |
2641 | 412k | { |
2642 | 412k | SECStatus rv; |
2643 | 412k | PRUint32 policyFlag; |
2644 | 412k | PRInt32 minPolicy, maxPolicy; |
2645 | | |
2646 | 412k | if (variant == ssl_variant_stream) { |
2647 | 232k | effectivePolicy->min = SSL_LIBRARY_VERSION_MIN_SUPPORTED_STREAM; |
2648 | 232k | effectivePolicy->max = SSL_LIBRARY_VERSION_MAX_SUPPORTED; |
2649 | 232k | } else { |
2650 | 180k | effectivePolicy->min = SSL_LIBRARY_VERSION_MIN_SUPPORTED_DATAGRAM; |
2651 | 180k | effectivePolicy->max = SSL_LIBRARY_VERSION_MAX_SUPPORTED; |
2652 | 180k | } |
2653 | | |
2654 | 412k | rv = NSS_GetAlgorithmPolicy(SEC_OID_APPLY_SSL_POLICY, &policyFlag); |
2655 | 412k | if ((rv != SECSuccess) || !(policyFlag & NSS_USE_POLICY_IN_SSL)) { |
2656 | | /* Policy is not active, report library extents. */ |
2657 | 412k | return SECSuccess; |
2658 | 412k | } |
2659 | | |
2660 | 0 | rv = NSS_OptionGet(VERSIONS_POLICY_MIN(variant), &minPolicy); |
2661 | 0 | if (rv != SECSuccess) { |
2662 | 0 | return SECFailure; |
2663 | 0 | } |
2664 | 0 | rv = NSS_OptionGet(VERSIONS_POLICY_MAX(variant), &maxPolicy); |
2665 | 0 | if (rv != SECSuccess) { |
2666 | 0 | return SECFailure; |
2667 | 0 | } |
2668 | | |
2669 | 0 | if (minPolicy > effectivePolicy->max || |
2670 | 0 | maxPolicy < effectivePolicy->min || |
2671 | 0 | minPolicy > maxPolicy) { |
2672 | 0 | return SECFailure; |
2673 | 0 | } |
2674 | 0 | effectivePolicy->min = PR_MAX(effectivePolicy->min, minPolicy); |
2675 | 0 | effectivePolicy->max = PR_MIN(effectivePolicy->max, maxPolicy); |
2676 | 0 | return SECSuccess; |
2677 | 0 | } |
2678 | | |
2679 | | /* |
2680 | | * Assumes that rangeParam values are within the supported boundaries, |
2681 | | * but should contain all potentially allowed versions, even if they contain |
2682 | | * conflicting versions. |
2683 | | * Will return the overlap, or a NONE range if system policy is invalid. |
2684 | | */ |
2685 | | static SECStatus |
2686 | | ssl3_CreateOverlapWithPolicy(SSLProtocolVariant protocolVariant, |
2687 | | SSLVersionRange *input, |
2688 | | SSLVersionRange *overlap) |
2689 | 342k | { |
2690 | 342k | SECStatus rv; |
2691 | 342k | SSLVersionRange effectivePolicyBoundary; |
2692 | 342k | SSLVersionRange vrange; |
2693 | | |
2694 | 342k | PORT_Assert(input != NULL); |
2695 | | |
2696 | 342k | rv = ssl3_GetEffectiveVersionPolicy(protocolVariant, |
2697 | 342k | &effectivePolicyBoundary); |
2698 | 342k | if (rv == SECFailure) { |
2699 | | /* SECFailure means internal failure or invalid configuration. */ |
2700 | 0 | overlap->min = overlap->max = SSL_LIBRARY_VERSION_NONE; |
2701 | 0 | return SECFailure; |
2702 | 0 | } |
2703 | | |
2704 | 342k | vrange.min = PR_MAX(input->min, effectivePolicyBoundary.min); |
2705 | 342k | vrange.max = PR_MIN(input->max, effectivePolicyBoundary.max); |
2706 | | |
2707 | 342k | if (vrange.max < vrange.min) { |
2708 | | /* there was no overlap, turn off range altogether */ |
2709 | 0 | overlap->min = overlap->max = SSL_LIBRARY_VERSION_NONE; |
2710 | 0 | return SECFailure; |
2711 | 0 | } |
2712 | | |
2713 | 342k | *overlap = vrange; |
2714 | 342k | return SECSuccess; |
2715 | 342k | } |
2716 | | |
2717 | | static PRBool |
2718 | | ssl_VersionIsSupportedByPolicy(SSLProtocolVariant protocolVariant, |
2719 | | SSL3ProtocolVersion version) |
2720 | 69.9k | { |
2721 | 69.9k | SECStatus rv; |
2722 | 69.9k | SSLVersionRange effectivePolicyBoundary; |
2723 | | |
2724 | 69.9k | rv = ssl3_GetEffectiveVersionPolicy(protocolVariant, |
2725 | 69.9k | &effectivePolicyBoundary); |
2726 | 69.9k | if (rv == SECFailure) { |
2727 | | /* SECFailure means internal failure or invalid configuration. */ |
2728 | 0 | return PR_FALSE; |
2729 | 0 | } |
2730 | 69.9k | return version >= effectivePolicyBoundary.min && |
2731 | 69.9k | version <= effectivePolicyBoundary.max; |
2732 | 69.9k | } |
2733 | | |
2734 | | /* |
2735 | | * This is called at SSL init time to constrain the existing range based |
2736 | | * on user supplied policy. |
2737 | | */ |
2738 | | SECStatus |
2739 | | ssl3_ConstrainRangeByPolicy(void) |
2740 | 0 | { |
2741 | | /* We ignore failures in ssl3_CreateOverlapWithPolicy. Although an empty |
2742 | | * overlap disables all connectivity, it's an allowed state. |
2743 | | */ |
2744 | 0 | ssl3_CreateOverlapWithPolicy(ssl_variant_stream, |
2745 | 0 | VERSIONS_DEFAULTS(ssl_variant_stream), |
2746 | 0 | VERSIONS_DEFAULTS(ssl_variant_stream)); |
2747 | 0 | ssl3_CreateOverlapWithPolicy(ssl_variant_datagram, |
2748 | 0 | VERSIONS_DEFAULTS(ssl_variant_datagram), |
2749 | 0 | VERSIONS_DEFAULTS(ssl_variant_datagram)); |
2750 | 0 | return SECSuccess; |
2751 | 0 | } |
2752 | | |
2753 | | PRBool |
2754 | | ssl3_VersionIsSupportedByCode(SSLProtocolVariant protocolVariant, |
2755 | | SSL3ProtocolVersion version) |
2756 | 386k | { |
2757 | 386k | switch (protocolVariant) { |
2758 | 218k | case ssl_variant_stream: |
2759 | 218k | return (version >= SSL_LIBRARY_VERSION_MIN_SUPPORTED_STREAM && |
2760 | 218k | version <= SSL_LIBRARY_VERSION_MAX_SUPPORTED); |
2761 | 168k | case ssl_variant_datagram: |
2762 | 168k | return (version >= SSL_LIBRARY_VERSION_MIN_SUPPORTED_DATAGRAM && |
2763 | 168k | version <= SSL_LIBRARY_VERSION_MAX_SUPPORTED); |
2764 | 386k | } |
2765 | | |
2766 | | /* Can't get here */ |
2767 | 0 | PORT_Assert(PR_FALSE); |
2768 | 0 | return PR_FALSE; |
2769 | 386k | } |
2770 | | |
2771 | | PRBool |
2772 | | ssl3_VersionIsSupported(SSLProtocolVariant protocolVariant, |
2773 | | SSL3ProtocolVersion version) |
2774 | 69.9k | { |
2775 | 69.9k | if (!ssl_VersionIsSupportedByPolicy(protocolVariant, version)) { |
2776 | 96 | return PR_FALSE; |
2777 | 96 | } |
2778 | 69.8k | return ssl3_VersionIsSupportedByCode(protocolVariant, version); |
2779 | 69.9k | } |
2780 | | |
2781 | | const SECItem * |
2782 | | SSL_PeerSignedCertTimestamps(PRFileDesc *fd) |
2783 | 0 | { |
2784 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
2785 | |
|
2786 | 0 | if (!ss) { |
2787 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_PeerSignedCertTimestamps", |
2788 | 0 | SSL_GETPID(), fd)); |
2789 | 0 | return NULL; |
2790 | 0 | } |
2791 | | |
2792 | 0 | if (!ss->sec.ci.sid) { |
2793 | 0 | PORT_SetError(SEC_ERROR_NOT_INITIALIZED); |
2794 | 0 | return NULL; |
2795 | 0 | } |
2796 | | |
2797 | 0 | return &ss->sec.ci.sid->u.ssl3.signedCertTimestamps; |
2798 | 0 | } |
2799 | | |
2800 | | SECStatus |
2801 | | SSL_VersionRangeGetSupported(SSLProtocolVariant protocolVariant, |
2802 | | SSLVersionRange *vrange) |
2803 | 122k | { |
2804 | 122k | SECStatus rv; |
2805 | | |
2806 | 122k | if (!vrange) { |
2807 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2808 | 0 | return SECFailure; |
2809 | 0 | } |
2810 | | |
2811 | 122k | switch (protocolVariant) { |
2812 | 61.2k | case ssl_variant_stream: |
2813 | 61.2k | vrange->min = SSL_LIBRARY_VERSION_MIN_SUPPORTED_STREAM; |
2814 | 61.2k | vrange->max = SSL_LIBRARY_VERSION_MAX_SUPPORTED; |
2815 | | /* We don't allow SSLv3 and TLSv1.3 together. |
2816 | | * However, don't check yet, apply the policy first. |
2817 | | * Because if the effective supported range doesn't use TLS 1.3, |
2818 | | * then we don't need to increase the minimum. */ |
2819 | 61.2k | break; |
2820 | 61.2k | case ssl_variant_datagram: |
2821 | 61.2k | vrange->min = SSL_LIBRARY_VERSION_MIN_SUPPORTED_DATAGRAM; |
2822 | 61.2k | vrange->max = SSL_LIBRARY_VERSION_MAX_SUPPORTED; |
2823 | 61.2k | break; |
2824 | 0 | default: |
2825 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2826 | 0 | return SECFailure; |
2827 | 122k | } |
2828 | | |
2829 | 122k | rv = ssl3_CreateOverlapWithPolicy(protocolVariant, vrange, vrange); |
2830 | 122k | if (rv != SECSuccess) { |
2831 | | /* Library default and policy don't overlap. */ |
2832 | 0 | return rv; |
2833 | 0 | } |
2834 | | |
2835 | | /* We don't allow SSLv3 and TLSv1.3 together */ |
2836 | 122k | if (vrange->max >= SSL_LIBRARY_VERSION_TLS_1_3) { |
2837 | 122k | vrange->min = PR_MAX(vrange->min, SSL_LIBRARY_VERSION_TLS_1_0); |
2838 | 122k | } |
2839 | | |
2840 | 122k | return SECSuccess; |
2841 | 122k | } |
2842 | | |
2843 | | SECStatus |
2844 | | SSL_VersionRangeGetDefault(SSLProtocolVariant protocolVariant, |
2845 | | SSLVersionRange *vrange) |
2846 | 0 | { |
2847 | 0 | if ((protocolVariant != ssl_variant_stream && |
2848 | 0 | protocolVariant != ssl_variant_datagram) || |
2849 | 0 | !vrange) { |
2850 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2851 | 0 | return SECFailure; |
2852 | 0 | } |
2853 | | |
2854 | 0 | *vrange = *VERSIONS_DEFAULTS(protocolVariant); |
2855 | 0 | return ssl3_CreateOverlapWithPolicy(protocolVariant, vrange, vrange); |
2856 | 0 | } |
2857 | | |
2858 | | static PRBool |
2859 | | ssl3_HasConflictingSSLVersions(const SSLVersionRange *vrange) |
2860 | 158k | { |
2861 | 158k | return (vrange->min <= SSL_LIBRARY_VERSION_3_0 && |
2862 | 0 | vrange->max >= SSL_LIBRARY_VERSION_TLS_1_3); |
2863 | 158k | } |
2864 | | |
2865 | | static SECStatus |
2866 | | ssl3_CheckRangeValidAndConstrainByPolicy(SSLProtocolVariant protocolVariant, |
2867 | | SSLVersionRange *vrange) |
2868 | 158k | { |
2869 | 158k | SECStatus rv; |
2870 | | |
2871 | 158k | if (vrange->min > vrange->max || |
2872 | 158k | !ssl3_VersionIsSupportedByCode(protocolVariant, vrange->min) || |
2873 | 158k | !ssl3_VersionIsSupportedByCode(protocolVariant, vrange->max) || |
2874 | 158k | ssl3_HasConflictingSSLVersions(vrange)) { |
2875 | 0 | PORT_SetError(SSL_ERROR_INVALID_VERSION_RANGE); |
2876 | 0 | return SECFailure; |
2877 | 0 | } |
2878 | | |
2879 | | /* Try to adjust the received range using our policy. |
2880 | | * If there's overlap, we'll use the (possibly reduced) range. |
2881 | | * If there isn't overlap, it's failure. */ |
2882 | | |
2883 | 158k | rv = ssl3_CreateOverlapWithPolicy(protocolVariant, vrange, vrange); |
2884 | 158k | if (rv != SECSuccess) { |
2885 | 0 | return rv; |
2886 | 0 | } |
2887 | | |
2888 | | /* We don't allow SSLv3 and TLSv1.3 together */ |
2889 | 158k | if (vrange->max >= SSL_LIBRARY_VERSION_TLS_1_3) { |
2890 | 134k | vrange->min = PR_MAX(vrange->min, SSL_LIBRARY_VERSION_TLS_1_0); |
2891 | 134k | } |
2892 | | |
2893 | 158k | return SECSuccess; |
2894 | 158k | } |
2895 | | |
2896 | | SECStatus |
2897 | | SSL_VersionRangeSetDefault(SSLProtocolVariant protocolVariant, |
2898 | | const SSLVersionRange *vrange) |
2899 | 122k | { |
2900 | 122k | SSLVersionRange constrainedRange; |
2901 | 122k | SECStatus rv; |
2902 | | |
2903 | 122k | if (!vrange) { |
2904 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2905 | 0 | return SECFailure; |
2906 | 0 | } |
2907 | | |
2908 | 122k | constrainedRange = *vrange; |
2909 | 122k | rv = ssl3_CheckRangeValidAndConstrainByPolicy(protocolVariant, |
2910 | 122k | &constrainedRange); |
2911 | 122k | if (rv != SECSuccess) |
2912 | 0 | return rv; |
2913 | | |
2914 | 122k | *VERSIONS_DEFAULTS(protocolVariant) = constrainedRange; |
2915 | 122k | return SECSuccess; |
2916 | 122k | } |
2917 | | |
2918 | | SECStatus |
2919 | | SSL_VersionRangeGet(PRFileDesc *fd, SSLVersionRange *vrange) |
2920 | 0 | { |
2921 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
2922 | |
|
2923 | 0 | if (!ss) { |
2924 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_VersionRangeGet", |
2925 | 0 | SSL_GETPID(), fd)); |
2926 | 0 | return SECFailure; |
2927 | 0 | } |
2928 | | |
2929 | 0 | if (!vrange) { |
2930 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2931 | 0 | return SECFailure; |
2932 | 0 | } |
2933 | | |
2934 | 0 | ssl_Get1stHandshakeLock(ss); |
2935 | 0 | ssl_GetSSL3HandshakeLock(ss); |
2936 | |
|
2937 | 0 | *vrange = ss->vrange; |
2938 | |
|
2939 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
2940 | 0 | ssl_Release1stHandshakeLock(ss); |
2941 | |
|
2942 | 0 | return ssl3_CreateOverlapWithPolicy(ss->protocolVariant, vrange, vrange); |
2943 | 0 | } |
2944 | | |
2945 | | SECStatus |
2946 | | SSL_VersionRangeSet(PRFileDesc *fd, const SSLVersionRange *vrange) |
2947 | 35.8k | { |
2948 | 35.8k | SSLVersionRange constrainedRange; |
2949 | 35.8k | sslSocket *ss; |
2950 | 35.8k | SECStatus rv; |
2951 | | |
2952 | 35.8k | if (!vrange) { |
2953 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
2954 | 0 | return SECFailure; |
2955 | 0 | } |
2956 | | |
2957 | 35.8k | ss = ssl_FindSocket(fd); |
2958 | 35.8k | if (!ss) { |
2959 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_VersionRangeSet", |
2960 | 0 | SSL_GETPID(), fd)); |
2961 | 0 | return SECFailure; |
2962 | 0 | } |
2963 | | |
2964 | 35.8k | constrainedRange = *vrange; |
2965 | 35.8k | rv = ssl3_CheckRangeValidAndConstrainByPolicy(ss->protocolVariant, |
2966 | 35.8k | &constrainedRange); |
2967 | 35.8k | if (rv != SECSuccess) |
2968 | 0 | return rv; |
2969 | | |
2970 | 35.8k | ssl_Get1stHandshakeLock(ss); |
2971 | 35.8k | ssl_GetSSL3HandshakeLock(ss); |
2972 | | |
2973 | 35.8k | if (ss->ssl3.downgradeCheckVersion && |
2974 | 0 | ss->vrange.max > ss->ssl3.downgradeCheckVersion) { |
2975 | 0 | PORT_SetError(SSL_ERROR_INVALID_VERSION_RANGE); |
2976 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
2977 | 0 | ssl_Release1stHandshakeLock(ss); |
2978 | 0 | return SECFailure; |
2979 | 0 | } |
2980 | | |
2981 | 35.8k | ss->vrange = constrainedRange; |
2982 | | |
2983 | 35.8k | ssl_ReleaseSSL3HandshakeLock(ss); |
2984 | 35.8k | ssl_Release1stHandshakeLock(ss); |
2985 | | |
2986 | 35.8k | return SECSuccess; |
2987 | 35.8k | } |
2988 | | |
2989 | | SECStatus |
2990 | | SSL_SetDowngradeCheckVersion(PRFileDesc *fd, PRUint16 version) |
2991 | 0 | { |
2992 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
2993 | 0 | SECStatus rv = SECFailure; |
2994 | |
|
2995 | 0 | if (!ss) { |
2996 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetDowngradeCheckVersion", |
2997 | 0 | SSL_GETPID(), fd)); |
2998 | 0 | return SECFailure; |
2999 | 0 | } |
3000 | | |
3001 | 0 | if (version && !ssl3_VersionIsSupported(ss->protocolVariant, version)) { |
3002 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
3003 | 0 | return SECFailure; |
3004 | 0 | } |
3005 | | |
3006 | 0 | ssl_Get1stHandshakeLock(ss); |
3007 | 0 | ssl_GetSSL3HandshakeLock(ss); |
3008 | |
|
3009 | 0 | if (version && version < ss->vrange.max) { |
3010 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
3011 | 0 | goto loser; |
3012 | 0 | } |
3013 | 0 | ss->ssl3.downgradeCheckVersion = version; |
3014 | 0 | rv = SECSuccess; |
3015 | |
|
3016 | 0 | loser: |
3017 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
3018 | 0 | ssl_Release1stHandshakeLock(ss); |
3019 | |
|
3020 | 0 | return rv; |
3021 | 0 | } |
3022 | | |
3023 | | const SECItemArray * |
3024 | | SSL_PeerStapledOCSPResponses(PRFileDesc *fd) |
3025 | 0 | { |
3026 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
3027 | |
|
3028 | 0 | if (!ss) { |
3029 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_PeerStapledOCSPResponses", |
3030 | 0 | SSL_GETPID(), fd)); |
3031 | 0 | return NULL; |
3032 | 0 | } |
3033 | | |
3034 | 0 | if (!ss->sec.ci.sid) { |
3035 | 0 | PORT_SetError(SEC_ERROR_NOT_INITIALIZED); |
3036 | 0 | return NULL; |
3037 | 0 | } |
3038 | | |
3039 | 0 | return &ss->sec.ci.sid->peerCertStatus; |
3040 | 0 | } |
3041 | | |
3042 | | /************************************************************************/ |
3043 | | /* The following functions are the TOP LEVEL SSL functions. |
3044 | | ** They all get called through the NSPRIOMethods table below. |
3045 | | */ |
3046 | | |
3047 | | static PRFileDesc *PR_CALLBACK |
3048 | | ssl_Accept(PRFileDesc *fd, PRNetAddr *sockaddr, PRIntervalTime timeout) |
3049 | 0 | { |
3050 | 0 | sslSocket *ss; |
3051 | 0 | sslSocket *ns = NULL; |
3052 | 0 | PRFileDesc *newfd = NULL; |
3053 | 0 | PRFileDesc *osfd; |
3054 | 0 | PRStatus status; |
3055 | |
|
3056 | 0 | ss = ssl_GetPrivate(fd); |
3057 | 0 | if (!ss) { |
3058 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in accept", SSL_GETPID(), fd)); |
3059 | 0 | return NULL; |
3060 | 0 | } |
3061 | | |
3062 | | /* IF this is a listen socket, there shouldn't be any I/O going on */ |
3063 | 0 | SSL_LOCK_READER(ss); |
3064 | 0 | SSL_LOCK_WRITER(ss); |
3065 | 0 | ssl_Get1stHandshakeLock(ss); |
3066 | 0 | ssl_GetSSL3HandshakeLock(ss); |
3067 | |
|
3068 | 0 | ss->cTimeout = timeout; |
3069 | |
|
3070 | 0 | osfd = ss->fd->lower; |
3071 | | |
3072 | | /* First accept connection */ |
3073 | 0 | newfd = osfd->methods->accept(osfd, sockaddr, timeout); |
3074 | 0 | if (newfd == NULL) { |
3075 | 0 | SSL_DBG(("%d: SSL[%d]: accept failed, errno=%d", |
3076 | 0 | SSL_GETPID(), ss->fd, PORT_GetError())); |
3077 | 0 | } else { |
3078 | | /* Create ssl module */ |
3079 | 0 | ns = ssl_DupSocket(ss); |
3080 | 0 | } |
3081 | |
|
3082 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
3083 | 0 | ssl_Release1stHandshakeLock(ss); |
3084 | 0 | SSL_UNLOCK_WRITER(ss); |
3085 | 0 | SSL_UNLOCK_READER(ss); /* ss isn't used below here. */ |
3086 | |
|
3087 | 0 | if (ns == NULL) |
3088 | 0 | goto loser; |
3089 | | |
3090 | | /* push ssl module onto the new socket */ |
3091 | 0 | status = ssl_PushIOLayer(ns, newfd, PR_TOP_IO_LAYER); |
3092 | 0 | if (status != PR_SUCCESS) |
3093 | 0 | goto loser; |
3094 | | |
3095 | | /* Now start server connection handshake with client. |
3096 | | ** Don't need locks here because nobody else has a reference to ns yet. |
3097 | | */ |
3098 | 0 | if (ns->opt.useSecurity) { |
3099 | 0 | ns->sec.isServer = !ns->opt.handshakeAsClient; |
3100 | 0 | if (ns->opt.handshakeAsClient) { |
3101 | 0 | ns->handshake = ssl_BeginClientHandshake; |
3102 | 0 | } else { |
3103 | 0 | ns->handshake = ssl_BeginServerHandshake; |
3104 | 0 | } |
3105 | 0 | } |
3106 | 0 | ns->TCPconnected = 1; |
3107 | 0 | return newfd; |
3108 | | |
3109 | 0 | loser: |
3110 | 0 | if (ns != NULL) |
3111 | 0 | ssl_FreeSocket(ns); |
3112 | 0 | if (newfd != NULL) |
3113 | 0 | PR_Close(newfd); |
3114 | 0 | return NULL; |
3115 | 0 | } |
3116 | | |
3117 | | static PRStatus PR_CALLBACK |
3118 | | ssl_Connect(PRFileDesc *fd, const PRNetAddr *sockaddr, PRIntervalTime timeout) |
3119 | 0 | { |
3120 | 0 | sslSocket *ss; |
3121 | 0 | PRStatus rv; |
3122 | |
|
3123 | 0 | ss = ssl_GetPrivate(fd); |
3124 | 0 | if (!ss) { |
3125 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in connect", SSL_GETPID(), fd)); |
3126 | 0 | return PR_FAILURE; |
3127 | 0 | } |
3128 | | |
3129 | | /* IF this is a listen socket, there shouldn't be any I/O going on */ |
3130 | 0 | SSL_LOCK_READER(ss); |
3131 | 0 | SSL_LOCK_WRITER(ss); |
3132 | |
|
3133 | 0 | ss->cTimeout = timeout; |
3134 | 0 | rv = (PRStatus)(*ss->ops->connect)(ss, sockaddr); |
3135 | |
|
3136 | 0 | SSL_UNLOCK_WRITER(ss); |
3137 | 0 | SSL_UNLOCK_READER(ss); |
3138 | |
|
3139 | 0 | return rv; |
3140 | 0 | } |
3141 | | |
3142 | | static PRStatus PR_CALLBACK |
3143 | | ssl_Bind(PRFileDesc *fd, const PRNetAddr *addr) |
3144 | 0 | { |
3145 | 0 | sslSocket *ss = ssl_GetPrivate(fd); |
3146 | 0 | PRStatus rv; |
3147 | |
|
3148 | 0 | if (!ss) { |
3149 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in bind", SSL_GETPID(), fd)); |
3150 | 0 | return PR_FAILURE; |
3151 | 0 | } |
3152 | 0 | SSL_LOCK_READER(ss); |
3153 | 0 | SSL_LOCK_WRITER(ss); |
3154 | |
|
3155 | 0 | rv = (PRStatus)(*ss->ops->bind)(ss, addr); |
3156 | |
|
3157 | 0 | SSL_UNLOCK_WRITER(ss); |
3158 | 0 | SSL_UNLOCK_READER(ss); |
3159 | 0 | return rv; |
3160 | 0 | } |
3161 | | |
3162 | | static PRStatus PR_CALLBACK |
3163 | | ssl_Listen(PRFileDesc *fd, PRIntn backlog) |
3164 | 0 | { |
3165 | 0 | sslSocket *ss = ssl_GetPrivate(fd); |
3166 | 0 | PRStatus rv; |
3167 | |
|
3168 | 0 | if (!ss) { |
3169 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in listen", SSL_GETPID(), fd)); |
3170 | 0 | return PR_FAILURE; |
3171 | 0 | } |
3172 | 0 | SSL_LOCK_READER(ss); |
3173 | 0 | SSL_LOCK_WRITER(ss); |
3174 | |
|
3175 | 0 | rv = (PRStatus)(*ss->ops->listen)(ss, backlog); |
3176 | |
|
3177 | 0 | SSL_UNLOCK_WRITER(ss); |
3178 | 0 | SSL_UNLOCK_READER(ss); |
3179 | 0 | return rv; |
3180 | 0 | } |
3181 | | |
3182 | | static PRStatus PR_CALLBACK |
3183 | | ssl_Shutdown(PRFileDesc *fd, PRIntn how) |
3184 | 0 | { |
3185 | 0 | sslSocket *ss = ssl_GetPrivate(fd); |
3186 | 0 | PRStatus rv; |
3187 | |
|
3188 | 0 | if (!ss) { |
3189 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in shutdown", SSL_GETPID(), fd)); |
3190 | 0 | return PR_FAILURE; |
3191 | 0 | } |
3192 | 0 | if (how == PR_SHUTDOWN_RCV || how == PR_SHUTDOWN_BOTH) { |
3193 | 0 | SSL_LOCK_READER(ss); |
3194 | 0 | } |
3195 | 0 | if (how == PR_SHUTDOWN_SEND || how == PR_SHUTDOWN_BOTH) { |
3196 | 0 | SSL_LOCK_WRITER(ss); |
3197 | 0 | } |
3198 | |
|
3199 | 0 | rv = (PRStatus)(*ss->ops->shutdown)(ss, how); |
3200 | |
|
3201 | 0 | if (how == PR_SHUTDOWN_SEND || how == PR_SHUTDOWN_BOTH) { |
3202 | 0 | SSL_UNLOCK_WRITER(ss); |
3203 | 0 | } |
3204 | 0 | if (how == PR_SHUTDOWN_RCV || how == PR_SHUTDOWN_BOTH) { |
3205 | 0 | SSL_UNLOCK_READER(ss); |
3206 | 0 | } |
3207 | 0 | return rv; |
3208 | 0 | } |
3209 | | |
3210 | | static PRStatus PR_CALLBACK |
3211 | | ssl_Close(PRFileDesc *fd) |
3212 | 61.2k | { |
3213 | 61.2k | sslSocket *ss; |
3214 | 61.2k | PRStatus rv; |
3215 | | |
3216 | 61.2k | ss = ssl_GetPrivate(fd); |
3217 | 61.2k | if (!ss) { |
3218 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in close", SSL_GETPID(), fd)); |
3219 | 0 | return PR_FAILURE; |
3220 | 0 | } |
3221 | | |
3222 | | /* There must not be any I/O going on */ |
3223 | 61.2k | SSL_LOCK_READER(ss); |
3224 | 61.2k | SSL_LOCK_WRITER(ss); |
3225 | | |
3226 | | /* By the time this function returns, |
3227 | | ** ss is an invalid pointer, and the locks to which it points have |
3228 | | ** been unlocked and freed. So, this is the ONE PLACE in all of SSL |
3229 | | ** where the LOCK calls and the corresponding UNLOCK calls are not in |
3230 | | ** the same function scope. The unlock calls are in ssl_FreeSocket(). |
3231 | | */ |
3232 | 61.2k | rv = (PRStatus)(*ss->ops->close)(ss); |
3233 | | |
3234 | 61.2k | return rv; |
3235 | 61.2k | } |
3236 | | |
3237 | | static int PR_CALLBACK |
3238 | | ssl_Recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags, |
3239 | | PRIntervalTime timeout) |
3240 | 0 | { |
3241 | 0 | sslSocket *ss; |
3242 | 0 | int rv; |
3243 | |
|
3244 | 0 | ss = ssl_GetPrivate(fd); |
3245 | 0 | if (!ss) { |
3246 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in recv", SSL_GETPID(), fd)); |
3247 | 0 | return SECFailure; |
3248 | 0 | } |
3249 | 0 | SSL_LOCK_READER(ss); |
3250 | 0 | ss->rTimeout = timeout; |
3251 | 0 | if (!ss->opt.fdx) |
3252 | 0 | ss->wTimeout = timeout; |
3253 | 0 | rv = (*ss->ops->recv)(ss, (unsigned char *)buf, len, flags); |
3254 | 0 | SSL_UNLOCK_READER(ss); |
3255 | 0 | return rv; |
3256 | 0 | } |
3257 | | |
3258 | | static int PR_CALLBACK |
3259 | | ssl_Send(PRFileDesc *fd, const void *buf, PRInt32 len, PRIntn flags, |
3260 | | PRIntervalTime timeout) |
3261 | 0 | { |
3262 | 0 | sslSocket *ss; |
3263 | 0 | int rv; |
3264 | |
|
3265 | 0 | ss = ssl_GetPrivate(fd); |
3266 | 0 | if (!ss) { |
3267 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in send", SSL_GETPID(), fd)); |
3268 | 0 | return SECFailure; |
3269 | 0 | } |
3270 | 0 | SSL_LOCK_WRITER(ss); |
3271 | 0 | ss->wTimeout = timeout; |
3272 | 0 | if (!ss->opt.fdx) |
3273 | 0 | ss->rTimeout = timeout; |
3274 | 0 | rv = (*ss->ops->send)(ss, (const unsigned char *)buf, len, flags); |
3275 | 0 | SSL_UNLOCK_WRITER(ss); |
3276 | 0 | return rv; |
3277 | 0 | } |
3278 | | |
3279 | | static int PR_CALLBACK |
3280 | | ssl_Read(PRFileDesc *fd, void *buf, PRInt32 len) |
3281 | 734k | { |
3282 | 734k | sslSocket *ss; |
3283 | 734k | int rv; |
3284 | | |
3285 | 734k | ss = ssl_GetPrivate(fd); |
3286 | 734k | if (!ss) { |
3287 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in read", SSL_GETPID(), fd)); |
3288 | 0 | return SECFailure; |
3289 | 0 | } |
3290 | 734k | SSL_LOCK_READER(ss); |
3291 | 734k | ss->rTimeout = PR_INTERVAL_NO_TIMEOUT; |
3292 | 734k | if (!ss->opt.fdx) |
3293 | 734k | ss->wTimeout = PR_INTERVAL_NO_TIMEOUT; |
3294 | 734k | rv = (*ss->ops->read)(ss, (unsigned char *)buf, len); |
3295 | 734k | SSL_UNLOCK_READER(ss); |
3296 | 734k | return rv; |
3297 | 734k | } |
3298 | | |
3299 | | static int PR_CALLBACK |
3300 | | ssl_Write(PRFileDesc *fd, const void *buf, PRInt32 len) |
3301 | 731k | { |
3302 | 731k | sslSocket *ss; |
3303 | 731k | int rv; |
3304 | | |
3305 | 731k | ss = ssl_GetPrivate(fd); |
3306 | 731k | if (!ss) { |
3307 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in write", SSL_GETPID(), fd)); |
3308 | 0 | return SECFailure; |
3309 | 0 | } |
3310 | 731k | SSL_LOCK_WRITER(ss); |
3311 | 731k | ss->wTimeout = PR_INTERVAL_NO_TIMEOUT; |
3312 | 731k | if (!ss->opt.fdx) |
3313 | 731k | ss->rTimeout = PR_INTERVAL_NO_TIMEOUT; |
3314 | 731k | rv = (*ss->ops->write)(ss, (const unsigned char *)buf, len); |
3315 | 731k | SSL_UNLOCK_WRITER(ss); |
3316 | 731k | return rv; |
3317 | 731k | } |
3318 | | |
3319 | | static PRStatus PR_CALLBACK |
3320 | | ssl_GetPeerName(PRFileDesc *fd, PRNetAddr *addr) |
3321 | 0 | { |
3322 | 0 | sslSocket *ss; |
3323 | |
|
3324 | 0 | ss = ssl_GetPrivate(fd); |
3325 | 0 | if (!ss) { |
3326 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in getpeername", SSL_GETPID(), fd)); |
3327 | 0 | return PR_FAILURE; |
3328 | 0 | } |
3329 | 0 | return (PRStatus)(*ss->ops->getpeername)(ss, addr); |
3330 | 0 | } |
3331 | | |
3332 | | /* |
3333 | | */ |
3334 | | SECStatus |
3335 | | ssl_GetPeerInfo(sslSocket *ss) |
3336 | 106k | { |
3337 | 106k | PRFileDesc *osfd; |
3338 | 106k | int rv; |
3339 | 106k | PRNetAddr sin; |
3340 | | |
3341 | 106k | osfd = ss->fd->lower; |
3342 | | |
3343 | 106k | PORT_Memset(&sin, 0, sizeof(sin)); |
3344 | 106k | rv = osfd->methods->getpeername(osfd, &sin); |
3345 | 106k | if (rv < 0) { |
3346 | 0 | return SECFailure; |
3347 | 0 | } |
3348 | 106k | ss->TCPconnected = 1; |
3349 | 106k | if (sin.inet.family == PR_AF_INET) { |
3350 | 106k | PR_ConvertIPv4AddrToIPv6(sin.inet.ip, &ss->sec.ci.peer); |
3351 | 106k | ss->sec.ci.port = sin.inet.port; |
3352 | 106k | } else if (sin.ipv6.family == PR_AF_INET6) { |
3353 | 0 | ss->sec.ci.peer = sin.ipv6.ip; |
3354 | 0 | ss->sec.ci.port = sin.ipv6.port; |
3355 | 0 | } else { |
3356 | 0 | PORT_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR); |
3357 | 0 | return SECFailure; |
3358 | 0 | } |
3359 | 106k | return SECSuccess; |
3360 | 106k | } |
3361 | | |
3362 | | static PRStatus PR_CALLBACK |
3363 | | ssl_GetSockName(PRFileDesc *fd, PRNetAddr *name) |
3364 | 0 | { |
3365 | 0 | sslSocket *ss; |
3366 | |
|
3367 | 0 | ss = ssl_GetPrivate(fd); |
3368 | 0 | if (!ss) { |
3369 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in getsockname", SSL_GETPID(), fd)); |
3370 | 0 | return PR_FAILURE; |
3371 | 0 | } |
3372 | 0 | return (PRStatus)(*ss->ops->getsockname)(ss, name); |
3373 | 0 | } |
3374 | | |
3375 | | SECStatus |
3376 | | SSL_SetSockPeerID(PRFileDesc *fd, const char *peerID) |
3377 | 0 | { |
3378 | 0 | sslSocket *ss; |
3379 | |
|
3380 | 0 | ss = ssl_FindSocket(fd); |
3381 | 0 | if (!ss) { |
3382 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetSockPeerID", |
3383 | 0 | SSL_GETPID(), fd)); |
3384 | 0 | return SECFailure; |
3385 | 0 | } |
3386 | | |
3387 | 0 | if (ss->peerID) { |
3388 | 0 | PORT_Free(ss->peerID); |
3389 | 0 | ss->peerID = NULL; |
3390 | 0 | } |
3391 | 0 | if (peerID) |
3392 | 0 | ss->peerID = PORT_Strdup(peerID); |
3393 | 0 | return (ss->peerID || !peerID) ? SECSuccess : SECFailure; |
3394 | 0 | } |
3395 | | |
3396 | 0 | #define PR_POLL_RW (PR_POLL_WRITE | PR_POLL_READ) |
3397 | | |
3398 | | static PRInt16 PR_CALLBACK |
3399 | | ssl_Poll(PRFileDesc *fd, PRInt16 how_flags, PRInt16 *p_out_flags) |
3400 | 0 | { |
3401 | 0 | sslSocket *ss; |
3402 | 0 | PRInt16 new_flags = how_flags; /* should select on these flags. */ |
3403 | 0 | PRNetAddr addr; |
3404 | |
|
3405 | 0 | *p_out_flags = 0; |
3406 | 0 | ss = ssl_GetPrivate(fd); |
3407 | 0 | if (!ss) { |
3408 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_Poll", |
3409 | 0 | SSL_GETPID(), fd)); |
3410 | 0 | return 0; /* don't poll on this socket */ |
3411 | 0 | } |
3412 | | |
3413 | 0 | if (ss->opt.useSecurity && |
3414 | 0 | (ss->handshake || ss->handshakeBegun) && |
3415 | 0 | !ss->firstHsDone && |
3416 | 0 | (how_flags & PR_POLL_RW)) { |
3417 | 0 | if (!ss->TCPconnected) { |
3418 | 0 | ss->TCPconnected = (PR_SUCCESS == ssl_DefGetpeername(ss, &addr)); |
3419 | 0 | } |
3420 | | /* If it's not connected, then presumably the application is polling |
3421 | | ** on read or write appropriately, so don't change it. |
3422 | | */ |
3423 | 0 | if (ss->TCPconnected) { |
3424 | 0 | if (!ss->handshakeBegun) { |
3425 | | /* If the handshake has not begun, poll on read or write |
3426 | | ** based on the local application's role in the handshake, |
3427 | | ** not based on what the application requested. |
3428 | | */ |
3429 | 0 | new_flags &= ~PR_POLL_RW; |
3430 | 0 | if (!ss->sec.isServer) { |
3431 | 0 | new_flags |= PR_POLL_WRITE; |
3432 | 0 | } else { /* handshaking as server */ |
3433 | 0 | new_flags |= PR_POLL_READ; |
3434 | 0 | } |
3435 | 0 | } else if (ss->lastWriteBlocked) { |
3436 | | /* First handshake is in progress */ |
3437 | 0 | if (new_flags & PR_POLL_READ) { |
3438 | | /* The caller is waiting for data to be received, |
3439 | | ** but the initial handshake is blocked on write, or the |
3440 | | ** client's first handshake record has not been written. |
3441 | | ** The code should select on write, not read. |
3442 | | */ |
3443 | 0 | new_flags &= ~PR_POLL_READ; /* don't select on read. */ |
3444 | 0 | new_flags |= PR_POLL_WRITE; /* do select on write. */ |
3445 | 0 | } |
3446 | 0 | } else if (new_flags & PR_POLL_WRITE) { |
3447 | | /* The caller is trying to write, but the handshake is |
3448 | | ** blocked waiting for data to read, and the first |
3449 | | ** handshake has been sent. So do NOT to poll on write |
3450 | | ** unless we did false start or we are doing 0-RTT. |
3451 | | */ |
3452 | 0 | if (!(ss->ssl3.hs.canFalseStart || |
3453 | 0 | ss->ssl3.hs.zeroRttState == ssl_0rtt_sent || |
3454 | 0 | ss->ssl3.hs.zeroRttState == ssl_0rtt_accepted)) { |
3455 | 0 | new_flags &= ~PR_POLL_WRITE; /* don't select on write. */ |
3456 | 0 | } |
3457 | 0 | new_flags |= PR_POLL_READ; /* do select on read. */ |
3458 | 0 | } |
3459 | 0 | } |
3460 | 0 | } else if ((new_flags & PR_POLL_READ) && (SSL_DataPending(fd) > 0)) { |
3461 | 0 | *p_out_flags = PR_POLL_READ; /* it's ready already. */ |
3462 | 0 | return new_flags; |
3463 | 0 | } else if ((ss->lastWriteBlocked) && (how_flags & PR_POLL_READ) && |
3464 | 0 | (ss->pendingBuf.len != 0)) { /* write data waiting to be sent */ |
3465 | 0 | new_flags |= PR_POLL_WRITE; /* also select on write. */ |
3466 | 0 | } |
3467 | | |
3468 | 0 | if (ss->ssl3.hs.restartTarget != NULL) { |
3469 | | /* Read and write will block until the asynchronous callback completes |
3470 | | * (e.g. until SSL_AuthCertificateComplete is called), so don't tell |
3471 | | * the caller to poll the socket unless there is pending write data. |
3472 | | */ |
3473 | 0 | if (ss->lastWriteBlocked && ss->pendingBuf.len != 0) { |
3474 | | /* Ignore any newly-received data on the socket, but do wait for |
3475 | | * the socket to become writable again. Here, it is OK for an error |
3476 | | * to be detected, because our logic for sending pending write data |
3477 | | * will allow us to report the error to the caller without the risk |
3478 | | * of the application spinning. |
3479 | | */ |
3480 | 0 | new_flags &= (PR_POLL_WRITE | PR_POLL_EXCEPT); |
3481 | 0 | } else { |
3482 | | /* Unfortunately, clearing new_flags will make it impossible for |
3483 | | * the application to detect errors that it would otherwise be |
3484 | | * able to detect with PR_POLL_EXCEPT, until the asynchronous |
3485 | | * callback completes. However, we must clear all the flags to |
3486 | | * prevent the application from spinning (alternating between |
3487 | | * calling PR_Poll that would return PR_POLL_EXCEPT, and send/recv |
3488 | | * which won't actually report the I/O error while we are waiting |
3489 | | * for the asynchronous callback to complete). |
3490 | | */ |
3491 | 0 | new_flags = 0; |
3492 | 0 | } |
3493 | 0 | } |
3494 | |
|
3495 | 0 | SSL_TRC(20, ("%d: SSL[%d]: ssl_Poll flags %x -> %x", |
3496 | 0 | SSL_GETPID(), fd, how_flags, new_flags)); |
3497 | |
|
3498 | 0 | if (new_flags && (fd->lower->methods->poll != NULL)) { |
3499 | 0 | PRInt16 lower_out_flags = 0; |
3500 | 0 | PRInt16 lower_new_flags; |
3501 | 0 | lower_new_flags = fd->lower->methods->poll(fd->lower, new_flags, |
3502 | 0 | &lower_out_flags); |
3503 | 0 | if ((lower_new_flags & lower_out_flags) && (how_flags != new_flags)) { |
3504 | 0 | PRInt16 out_flags = lower_out_flags & ~PR_POLL_RW; |
3505 | 0 | if (lower_out_flags & PR_POLL_READ) |
3506 | 0 | out_flags |= PR_POLL_WRITE; |
3507 | 0 | if (lower_out_flags & PR_POLL_WRITE) |
3508 | 0 | out_flags |= PR_POLL_READ; |
3509 | 0 | *p_out_flags = out_flags; |
3510 | 0 | new_flags = how_flags; |
3511 | 0 | } else { |
3512 | 0 | *p_out_flags = lower_out_flags; |
3513 | 0 | new_flags = lower_new_flags; |
3514 | 0 | } |
3515 | 0 | } |
3516 | |
|
3517 | 0 | return new_flags; |
3518 | 0 | } |
3519 | | |
3520 | | static PRInt32 PR_CALLBACK |
3521 | | ssl_TransmitFile(PRFileDesc *sd, PRFileDesc *fd, |
3522 | | const void *headers, PRInt32 hlen, |
3523 | | PRTransmitFileFlags flags, PRIntervalTime timeout) |
3524 | 0 | { |
3525 | 0 | PRSendFileData sfd; |
3526 | |
|
3527 | 0 | sfd.fd = fd; |
3528 | 0 | sfd.file_offset = 0; |
3529 | 0 | sfd.file_nbytes = 0; |
3530 | 0 | sfd.header = headers; |
3531 | 0 | sfd.hlen = hlen; |
3532 | 0 | sfd.trailer = NULL; |
3533 | 0 | sfd.tlen = 0; |
3534 | |
|
3535 | 0 | return sd->methods->sendfile(sd, &sfd, flags, timeout); |
3536 | 0 | } |
3537 | | |
3538 | | PRBool |
3539 | | ssl_FdIsBlocking(PRFileDesc *fd) |
3540 | 816k | { |
3541 | 816k | PRSocketOptionData opt; |
3542 | 816k | PRStatus status; |
3543 | | |
3544 | 816k | opt.option = PR_SockOpt_Nonblocking; |
3545 | 816k | opt.value.non_blocking = PR_FALSE; |
3546 | 816k | status = PR_GetSocketOption(fd, &opt); |
3547 | 816k | if (status != PR_SUCCESS) |
3548 | 0 | return PR_FALSE; |
3549 | 816k | return (PRBool)!opt.value.non_blocking; |
3550 | 816k | } |
3551 | | |
3552 | | PRBool |
3553 | | ssl_SocketIsBlocking(sslSocket *ss) |
3554 | 816k | { |
3555 | 816k | return ssl_FdIsBlocking(ss->fd); |
3556 | 816k | } |
3557 | | |
3558 | | PRInt32 sslFirstBufSize = 8 * 1024; |
3559 | | PRInt32 sslCopyLimit = 1024; |
3560 | | |
3561 | | static PRInt32 PR_CALLBACK |
3562 | | ssl_WriteV(PRFileDesc *fd, const PRIOVec *iov, PRInt32 vectors, |
3563 | | PRIntervalTime timeout) |
3564 | 0 | { |
3565 | 0 | PRInt32 i; |
3566 | 0 | PRInt32 bufLen; |
3567 | 0 | PRInt32 left; |
3568 | 0 | PRInt32 rv; |
3569 | 0 | PRInt32 sent = 0; |
3570 | 0 | const PRInt32 first_len = sslFirstBufSize; |
3571 | 0 | const PRInt32 limit = sslCopyLimit; |
3572 | 0 | PRBool blocking; |
3573 | 0 | PRIOVec myIov; |
3574 | 0 | char buf[MAX_FRAGMENT_LENGTH]; |
3575 | |
|
3576 | 0 | if (vectors < 0) { |
3577 | 0 | PORT_SetError(PR_INVALID_ARGUMENT_ERROR); |
3578 | 0 | return -1; |
3579 | 0 | } |
3580 | 0 | if (vectors > PR_MAX_IOVECTOR_SIZE) { |
3581 | 0 | PORT_SetError(PR_BUFFER_OVERFLOW_ERROR); |
3582 | 0 | return -1; |
3583 | 0 | } |
3584 | 0 | for (i = 0; i < vectors; i++) { |
3585 | 0 | if (iov[i].iov_len < 0) { |
3586 | 0 | PORT_SetError(PR_INVALID_ARGUMENT_ERROR); |
3587 | 0 | return -1; |
3588 | 0 | } |
3589 | 0 | } |
3590 | 0 | blocking = ssl_FdIsBlocking(fd); |
3591 | |
|
3592 | 0 | #define K16 ((int)sizeof(buf)) |
3593 | 0 | #define KILL_VECTORS \ |
3594 | 0 | while (vectors && !iov->iov_len) { \ |
3595 | 0 | ++iov; \ |
3596 | 0 | --vectors; \ |
3597 | 0 | } |
3598 | 0 | #define GET_VECTOR \ |
3599 | 0 | do { \ |
3600 | 0 | myIov = *iov++; \ |
3601 | 0 | --vectors; \ |
3602 | 0 | KILL_VECTORS \ |
3603 | 0 | } while (0) |
3604 | 0 | #define HANDLE_ERR(rv, len) \ |
3605 | 0 | if (rv != len) { \ |
3606 | 0 | if (rv < 0) { \ |
3607 | 0 | if (!blocking && \ |
3608 | 0 | (PR_GetError() == PR_WOULD_BLOCK_ERROR) && \ |
3609 | 0 | (sent > 0)) { \ |
3610 | 0 | return sent; \ |
3611 | 0 | } else { \ |
3612 | 0 | return -1; \ |
3613 | 0 | } \ |
3614 | 0 | } \ |
3615 | | /* Only a nonblocking socket can have partial sends */ \ |
3616 | 0 | PR_ASSERT(!blocking); \ |
3617 | 0 | return sent + rv; \ |
3618 | 0 | } |
3619 | 0 | #define SEND(bfr, len) \ |
3620 | 0 | do { \ |
3621 | 0 | rv = ssl_Send(fd, bfr, len, 0, timeout); \ |
3622 | 0 | HANDLE_ERR(rv, len) \ |
3623 | 0 | sent += len; \ |
3624 | 0 | } while (0) |
3625 | | |
3626 | | /* Make sure the first write is at least 8 KB, if possible. */ |
3627 | 0 | KILL_VECTORS |
3628 | 0 | if (!vectors) |
3629 | 0 | return ssl_Send(fd, 0, 0, 0, timeout); |
3630 | 0 | GET_VECTOR; |
3631 | 0 | if (!vectors) { |
3632 | 0 | return ssl_Send(fd, myIov.iov_base, myIov.iov_len, 0, timeout); |
3633 | 0 | } |
3634 | 0 | if (myIov.iov_len < first_len) { |
3635 | 0 | PORT_Memcpy(buf, myIov.iov_base, myIov.iov_len); |
3636 | 0 | bufLen = myIov.iov_len; |
3637 | 0 | left = first_len - bufLen; |
3638 | 0 | while (vectors && left) { |
3639 | 0 | int toCopy; |
3640 | 0 | GET_VECTOR; |
3641 | 0 | toCopy = PR_MIN(left, myIov.iov_len); |
3642 | 0 | PORT_Memcpy(buf + bufLen, myIov.iov_base, toCopy); |
3643 | 0 | bufLen += toCopy; |
3644 | 0 | left -= toCopy; |
3645 | 0 | myIov.iov_base += toCopy; |
3646 | 0 | myIov.iov_len -= toCopy; |
3647 | 0 | } |
3648 | 0 | SEND(buf, bufLen); |
3649 | 0 | } |
3650 | | |
3651 | 0 | while (vectors || myIov.iov_len) { |
3652 | 0 | PRInt32 addLen; |
3653 | 0 | if (!myIov.iov_len) { |
3654 | 0 | GET_VECTOR; |
3655 | 0 | } |
3656 | 0 | while (myIov.iov_len >= K16) { |
3657 | 0 | SEND(myIov.iov_base, K16); |
3658 | 0 | myIov.iov_base += K16; |
3659 | 0 | myIov.iov_len -= K16; |
3660 | 0 | } |
3661 | 0 | if (!myIov.iov_len) |
3662 | 0 | continue; |
3663 | | |
3664 | 0 | if (!vectors || myIov.iov_len > limit) { |
3665 | 0 | addLen = 0; |
3666 | 0 | } else if ((addLen = iov->iov_len % K16) + myIov.iov_len <= limit) { |
3667 | 0 | /* Addlen is already computed. */; |
3668 | 0 | } else if (vectors > 1 && |
3669 | 0 | iov[1].iov_len % K16 + addLen + myIov.iov_len <= 2 * limit) { |
3670 | 0 | addLen = limit - myIov.iov_len; |
3671 | 0 | } else |
3672 | 0 | addLen = 0; |
3673 | |
|
3674 | 0 | if (!addLen) { |
3675 | 0 | SEND(myIov.iov_base, myIov.iov_len); |
3676 | 0 | myIov.iov_len = 0; |
3677 | 0 | continue; |
3678 | 0 | } |
3679 | 0 | PORT_Memcpy(buf, myIov.iov_base, myIov.iov_len); |
3680 | 0 | bufLen = myIov.iov_len; |
3681 | 0 | do { |
3682 | 0 | GET_VECTOR; |
3683 | 0 | PORT_Memcpy(buf + bufLen, myIov.iov_base, addLen); |
3684 | 0 | myIov.iov_base += addLen; |
3685 | 0 | myIov.iov_len -= addLen; |
3686 | 0 | bufLen += addLen; |
3687 | |
|
3688 | 0 | left = PR_MIN(limit, K16 - bufLen); |
3689 | 0 | if (!vectors /* no more left */ |
3690 | 0 | || myIov.iov_len > 0 /* we didn't use that one all up */ |
3691 | 0 | || bufLen >= K16 /* it's full. */) { |
3692 | 0 | addLen = 0; |
3693 | 0 | } else if ((addLen = iov->iov_len % K16) <= left) { |
3694 | 0 | /* Addlen is already computed. */; |
3695 | 0 | } else if (vectors > 1 && |
3696 | 0 | iov[1].iov_len % K16 + addLen <= left + limit) { |
3697 | 0 | addLen = left; |
3698 | 0 | } else |
3699 | 0 | addLen = 0; |
3700 | |
|
3701 | 0 | } while (addLen); |
3702 | 0 | SEND(buf, bufLen); |
3703 | 0 | } |
3704 | 0 | return sent; |
3705 | 0 | } |
3706 | | |
3707 | | /* |
3708 | | * These functions aren't implemented. |
3709 | | */ |
3710 | | |
3711 | | static PRInt32 PR_CALLBACK |
3712 | | ssl_Available(PRFileDesc *fd) |
3713 | 0 | { |
3714 | 0 | PORT_Assert(0); |
3715 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3716 | 0 | return SECFailure; |
3717 | 0 | } |
3718 | | |
3719 | | static PRInt64 PR_CALLBACK |
3720 | | ssl_Available64(PRFileDesc *fd) |
3721 | 0 | { |
3722 | 0 | PRInt64 res; |
3723 | |
|
3724 | 0 | PORT_Assert(0); |
3725 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3726 | 0 | LL_I2L(res, -1L); |
3727 | 0 | return res; |
3728 | 0 | } |
3729 | | |
3730 | | static PRStatus PR_CALLBACK |
3731 | | ssl_FSync(PRFileDesc *fd) |
3732 | 0 | { |
3733 | 0 | PORT_Assert(0); |
3734 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3735 | 0 | return PR_FAILURE; |
3736 | 0 | } |
3737 | | |
3738 | | static PRInt32 PR_CALLBACK |
3739 | | ssl_Seek(PRFileDesc *fd, PRInt32 offset, PRSeekWhence how) |
3740 | 0 | { |
3741 | 0 | PORT_Assert(0); |
3742 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3743 | 0 | return SECFailure; |
3744 | 0 | } |
3745 | | |
3746 | | static PRInt64 PR_CALLBACK |
3747 | | ssl_Seek64(PRFileDesc *fd, PRInt64 offset, PRSeekWhence how) |
3748 | 0 | { |
3749 | 0 | PRInt64 res; |
3750 | |
|
3751 | 0 | PORT_Assert(0); |
3752 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3753 | 0 | LL_I2L(res, -1L); |
3754 | 0 | return res; |
3755 | 0 | } |
3756 | | |
3757 | | static PRStatus PR_CALLBACK |
3758 | | ssl_FileInfo(PRFileDesc *fd, PRFileInfo *info) |
3759 | 0 | { |
3760 | 0 | PORT_Assert(0); |
3761 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3762 | 0 | return PR_FAILURE; |
3763 | 0 | } |
3764 | | |
3765 | | static PRStatus PR_CALLBACK |
3766 | | ssl_FileInfo64(PRFileDesc *fd, PRFileInfo64 *info) |
3767 | 0 | { |
3768 | 0 | PORT_Assert(0); |
3769 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3770 | 0 | return PR_FAILURE; |
3771 | 0 | } |
3772 | | |
3773 | | static PRInt32 PR_CALLBACK |
3774 | | ssl_RecvFrom(PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, |
3775 | | PRNetAddr *addr, PRIntervalTime timeout) |
3776 | 0 | { |
3777 | 0 | PORT_Assert(0); |
3778 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3779 | 0 | return SECFailure; |
3780 | 0 | } |
3781 | | |
3782 | | static PRInt32 PR_CALLBACK |
3783 | | ssl_SendTo(PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags, |
3784 | | const PRNetAddr *addr, PRIntervalTime timeout) |
3785 | 0 | { |
3786 | 0 | PORT_Assert(0); |
3787 | 0 | PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
3788 | 0 | return SECFailure; |
3789 | 0 | } |
3790 | | |
3791 | | static const PRIOMethods ssl_methods = { |
3792 | | PR_DESC_LAYERED, |
3793 | | ssl_Close, /* close */ |
3794 | | ssl_Read, /* read */ |
3795 | | ssl_Write, /* write */ |
3796 | | ssl_Available, /* available */ |
3797 | | ssl_Available64, /* available64 */ |
3798 | | ssl_FSync, /* fsync */ |
3799 | | ssl_Seek, /* seek */ |
3800 | | ssl_Seek64, /* seek64 */ |
3801 | | ssl_FileInfo, /* fileInfo */ |
3802 | | ssl_FileInfo64, /* fileInfo64 */ |
3803 | | ssl_WriteV, /* writev */ |
3804 | | ssl_Connect, /* connect */ |
3805 | | ssl_Accept, /* accept */ |
3806 | | ssl_Bind, /* bind */ |
3807 | | ssl_Listen, /* listen */ |
3808 | | ssl_Shutdown, /* shutdown */ |
3809 | | ssl_Recv, /* recv */ |
3810 | | ssl_Send, /* send */ |
3811 | | ssl_RecvFrom, /* recvfrom */ |
3812 | | ssl_SendTo, /* sendto */ |
3813 | | ssl_Poll, /* poll */ |
3814 | | PR_EmulateAcceptRead, /* acceptread */ |
3815 | | ssl_TransmitFile, /* transmitfile */ |
3816 | | ssl_GetSockName, /* getsockname */ |
3817 | | ssl_GetPeerName, /* getpeername */ |
3818 | | NULL, /* getsockopt OBSOLETE */ |
3819 | | NULL, /* setsockopt OBSOLETE */ |
3820 | | NULL, /* getsocketoption */ |
3821 | | NULL, /* setsocketoption */ |
3822 | | PR_EmulateSendFile, /* Send a (partial) file with header/trailer*/ |
3823 | | NULL, /* reserved for future use */ |
3824 | | NULL, /* reserved for future use */ |
3825 | | NULL, /* reserved for future use */ |
3826 | | NULL, /* reserved for future use */ |
3827 | | NULL /* reserved for future use */ |
3828 | | }; |
3829 | | |
3830 | | static PRIOMethods combined_methods; |
3831 | | |
3832 | | static void |
3833 | | ssl_SetupIOMethods(void) |
3834 | 9 | { |
3835 | 9 | PRIOMethods *new_methods = &combined_methods; |
3836 | 9 | const PRIOMethods *nspr_methods = PR_GetDefaultIOMethods(); |
3837 | 9 | const PRIOMethods *my_methods = &ssl_methods; |
3838 | | |
3839 | 9 | *new_methods = *nspr_methods; |
3840 | | |
3841 | 9 | new_methods->file_type = my_methods->file_type; |
3842 | 9 | new_methods->close = my_methods->close; |
3843 | 9 | new_methods->read = my_methods->read; |
3844 | 9 | new_methods->write = my_methods->write; |
3845 | 9 | new_methods->available = my_methods->available; |
3846 | 9 | new_methods->available64 = my_methods->available64; |
3847 | 9 | new_methods->fsync = my_methods->fsync; |
3848 | 9 | new_methods->seek = my_methods->seek; |
3849 | 9 | new_methods->seek64 = my_methods->seek64; |
3850 | 9 | new_methods->fileInfo = my_methods->fileInfo; |
3851 | 9 | new_methods->fileInfo64 = my_methods->fileInfo64; |
3852 | 9 | new_methods->writev = my_methods->writev; |
3853 | 9 | new_methods->connect = my_methods->connect; |
3854 | 9 | new_methods->accept = my_methods->accept; |
3855 | 9 | new_methods->bind = my_methods->bind; |
3856 | 9 | new_methods->listen = my_methods->listen; |
3857 | 9 | new_methods->shutdown = my_methods->shutdown; |
3858 | 9 | new_methods->recv = my_methods->recv; |
3859 | 9 | new_methods->send = my_methods->send; |
3860 | 9 | new_methods->recvfrom = my_methods->recvfrom; |
3861 | 9 | new_methods->sendto = my_methods->sendto; |
3862 | 9 | new_methods->poll = my_methods->poll; |
3863 | 9 | new_methods->acceptread = my_methods->acceptread; |
3864 | 9 | new_methods->transmitfile = my_methods->transmitfile; |
3865 | 9 | new_methods->getsockname = my_methods->getsockname; |
3866 | 9 | new_methods->getpeername = my_methods->getpeername; |
3867 | | /* new_methods->getsocketoption = my_methods->getsocketoption; */ |
3868 | | /* new_methods->setsocketoption = my_methods->setsocketoption; */ |
3869 | 9 | new_methods->sendfile = my_methods->sendfile; |
3870 | 9 | } |
3871 | | |
3872 | | static PRCallOnceType initIoLayerOnce; |
3873 | | |
3874 | | static PRStatus |
3875 | | ssl_InitIOLayer(void) |
3876 | 9 | { |
3877 | 9 | ssl_layer_id = PR_GetUniqueIdentity("SSL"); |
3878 | 9 | ssl_SetupIOMethods(); |
3879 | 9 | return PR_SUCCESS; |
3880 | 9 | } |
3881 | | |
3882 | | static PRStatus |
3883 | | ssl_PushIOLayer(sslSocket *ns, PRFileDesc *stack, PRDescIdentity id) |
3884 | 61.2k | { |
3885 | 61.2k | PRFileDesc *layer = NULL; |
3886 | 61.2k | PRStatus status; |
3887 | | |
3888 | 61.2k | status = PR_CallOnce(&initIoLayerOnce, &ssl_InitIOLayer); |
3889 | 61.2k | if (status != PR_SUCCESS) { |
3890 | 0 | goto loser; |
3891 | 0 | } |
3892 | 61.2k | if (ns == NULL) { |
3893 | 0 | goto loser; |
3894 | 0 | } |
3895 | 61.2k | layer = PR_CreateIOLayerStub(ssl_layer_id, &combined_methods); |
3896 | 61.2k | if (layer == NULL) |
3897 | 0 | goto loser; |
3898 | 61.2k | layer->secret = (PRFilePrivate *)ns; |
3899 | | |
3900 | | /* Here, "stack" points to the PRFileDesc on the top of the stack. |
3901 | | ** "layer" points to a new FD that is to be inserted into the stack. |
3902 | | ** If layer is being pushed onto the top of the stack, then |
3903 | | ** PR_PushIOLayer switches the contents of stack and layer, and then |
3904 | | ** puts stack on top of layer, so that after it is done, the top of |
3905 | | ** stack is the same "stack" as it was before, and layer is now the |
3906 | | ** FD for the former top of stack. |
3907 | | ** After this call, stack always points to the top PRFD on the stack. |
3908 | | ** If this function fails, the contents of stack and layer are as |
3909 | | ** they were before the call. |
3910 | | */ |
3911 | 61.2k | status = PR_PushIOLayer(stack, id, layer); |
3912 | 61.2k | if (status != PR_SUCCESS) |
3913 | 0 | goto loser; |
3914 | | |
3915 | 61.2k | ns->fd = (id == PR_TOP_IO_LAYER) ? stack : layer; |
3916 | 61.2k | return PR_SUCCESS; |
3917 | | |
3918 | 0 | loser: |
3919 | 0 | if (layer) { |
3920 | 0 | layer->dtor(layer); /* free layer */ |
3921 | 0 | } |
3922 | 0 | return PR_FAILURE; |
3923 | 61.2k | } |
3924 | | |
3925 | | /* if this fails, caller must destroy socket. */ |
3926 | | static SECStatus |
3927 | | ssl_MakeLocks(sslSocket *ss) |
3928 | 61.2k | { |
3929 | 61.2k | PR_ASSERT(!ss->firstHandshakeLock); |
3930 | 61.2k | ss->firstHandshakeLock = PR_NewMonitor(); |
3931 | 61.2k | if (!ss->firstHandshakeLock) |
3932 | 0 | goto loser; |
3933 | | |
3934 | 61.2k | PR_ASSERT(!ss->ssl3HandshakeLock); |
3935 | 61.2k | ss->ssl3HandshakeLock = PR_NewMonitor(); |
3936 | 61.2k | if (!ss->ssl3HandshakeLock) |
3937 | 0 | goto loser; |
3938 | | |
3939 | 61.2k | PR_ASSERT(!ss->specLock); |
3940 | 61.2k | ss->specLock = NSSRWLock_New(SSL_LOCK_RANK_SPEC, NULL); |
3941 | 61.2k | if (!ss->specLock) |
3942 | 0 | goto loser; |
3943 | | |
3944 | 61.2k | PR_ASSERT(!ss->recvBufLock); |
3945 | 61.2k | ss->recvBufLock = PR_NewMonitor(); |
3946 | 61.2k | if (!ss->recvBufLock) |
3947 | 0 | goto loser; |
3948 | | |
3949 | 61.2k | PR_ASSERT(!ss->xmitBufLock); |
3950 | 61.2k | ss->xmitBufLock = PR_NewMonitor(); |
3951 | 61.2k | if (!ss->xmitBufLock) |
3952 | 0 | goto loser; |
3953 | 61.2k | ss->writerThread = NULL; |
3954 | 61.2k | if (ssl_lock_readers) { |
3955 | 61.2k | PR_ASSERT(!ss->recvLock); |
3956 | 61.2k | ss->recvLock = PR_NewLock(); |
3957 | 61.2k | if (!ss->recvLock) |
3958 | 0 | goto loser; |
3959 | | |
3960 | 61.2k | PR_ASSERT(!ss->sendLock); |
3961 | 61.2k | ss->sendLock = PR_NewLock(); |
3962 | 61.2k | if (!ss->sendLock) |
3963 | 0 | goto loser; |
3964 | 61.2k | } |
3965 | 61.2k | return SECSuccess; |
3966 | 0 | loser: |
3967 | 0 | ssl_DestroyLocks(ss); |
3968 | 0 | return SECFailure; |
3969 | 61.2k | } |
3970 | | |
3971 | | #if defined(XP_UNIX) || defined(XP_WIN32) |
3972 | | #define NSS_HAVE_GETENV 1 |
3973 | | #endif |
3974 | | |
3975 | 0 | #define LOWER(x) (x | 0x20) /* cheap ToLower function ignores LOCALE */ |
3976 | | |
3977 | | static PRStatus |
3978 | | ssl_SetDefaultsFromEnvironmentCallOnce(void) |
3979 | 9 | { |
3980 | 9 | #if defined(NSS_HAVE_GETENV) |
3981 | 9 | char *ev; |
3982 | 9 | #ifdef DEBUG |
3983 | 9 | ssl_trace_iob = NULL; |
3984 | 9 | ev = PR_GetEnvSecure("SSLDEBUGFILE"); |
3985 | 9 | if (ev && ev[0]) { |
3986 | 0 | ssl_trace_iob = fopen(ev, "w"); |
3987 | 0 | } |
3988 | 9 | if (!ssl_trace_iob) { |
3989 | 9 | ssl_trace_iob = stderr; |
3990 | 9 | } |
3991 | 9 | #ifdef TRACE |
3992 | 9 | ev = PR_GetEnvSecure("SSLTRACE"); |
3993 | 9 | if (ev && ev[0]) { |
3994 | 0 | ssl_trace = atoi(ev); |
3995 | 0 | SSL_TRACE(("SSL: tracing set to %d", ssl_trace)); |
3996 | 0 | } |
3997 | 9 | #endif /* TRACE */ |
3998 | 9 | ev = PR_GetEnvSecure("SSLDEBUG"); |
3999 | 9 | if (ev && ev[0]) { |
4000 | 0 | ssl_debug = atoi(ev); |
4001 | 0 | SSL_TRACE(("SSL: debugging set to %d", ssl_debug)); |
4002 | 0 | } |
4003 | 9 | #endif /* DEBUG */ |
4004 | 9 | #ifdef NSS_ALLOW_SSLKEYLOGFILE |
4005 | 9 | ssl_keylog_iob = NULL; |
4006 | 9 | ev = PR_GetEnvSecure("SSLKEYLOGFILE"); |
4007 | 9 | if (ev && ev[0]) { |
4008 | 0 | ssl_keylog_iob = fopen(ev, "a"); |
4009 | 0 | if (!ssl_keylog_iob) { |
4010 | 0 | SSL_TRACE(("SSL: failed to open key log file")); |
4011 | 0 | } else { |
4012 | 0 | if (ftell(ssl_keylog_iob) == 0) { |
4013 | 0 | fputs("# SSL/TLS secrets log file, generated by NSS\n", |
4014 | 0 | ssl_keylog_iob); |
4015 | 0 | } |
4016 | 0 | SSL_TRACE(("SSL: logging SSL/TLS secrets to %s", ev)); |
4017 | 0 | ssl_keylog_lock = PR_NewLock(); |
4018 | 0 | if (!ssl_keylog_lock) { |
4019 | 0 | SSL_TRACE(("SSL: failed to create key log lock")); |
4020 | 0 | fclose(ssl_keylog_iob); |
4021 | 0 | ssl_keylog_iob = NULL; |
4022 | 0 | } |
4023 | 0 | } |
4024 | 0 | } |
4025 | 9 | #endif |
4026 | 9 | ev = PR_GetEnvSecure("SSLFORCELOCKS"); |
4027 | 9 | if (ev && ev[0] == '1') { |
4028 | 0 | ssl_force_locks = PR_TRUE; |
4029 | 0 | ssl_defaults.noLocks = 0; |
4030 | 0 | SSL_TRACE(("SSL: force_locks set to %d", ssl_force_locks)); |
4031 | 0 | } |
4032 | 9 | ev = PR_GetEnvSecure("NSS_SSL_ENABLE_RENEGOTIATION"); |
4033 | 9 | if (ev) { |
4034 | 0 | if (ev[0] == '1' || LOWER(ev[0]) == 'u') |
4035 | 0 | ssl_defaults.enableRenegotiation = SSL_RENEGOTIATE_UNRESTRICTED; |
4036 | 0 | else if (ev[0] == '0' || LOWER(ev[0]) == 'n') |
4037 | 0 | ssl_defaults.enableRenegotiation = SSL_RENEGOTIATE_NEVER; |
4038 | 0 | else if (ev[0] == '2' || LOWER(ev[0]) == 'r') |
4039 | 0 | ssl_defaults.enableRenegotiation = SSL_RENEGOTIATE_REQUIRES_XTN; |
4040 | 0 | else if (ev[0] == '3' || LOWER(ev[0]) == 't') |
4041 | 0 | ssl_defaults.enableRenegotiation = SSL_RENEGOTIATE_TRANSITIONAL; |
4042 | 0 | SSL_TRACE(("SSL: enableRenegotiation set to %d", |
4043 | 0 | ssl_defaults.enableRenegotiation)); |
4044 | 0 | } |
4045 | 9 | ev = PR_GetEnvSecure("NSS_SSL_REQUIRE_SAFE_NEGOTIATION"); |
4046 | 9 | if (ev && ev[0] == '1') { |
4047 | 0 | ssl_defaults.requireSafeNegotiation = PR_TRUE; |
4048 | 0 | SSL_TRACE(("SSL: requireSafeNegotiation set to %d", |
4049 | 0 | PR_TRUE)); |
4050 | 0 | } |
4051 | 9 | ev = PR_GetEnvSecure("NSS_SSL_CBC_RANDOM_IV"); |
4052 | 9 | if (ev && ev[0] == '0') { |
4053 | 0 | ssl_defaults.cbcRandomIV = PR_FALSE; |
4054 | 0 | SSL_TRACE(("SSL: cbcRandomIV set to 0")); |
4055 | 0 | } |
4056 | 9 | #endif /* NSS_HAVE_GETENV */ |
4057 | 9 | return PR_SUCCESS; |
4058 | 9 | } |
4059 | | |
4060 | | static void |
4061 | | ssl_SetDefaultsFromEnvironment(void) |
4062 | 61.2k | { |
4063 | 61.2k | PR_CallOnce(&ssl_setDefaultsFromEnvironment, ssl_SetDefaultsFromEnvironmentCallOnce); |
4064 | 61.2k | } |
4065 | | |
4066 | | const sslNamedGroupDef * |
4067 | | ssl_LookupNamedGroup(SSLNamedGroup group) |
4068 | 96.7k | { |
4069 | 96.7k | unsigned int i; |
4070 | | |
4071 | 1.34M | for (i = 0; i < SSL_NAMED_GROUP_COUNT; ++i) { |
4072 | 1.31M | if (ssl_named_groups[i].name == group) { |
4073 | 70.1k | return &ssl_named_groups[i]; |
4074 | 70.1k | } |
4075 | 1.31M | } |
4076 | 26.5k | return NULL; |
4077 | 96.7k | } |
4078 | | |
4079 | | PRBool |
4080 | | ssl_NamedGroupEnabled(const sslSocket *ss, const sslNamedGroupDef *groupDef) |
4081 | 1.11M | { |
4082 | 1.11M | unsigned int i; |
4083 | | |
4084 | 1.11M | if (!groupDef) { |
4085 | 6 | return PR_FALSE; |
4086 | 6 | } |
4087 | | |
4088 | 7.62M | for (i = 0; i < SSL_NAMED_GROUP_COUNT; ++i) { |
4089 | 7.49M | if (ss->namedGroupPreferences[i] && |
4090 | 2.52M | ss->namedGroupPreferences[i] == groupDef) { |
4091 | 992k | return PR_TRUE; |
4092 | 992k | } |
4093 | 7.49M | } |
4094 | 126k | return PR_FALSE; |
4095 | 1.11M | } |
4096 | | |
4097 | | /* Returns a reference counted object that contains a key pair. |
4098 | | * Or NULL on failure. Initial ref count is 1. |
4099 | | * Uses the keys in the pair as input. Adopts the keys given. |
4100 | | */ |
4101 | | sslKeyPair * |
4102 | | ssl_NewKeyPair(SECKEYPrivateKey *privKey, SECKEYPublicKey *pubKey) |
4103 | 89.0k | { |
4104 | 89.0k | sslKeyPair *pair; |
4105 | | |
4106 | 89.0k | if (!privKey || !pubKey) { |
4107 | 0 | PORT_SetError(PR_INVALID_ARGUMENT_ERROR); |
4108 | 0 | return NULL; |
4109 | 0 | } |
4110 | 89.0k | pair = PORT_ZNew(sslKeyPair); |
4111 | 89.0k | if (!pair) |
4112 | 0 | return NULL; /* error code is set. */ |
4113 | 89.0k | pair->privKey = privKey; |
4114 | 89.0k | pair->pubKey = pubKey; |
4115 | 89.0k | pair->refCount = 1; |
4116 | 89.0k | return pair; /* success */ |
4117 | 89.0k | } |
4118 | | |
4119 | | sslKeyPair * |
4120 | | ssl_GetKeyPairRef(sslKeyPair *keyPair) |
4121 | 124k | { |
4122 | 124k | PRInt32 newCount = PR_ATOMIC_INCREMENT(&keyPair->refCount); |
4123 | 124k | PORT_ReleaseAssert(newCount > 1); |
4124 | 124k | return keyPair; |
4125 | 124k | } |
4126 | | |
4127 | | void |
4128 | | ssl_FreeKeyPair(sslKeyPair *keyPair) |
4129 | 277k | { |
4130 | 277k | if (!keyPair) { |
4131 | 63.1k | return; |
4132 | 63.1k | } |
4133 | | |
4134 | 213k | PRInt32 newCount = PR_ATOMIC_DECREMENT(&keyPair->refCount); |
4135 | 213k | PORT_ReleaseAssert(newCount >= 0); |
4136 | 213k | if (!newCount) { |
4137 | 89.0k | SECKEY_DestroyPrivateKey(keyPair->privKey); |
4138 | 89.0k | SECKEY_DestroyPublicKey(keyPair->pubKey); |
4139 | 89.0k | PORT_Free(keyPair); |
4140 | 89.0k | } |
4141 | 213k | } |
4142 | | |
4143 | | /* Ephemeral key handling. */ |
4144 | | |
4145 | | /* Allocate an ephemeral key pair for a group, taking ownership of an |
4146 | | * already-built sslKeyPair. `keys` may be NULL, e.g. for a standalone KEM |
4147 | | * group that has no ECDH key pair and populates the kemKeys/kemCt fields |
4148 | | * separately. */ |
4149 | | sslEphemeralKeyPair * |
4150 | | ssl_NewEphemeralKeyPairWithKeys(const sslNamedGroupDef *group, sslKeyPair *keys) |
4151 | 76.0k | { |
4152 | 76.0k | sslEphemeralKeyPair *pair; |
4153 | | |
4154 | 76.0k | if (!group) { |
4155 | 0 | PORT_SetError(PR_INVALID_ARGUMENT_ERROR); |
4156 | 0 | return NULL; |
4157 | 0 | } |
4158 | | |
4159 | 76.0k | pair = PORT_ZNew(sslEphemeralKeyPair); |
4160 | 76.0k | if (!pair) { |
4161 | 0 | return NULL; /* error already set */ |
4162 | 0 | } |
4163 | | |
4164 | 76.0k | PR_INIT_CLIST(&pair->link); |
4165 | 76.0k | pair->group = group; |
4166 | 76.0k | pair->keys = keys; |
4167 | 76.0k | pair->kemKeys = NULL; |
4168 | 76.0k | pair->kemCt = NULL; |
4169 | | |
4170 | 76.0k | return pair; |
4171 | 76.0k | } |
4172 | | |
4173 | | sslEphemeralKeyPair * |
4174 | | ssl_NewEphemeralKeyPair(const sslNamedGroupDef *group, |
4175 | | SECKEYPrivateKey *privKey, SECKEYPublicKey *pubKey) |
4176 | 76.0k | { |
4177 | 76.0k | sslKeyPair *keys; |
4178 | 76.0k | sslEphemeralKeyPair *pair; |
4179 | | |
4180 | 76.0k | keys = ssl_NewKeyPair(privKey, pubKey); |
4181 | 76.0k | if (!keys) { |
4182 | 0 | return NULL; |
4183 | 0 | } |
4184 | | |
4185 | 76.0k | pair = ssl_NewEphemeralKeyPairWithKeys(group, keys); |
4186 | 76.0k | if (!pair) { |
4187 | 0 | ssl_FreeKeyPair(keys); |
4188 | 0 | return NULL; /* error already set */ |
4189 | 0 | } |
4190 | | |
4191 | 76.0k | return pair; |
4192 | 76.0k | } |
4193 | | |
4194 | | sslEphemeralKeyPair * |
4195 | | ssl_CopyEphemeralKeyPair(sslEphemeralKeyPair *keyPair) |
4196 | 0 | { |
4197 | 0 | sslEphemeralKeyPair *pair; |
4198 | |
|
4199 | 0 | pair = PORT_ZNew(sslEphemeralKeyPair); |
4200 | 0 | if (!pair) { |
4201 | 0 | return NULL; /* error already set */ |
4202 | 0 | } |
4203 | | |
4204 | 0 | pair->kemCt = NULL; |
4205 | 0 | if (keyPair->kemCt) { |
4206 | 0 | pair->kemCt = SECITEM_DupItem(keyPair->kemCt); |
4207 | 0 | if (!pair->kemCt) { |
4208 | 0 | PORT_Free(pair); |
4209 | 0 | return NULL; |
4210 | 0 | } |
4211 | 0 | } |
4212 | | |
4213 | 0 | PR_INIT_CLIST(&pair->link); |
4214 | 0 | pair->group = keyPair->group; |
4215 | 0 | pair->keys = ssl_GetKeyPairRef(keyPair->keys); |
4216 | 0 | pair->kemKeys = keyPair->kemKeys ? ssl_GetKeyPairRef(keyPair->kemKeys) : NULL; |
4217 | |
|
4218 | 0 | return pair; |
4219 | 0 | } |
4220 | | |
4221 | | void |
4222 | | ssl_FreeEphemeralKeyPair(sslEphemeralKeyPair *keyPair) |
4223 | 76.0k | { |
4224 | 76.0k | if (!keyPair) { |
4225 | 0 | return; |
4226 | 0 | } |
4227 | | |
4228 | 76.0k | ssl_FreeKeyPair(keyPair->keys); |
4229 | 76.0k | ssl_FreeKeyPair(keyPair->kemKeys); |
4230 | 76.0k | SECITEM_FreeItem(keyPair->kemCt, PR_TRUE); |
4231 | 76.0k | PR_REMOVE_LINK(&keyPair->link); |
4232 | 76.0k | PORT_Free(keyPair); |
4233 | 76.0k | } |
4234 | | |
4235 | | PRBool |
4236 | | ssl_HaveEphemeralKeyPair(const sslSocket *ss, const sslNamedGroupDef *groupDef) |
4237 | 2.84k | { |
4238 | 2.84k | return ssl_LookupEphemeralKeyPair((sslSocket *)ss, groupDef) != NULL; |
4239 | 2.84k | } |
4240 | | |
4241 | | sslEphemeralKeyPair * |
4242 | | ssl_LookupEphemeralKeyPair(sslSocket *ss, const sslNamedGroupDef *groupDef) |
4243 | 21.3k | { |
4244 | 21.3k | PRCList *cursor; |
4245 | 21.3k | for (cursor = PR_NEXT_LINK(&ss->ephemeralKeyPairs); |
4246 | 24.2k | cursor != &ss->ephemeralKeyPairs; |
4247 | 21.3k | cursor = PR_NEXT_LINK(cursor)) { |
4248 | 5.29k | sslEphemeralKeyPair *keyPair = (sslEphemeralKeyPair *)cursor; |
4249 | 5.29k | if (keyPair->group == groupDef) { |
4250 | 2.43k | return keyPair; |
4251 | 2.43k | } |
4252 | 5.29k | } |
4253 | 18.9k | return NULL; |
4254 | 21.3k | } |
4255 | | |
4256 | | void |
4257 | | ssl_FreeEphemeralKeyPairs(sslSocket *ss) |
4258 | 250k | { |
4259 | 296k | while (!PR_CLIST_IS_EMPTY(&ss->ephemeralKeyPairs)) { |
4260 | 46.0k | PRCList *cursor = PR_LIST_TAIL(&ss->ephemeralKeyPairs); |
4261 | 46.0k | ssl_FreeEphemeralKeyPair((sslEphemeralKeyPair *)cursor); |
4262 | 46.0k | } |
4263 | 250k | } |
4264 | | |
4265 | | PRTime |
4266 | | ssl_Time(const sslSocket *ss) |
4267 | 157k | { |
4268 | 157k | if (!ss->now) { |
4269 | 0 | return PR_Now(); |
4270 | 0 | } |
4271 | 157k | return ss->now(ss->nowArg); |
4272 | 157k | } |
4273 | | |
4274 | | /* |
4275 | | ** Create a newsocket structure for a file descriptor. |
4276 | | */ |
4277 | | static sslSocket * |
4278 | | ssl_NewSocket(PRBool makeLocks, SSLProtocolVariant protocolVariant) |
4279 | 61.2k | { |
4280 | 61.2k | SECStatus rv; |
4281 | 61.2k | sslSocket *ss; |
4282 | 61.2k | int i; |
4283 | 61.2k | ssl_SetDefaultsFromEnvironment(); |
4284 | | |
4285 | 61.2k | if (ssl_force_locks) |
4286 | 0 | makeLocks = PR_TRUE; |
4287 | | |
4288 | | /* Make a new socket and get it ready */ |
4289 | 61.2k | ss = PORT_ZNew(sslSocket); |
4290 | 61.2k | if (!ss) { |
4291 | 0 | return NULL; |
4292 | 0 | } |
4293 | 61.2k | ss->opt = ssl_defaults; |
4294 | 61.2k | if (protocolVariant == ssl_variant_datagram) { |
4295 | 29.4k | ss->opt.enableRenegotiation = SSL_RENEGOTIATE_NEVER; |
4296 | 29.4k | ss->opt.suppressEndOfEarlyData = PR_FALSE; |
4297 | 29.4k | } |
4298 | 61.2k | ss->opt.useSocks = PR_FALSE; |
4299 | 61.2k | ss->opt.noLocks = !makeLocks; |
4300 | 61.2k | ss->vrange = *VERSIONS_DEFAULTS(protocolVariant); |
4301 | 61.2k | ss->protocolVariant = protocolVariant; |
4302 | | /* Ignore overlap failures, because returning NULL would trigger assertion |
4303 | | * failures elsewhere. We don't want this scenario to be fatal, it's just |
4304 | | * a state where no SSL connectivity is possible. */ |
4305 | 61.2k | ssl3_CreateOverlapWithPolicy(ss->protocolVariant, &ss->vrange, &ss->vrange); |
4306 | 61.2k | ss->peerID = NULL; |
4307 | 61.2k | ss->rTimeout = PR_INTERVAL_NO_TIMEOUT; |
4308 | 61.2k | ss->wTimeout = PR_INTERVAL_NO_TIMEOUT; |
4309 | 61.2k | ss->cTimeout = PR_INTERVAL_NO_TIMEOUT; |
4310 | 61.2k | ss->url = NULL; |
4311 | | |
4312 | 61.2k | PR_INIT_CLIST(&ss->serverCerts); |
4313 | 61.2k | PR_INIT_CLIST(&ss->ephemeralKeyPairs); |
4314 | 61.2k | PR_INIT_CLIST(&ss->extensionHooks); |
4315 | 61.2k | PR_INIT_CLIST(&ss->echConfigs); |
4316 | | |
4317 | 61.2k | ss->dbHandle = CERT_GetDefaultCertDB(); |
4318 | | |
4319 | | /* Provide default implementation of hooks */ |
4320 | 61.2k | ss->authCertificate = SSL_AuthCertificate; |
4321 | 61.2k | ss->authCertificateArg = (void *)ss->dbHandle; |
4322 | 61.2k | ss->sniSocketConfig = NULL; |
4323 | 61.2k | ss->sniSocketConfigArg = NULL; |
4324 | 61.2k | ss->getClientAuthData = NULL; |
4325 | 61.2k | ss->alertReceivedCallback = NULL; |
4326 | 61.2k | ss->alertReceivedCallbackArg = NULL; |
4327 | 61.2k | ss->alertSentCallback = NULL; |
4328 | 61.2k | ss->alertSentCallbackArg = NULL; |
4329 | 61.2k | ss->handleBadCert = NULL; |
4330 | 61.2k | ss->badCertArg = NULL; |
4331 | 61.2k | ss->pkcs11PinArg = NULL; |
4332 | | |
4333 | 61.2k | ssl_ChooseOps(ss); |
4334 | 61.2k | ssl3_InitSocketPolicy(ss); |
4335 | 2.20M | for (i = 0; i < SSL_NAMED_GROUP_COUNT; ++i) { |
4336 | 2.14M | ss->namedGroupPreferences[i] = &ssl_named_groups[i]; |
4337 | 2.14M | } |
4338 | 61.2k | ss->additionalShares = 0; |
4339 | 61.2k | PR_INIT_CLIST(&ss->ssl3.hs.remoteExtensions); |
4340 | 61.2k | PR_INIT_CLIST(&ss->ssl3.hs.echOuterExtensions); |
4341 | 61.2k | PR_INIT_CLIST(&ss->ssl3.hs.lastMessageFlight); |
4342 | 61.2k | PR_INIT_CLIST(&ss->ssl3.hs.cipherSpecs); |
4343 | 61.2k | PR_INIT_CLIST(&ss->ssl3.hs.bufferedEarlyData); |
4344 | 61.2k | ssl3_InitExtensionData(&ss->xtnData, ss); |
4345 | 61.2k | PR_INIT_CLIST(&ss->ssl3.hs.dtlsSentHandshake); |
4346 | 61.2k | PR_INIT_CLIST(&ss->ssl3.hs.dtlsRcvdHandshake); |
4347 | 61.2k | PR_INIT_CLIST(&ss->ssl3.hs.psks); |
4348 | 61.2k | dtls_InitTimers(ss); |
4349 | | |
4350 | 61.2k | ss->echPrivKey = NULL; |
4351 | 61.2k | ss->echPubKey = NULL; |
4352 | 61.2k | ss->antiReplay = NULL; |
4353 | 61.2k | ss->psk = NULL; |
4354 | | |
4355 | 61.2k | if (makeLocks) { |
4356 | 61.2k | rv = ssl_MakeLocks(ss); |
4357 | 61.2k | if (rv != SECSuccess) |
4358 | 0 | goto loser; |
4359 | 61.2k | } |
4360 | 61.2k | rv = ssl_CreateSecurityInfo(ss); |
4361 | 61.2k | if (rv != SECSuccess) |
4362 | 0 | goto loser; |
4363 | 61.2k | rv = ssl3_InitGather(&ss->gs); |
4364 | 61.2k | if (rv != SECSuccess) |
4365 | 0 | goto loser; |
4366 | 61.2k | rv = ssl3_InitState(ss); |
4367 | 61.2k | if (rv != SECSuccess) { |
4368 | 0 | goto loser; |
4369 | 0 | } |
4370 | 61.2k | return ss; |
4371 | | |
4372 | 0 | loser: |
4373 | 0 | ssl_DestroySocketContents(ss); |
4374 | 0 | ssl_DestroyLocks(ss); |
4375 | 0 | PORT_Free(ss); |
4376 | 0 | return NULL; |
4377 | 61.2k | } |
4378 | | |
4379 | | /** |
4380 | | * DEPRECATED: Will always return false. |
4381 | | */ |
4382 | | SECStatus |
4383 | | SSL_CanBypass(CERTCertificate *cert, SECKEYPrivateKey *srvPrivkey, |
4384 | | PRUint32 protocolmask, PRUint16 *ciphersuites, int nsuites, |
4385 | | PRBool *pcanbypass, void *pwArg) |
4386 | 0 | { |
4387 | 0 | if (!pcanbypass) { |
4388 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
4389 | 0 | return SECFailure; |
4390 | 0 | } |
4391 | 0 | *pcanbypass = PR_FALSE; |
4392 | 0 | return SECSuccess; |
4393 | 0 | } |
4394 | | |
4395 | | /* Functions that are truly experimental use EXP, functions that are no longer |
4396 | | * experimental use PUB. |
4397 | | * |
4398 | | * When initially defining a new API, add that API here using the EXP() macro |
4399 | | * and name the function with a SSLExp_ prefix. Define the experimental API as |
4400 | | * a macro in sslexp.h using the SSL_EXPERIMENTAL_API() macro defined there. |
4401 | | * |
4402 | | * Once an API is stable and proven, move the macro definition in sslexp.h to a |
4403 | | * proper function declaration in ssl.h. Keeping the function in this list |
4404 | | * ensures that code built against the release that contained the experimental |
4405 | | * API will continue to work; use PUB() to reference the public function. |
4406 | | */ |
4407 | | #define EXP(n) \ |
4408 | | { \ |
4409 | | "SSL_" #n, SSLExp_##n \ |
4410 | | } |
4411 | | #define PUB(n) \ |
4412 | | { \ |
4413 | | "SSL_" #n, SSL_##n \ |
4414 | | } |
4415 | | struct { |
4416 | | const char *const name; |
4417 | | void *function; |
4418 | | } ssl_experimental_functions[] = { |
4419 | | #ifndef SSL_DISABLE_EXPERIMENTAL_API |
4420 | | EXP(AddExternalPsk), |
4421 | | EXP(AddExternalPsk0Rtt), |
4422 | | EXP(AeadDecrypt), |
4423 | | EXP(AeadEncrypt), |
4424 | | EXP(CallExtensionWriterOnEchInner), |
4425 | | EXP(CipherSuiteOrderGet), |
4426 | | EXP(CipherSuiteOrderSet), |
4427 | | EXP(CreateAntiReplayContext), |
4428 | | EXP(CreateMask), |
4429 | | EXP(CreateMaskingContext), |
4430 | | EXP(CreateVariantMaskingContext), |
4431 | | EXP(DelegateCredential), |
4432 | | EXP(DestroyAead), |
4433 | | EXP(DestroyMaskingContext), |
4434 | | EXP(DestroyResumptionTokenInfo), |
4435 | | EXP(EnablePlaintextResumptionExport), |
4436 | | EXP(EnableTls13BackendEch), |
4437 | | EXP(EnableTls13GreaseEch), |
4438 | | EXP(SetTls13GreaseEchSize), |
4439 | | EXP(EncodeEchConfigId), |
4440 | | EXP(GetCurrentEpoch), |
4441 | | EXP(GetEchRetryConfigs), |
4442 | | EXP(GetExtensionSupport), |
4443 | | EXP(GetResumptionTokenInfo), |
4444 | | EXP(GetResumptionTokenInfoWithFlags), |
4445 | | EXP(HelloRetryRequestCallback), |
4446 | | EXP(InstallExtensionHooks), |
4447 | | EXP(HkdfExtract), |
4448 | | EXP(HkdfExpandLabel), |
4449 | | EXP(HkdfExpandLabelWithMech), |
4450 | | EXP(HkdfVariantExpandLabel), |
4451 | | EXP(HkdfVariantExpandLabelWithMech), |
4452 | | EXP(KeyUpdate), |
4453 | | EXP(MakeAead), |
4454 | | EXP(MakeVariantAead), |
4455 | | EXP(RecordLayerData), |
4456 | | EXP(RecordLayerWriteCallback), |
4457 | | EXP(ReleaseAntiReplayContext), |
4458 | | EXP(RemoveEchConfigs), |
4459 | | EXP(RemoveExternalPsk), |
4460 | | EXP(SecretCallback), |
4461 | | EXP(SendCertificateRequest), |
4462 | | EXP(SendSessionTicket), |
4463 | | EXP(SetAntiReplayContext), |
4464 | | EXP(SetClientEchConfigs), |
4465 | | EXP(SetDtls13VersionWorkaround), |
4466 | | EXP(SetMaxEarlyDataSize), |
4467 | | EXP(SetResumptionTokenCallback), |
4468 | | EXP(SetResumptionToken), |
4469 | | EXP(SetServerEchConfigs), |
4470 | | EXP(SetTimeFunc), |
4471 | | EXP(SetCertificateCompressionAlgorithm), |
4472 | | EXP(PeerCertificateChainDER), |
4473 | | #endif |
4474 | | { "", NULL } |
4475 | | }; |
4476 | | #undef EXP |
4477 | | #undef PUB |
4478 | | |
4479 | | void * |
4480 | | SSL_GetExperimentalAPI(const char *name) |
4481 | 447k | { |
4482 | 447k | unsigned int i; |
4483 | 15.2M | for (i = 0; i < PR_ARRAY_SIZE(ssl_experimental_functions); ++i) { |
4484 | 15.2M | if (strcmp(name, ssl_experimental_functions[i].name) == 0) { |
4485 | 447k | return ssl_experimental_functions[i].function; |
4486 | 447k | } |
4487 | 15.2M | } |
4488 | 0 | PORT_SetError(SSL_ERROR_UNSUPPORTED_EXPERIMENTAL_API); |
4489 | 0 | return NULL; |
4490 | 447k | } |
4491 | | |
4492 | | void |
4493 | | ssl_ClearPRCList(PRCList *list, void (*f)(void *)) |
4494 | 215k | { |
4495 | 215k | PRCList *cursor; |
4496 | | |
4497 | 287k | while (!PR_CLIST_IS_EMPTY(list)) { |
4498 | 71.6k | cursor = PR_LIST_TAIL(list); |
4499 | | |
4500 | 71.6k | PR_REMOVE_LINK(cursor); |
4501 | 71.6k | if (f) { |
4502 | 0 | f(cursor); |
4503 | 0 | } |
4504 | 71.6k | PORT_Free(cursor); |
4505 | 71.6k | } |
4506 | 215k | } |
4507 | | |
4508 | | SECStatus |
4509 | | SSLExp_EnableTls13GreaseEch(PRFileDesc *fd, PRBool enabled) |
4510 | 30.0k | { |
4511 | 30.0k | sslSocket *ss = ssl_FindSocket(fd); |
4512 | 30.0k | if (!ss) { |
4513 | 0 | return SECFailure; |
4514 | 0 | } |
4515 | 30.0k | ss->opt.enableTls13GreaseEch = enabled; |
4516 | 30.0k | return SECSuccess; |
4517 | 30.0k | } |
4518 | | |
4519 | | SECStatus |
4520 | | SSLExp_SetTls13GreaseEchSize(PRFileDesc *fd, PRUint8 size) |
4521 | 0 | { |
4522 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
4523 | 0 | if (!ss || size == 0) { |
4524 | 0 | return SECFailure; |
4525 | 0 | } |
4526 | 0 | ssl_Get1stHandshakeLock(ss); |
4527 | 0 | ssl_GetSSL3HandshakeLock(ss); |
4528 | |
|
4529 | 0 | ss->ssl3.hs.greaseEchSize = size; |
4530 | |
|
4531 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
4532 | 0 | ssl_Release1stHandshakeLock(ss); |
4533 | |
|
4534 | 0 | return SECSuccess; |
4535 | 0 | } |
4536 | | |
4537 | | SECStatus |
4538 | | SSLExp_EnableTls13BackendEch(PRFileDesc *fd, PRBool enabled) |
4539 | 31.2k | { |
4540 | 31.2k | sslSocket *ss = ssl_FindSocket(fd); |
4541 | 31.2k | if (!ss) { |
4542 | 0 | return SECFailure; |
4543 | 0 | } |
4544 | 31.2k | ss->opt.enableTls13BackendEch = enabled; |
4545 | 31.2k | return SECSuccess; |
4546 | 31.2k | } |
4547 | | |
4548 | | SECStatus |
4549 | | SSLExp_CallExtensionWriterOnEchInner(PRFileDesc *fd, PRBool enabled) |
4550 | 0 | { |
4551 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
4552 | 0 | if (!ss) { |
4553 | 0 | return SECFailure; |
4554 | 0 | } |
4555 | 0 | ss->opt.callExtensionWriterOnEchInner = enabled; |
4556 | 0 | return SECSuccess; |
4557 | 0 | } |
4558 | | |
4559 | | SECStatus |
4560 | | SSLExp_SetDtls13VersionWorkaround(PRFileDesc *fd, PRBool enabled) |
4561 | 30.0k | { |
4562 | 30.0k | sslSocket *ss = ssl_FindSocket(fd); |
4563 | 30.0k | if (!ss) { |
4564 | 0 | return SECFailure; |
4565 | 0 | } |
4566 | 30.0k | ss->opt.enableDtls13VersionCompat = enabled; |
4567 | 30.0k | return SECSuccess; |
4568 | 30.0k | } |
4569 | | |
4570 | | SECStatus |
4571 | | SSLExp_SetTimeFunc(PRFileDesc *fd, SSLTimeFunc f, void *arg) |
4572 | 61.2k | { |
4573 | 61.2k | sslSocket *ss = ssl_FindSocket(fd); |
4574 | | |
4575 | 61.2k | if (!ss) { |
4576 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetTimeFunc", |
4577 | 0 | SSL_GETPID(), fd)); |
4578 | 0 | return SECFailure; |
4579 | 0 | } |
4580 | 61.2k | ss->now = f; |
4581 | 61.2k | ss->nowArg = arg; |
4582 | 61.2k | return SECSuccess; |
4583 | 61.2k | } |
4584 | | |
4585 | | /* Experimental APIs for session cache handling. */ |
4586 | | |
4587 | | SECStatus |
4588 | | SSLExp_SetResumptionTokenCallback(PRFileDesc *fd, |
4589 | | SSLResumptionTokenCallback cb, |
4590 | | void *ctx) |
4591 | 0 | { |
4592 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
4593 | |
|
4594 | 0 | if (!ss) { |
4595 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetResumptionTokenCallback", |
4596 | 0 | SSL_GETPID(), fd)); |
4597 | 0 | return SECFailure; |
4598 | 0 | } |
4599 | | |
4600 | 0 | ssl_Get1stHandshakeLock(ss); |
4601 | 0 | ssl_GetSSL3HandshakeLock(ss); |
4602 | 0 | ss->resumptionTokenCallback = cb; |
4603 | 0 | ss->resumptionTokenContext = ctx; |
4604 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
4605 | 0 | ssl_Release1stHandshakeLock(ss); |
4606 | |
|
4607 | 0 | return SECSuccess; |
4608 | 0 | } |
4609 | | |
4610 | | SECStatus |
4611 | | SSLExp_EnablePlaintextResumptionExport(PRFileDesc *fd, PRBool enabled) |
4612 | 0 | { |
4613 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
4614 | |
|
4615 | 0 | if (!ss) { |
4616 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_EnablePlaintextResumptionExport", |
4617 | 0 | SSL_GETPID(), fd)); |
4618 | 0 | return SECFailure; |
4619 | 0 | } |
4620 | | |
4621 | 0 | ssl_Get1stHandshakeLock(ss); |
4622 | 0 | ssl_GetSSL3HandshakeLock(ss); |
4623 | 0 | ss->opt.enablePlaintextResumptionExport = enabled; |
4624 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
4625 | 0 | ssl_Release1stHandshakeLock(ss); |
4626 | |
|
4627 | 0 | return SECSuccess; |
4628 | 0 | } |
4629 | | |
4630 | | SECStatus |
4631 | | SSLExp_SetResumptionToken(PRFileDesc *fd, const PRUint8 *token, |
4632 | | unsigned int len) |
4633 | 0 | { |
4634 | 0 | sslSocket *ss = ssl_FindSocket(fd); |
4635 | 0 | sslSessionID *sid = NULL; |
4636 | |
|
4637 | 0 | if (!ss) { |
4638 | 0 | SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetResumptionToken", |
4639 | 0 | SSL_GETPID(), fd)); |
4640 | 0 | return SECFailure; |
4641 | 0 | } |
4642 | | |
4643 | 0 | ssl_Get1stHandshakeLock(ss); |
4644 | 0 | ssl_GetSSL3HandshakeLock(ss); |
4645 | |
|
4646 | 0 | if (ss->firstHsDone || ss->ssl3.hs.ws != idle_handshake || |
4647 | 0 | ss->sec.isServer || len == 0 || !token) { |
4648 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
4649 | 0 | goto loser; |
4650 | 0 | } |
4651 | | |
4652 | | // We override any previously set session. |
4653 | 0 | if (ss->sec.ci.sid) { |
4654 | 0 | ssl_SetSocketSID(ss, NULL); |
4655 | 0 | } |
4656 | |
|
4657 | 0 | PRINT_BUF(50, (ss, "incoming resumption token", token, len)); |
4658 | |
|
4659 | 0 | sid = ssl3_NewSessionID(ss, PR_FALSE); |
4660 | 0 | if (!sid) { |
4661 | 0 | goto loser; |
4662 | 0 | } |
4663 | | |
4664 | | /* Populate NewSessionTicket values */ |
4665 | 0 | SECStatus rv = ssl_DecodeResumptionToken(ss, sid, token, len); |
4666 | 0 | if (rv != SECSuccess) { |
4667 | | // If decoding fails, we assume the token is bad. |
4668 | 0 | PORT_SetError(SSL_ERROR_BAD_RESUMPTION_TOKEN_ERROR); |
4669 | 0 | goto loser; |
4670 | 0 | } |
4671 | | |
4672 | | // Make sure that the token is currently usable. |
4673 | 0 | if (!ssl_IsResumptionTokenUsable(ss, sid)) { |
4674 | 0 | PORT_SetError(SSL_ERROR_BAD_RESUMPTION_TOKEN_ERROR); |
4675 | 0 | goto loser; |
4676 | 0 | } |
4677 | | |
4678 | | // Generate a new random session ID for this ticket. |
4679 | 0 | rv = PK11_GenerateRandom(sid->u.ssl3.sessionID, SSL3_SESSIONID_BYTES); |
4680 | 0 | if (rv != SECSuccess) { |
4681 | 0 | goto loser; // Code set by PK11_GenerateRandom. |
4682 | 0 | } |
4683 | 0 | sid->u.ssl3.sessionIDLength = SSL3_SESSIONID_BYTES; |
4684 | | /* Use the sid->cached as marker that this is from an external cache and |
4685 | | * we don't have to look up anything in the NSS internal cache. */ |
4686 | 0 | sid->cached = in_external_cache; |
4687 | 0 | sid->lastAccessTime = ssl_Time(ss); |
4688 | |
|
4689 | 0 | ssl_SetSocketSID(ss, sid); |
4690 | |
|
4691 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
4692 | 0 | ssl_Release1stHandshakeLock(ss); |
4693 | 0 | return SECSuccess; |
4694 | | |
4695 | 0 | loser: |
4696 | 0 | ssl_FreeSID(sid); |
4697 | 0 | ssl_ReleaseSSL3HandshakeLock(ss); |
4698 | 0 | ssl_Release1stHandshakeLock(ss); |
4699 | |
|
4700 | 0 | return SECFailure; |
4701 | 0 | } |
4702 | | |
4703 | | SECStatus |
4704 | | SSLExp_DestroyResumptionTokenInfo(SSLResumptionTokenInfo *token) |
4705 | 0 | { |
4706 | 0 | if (!token) { |
4707 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
4708 | 0 | return SECFailure; |
4709 | 0 | } |
4710 | 0 | if (token->peerCert) { |
4711 | 0 | CERT_DestroyCertificate(token->peerCert); |
4712 | 0 | } |
4713 | 0 | PORT_Free(token->alpnSelection); |
4714 | 0 | PORT_Memset(token, 0, token->length); |
4715 | 0 | return SECSuccess; |
4716 | 0 | } |
4717 | | |
4718 | | SECStatus |
4719 | | SSLExp_GetResumptionTokenInfo(const PRUint8 *tokenData, unsigned int tokenLen, |
4720 | | SSLResumptionTokenInfo *tokenOut, PRUintn len) |
4721 | 0 | { |
4722 | 0 | return SSLExp_GetResumptionTokenInfoWithFlags(tokenData, tokenLen, tokenOut, |
4723 | 0 | len, 0); |
4724 | 0 | } |
4725 | | |
4726 | | SECStatus |
4727 | | SSLExp_GetResumptionTokenInfoWithFlags(const PRUint8 *tokenData, |
4728 | | unsigned int tokenLen, |
4729 | | SSLResumptionTokenInfo *tokenOut, |
4730 | | PRUintn len, PRUint32 flags) |
4731 | 0 | { |
4732 | 0 | if (!tokenData || !tokenOut || !tokenLen || |
4733 | 0 | len > sizeof(SSLResumptionTokenInfo) || |
4734 | 0 | (flags & ~SSL_RESUMPTION_TOKEN_INFO_NO_PEER_CERT)) { |
4735 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
4736 | 0 | return SECFailure; |
4737 | 0 | } |
4738 | 0 | sslSessionID sid = { 0 }; |
4739 | 0 | SSLResumptionTokenInfo token = { 0 }; |
4740 | | |
4741 | | /* Populate sid values */ |
4742 | 0 | if (ssl_DecodeResumptionToken(NULL, &sid, tokenData, tokenLen) != SECSuccess) { |
4743 | | // If decoding fails, we assume the token is bad. |
4744 | 0 | ssl_DestroySID(&sid, PR_FALSE); |
4745 | 0 | PORT_SetError(SSL_ERROR_BAD_RESUMPTION_TOKEN_ERROR); |
4746 | 0 | return SECFailure; |
4747 | 0 | } |
4748 | | |
4749 | | /* |sid| only holds the peer certificate as DER; SSLResumptionTokenInfo is |
4750 | | * a public struct that hands out a CERTCertificate, so make one here |
4751 | | * unless the caller doesn't want it. */ |
4752 | 0 | if (sid.peerCertDER.data && |
4753 | 0 | !(flags & SSL_RESUMPTION_TOKEN_INFO_NO_PEER_CERT)) { |
4754 | 0 | token.peerCert = CERT_NewTempCertificate(NULL, /* dbHandle */ |
4755 | 0 | &sid.peerCertDER, |
4756 | 0 | NULL, PR_FALSE, PR_TRUE); |
4757 | 0 | if (!token.peerCert) { |
4758 | 0 | ssl_DestroySID(&sid, PR_FALSE); |
4759 | 0 | return SECFailure; |
4760 | 0 | } |
4761 | 0 | } |
4762 | | |
4763 | 0 | token.alpnSelectionLen = sid.u.ssl3.alpnSelection.len; |
4764 | 0 | token.alpnSelection = PORT_ZAlloc(token.alpnSelectionLen); |
4765 | 0 | if (!token.alpnSelection) { |
4766 | 0 | CERT_DestroyCertificate(token.peerCert); |
4767 | 0 | ssl_DestroySID(&sid, PR_FALSE); |
4768 | 0 | return SECFailure; |
4769 | 0 | } |
4770 | 0 | if (token.alpnSelectionLen > 0) { |
4771 | 0 | PORT_Assert(sid.u.ssl3.alpnSelection.data); |
4772 | 0 | PORT_Memcpy(token.alpnSelection, sid.u.ssl3.alpnSelection.data, |
4773 | 0 | token.alpnSelectionLen); |
4774 | 0 | } |
4775 | |
|
4776 | 0 | if (sid.u.ssl3.locked.sessionTicket.flags & ticket_allow_early_data) { |
4777 | 0 | token.maxEarlyDataSize = |
4778 | 0 | sid.u.ssl3.locked.sessionTicket.max_early_data_size; |
4779 | 0 | } else { |
4780 | 0 | token.maxEarlyDataSize = 0; |
4781 | 0 | } |
4782 | 0 | token.expirationTime = sid.expirationTime; |
4783 | | /* A successful decode guarantees the version and features bytes. */ |
4784 | 0 | token.plaintextSecret = |
4785 | 0 | (tokenData[1] & SSLResumptionTokenFeatureRawMS) ? PR_TRUE : PR_FALSE; |
4786 | |
|
4787 | 0 | token.length = PR_MIN(sizeof(SSLResumptionTokenInfo), len); |
4788 | 0 | PORT_Memcpy(tokenOut, &token, token.length); |
4789 | |
|
4790 | 0 | ssl_DestroySID(&sid, PR_FALSE); |
4791 | 0 | return SECSuccess; |
4792 | 0 | } |