Coverage Report

Created: 2026-11-15 06:55

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/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(&params->prime, dh_p)) {
2258
44
            if (!SECITEM_ItemsAreEqual(&params->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
}