]> git.ipfire.org Git - thirdparty/openssl.git/blame - ssl/ssl_lib.c
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Don't read uninitialised data for short session IDs.
[thirdparty/openssl.git] / ssl / ssl_lib.c
CommitLineData
0f113f3e 1/*
846e33c7 2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
bf21446a 3 *
846e33c7
RS		 4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
bf21446a 8 */
846e33c7 9
ea262260
BM		 10/* ====================================================================
11 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
0f113f3e 12 * ECC cipher suite support in OpenSSL originally developed by
ea262260
BM		 13 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
14 */
ddac1974
NL		 15/* ====================================================================
16 * Copyright 2005 Nokia. All rights reserved.
17 *
18 * The portions of the attached software ("Contribution") is developed by
19 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
20 * license.
21 *
22 * The Contribution, originally written by Mika Kousa and Pasi Eronen of
23 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
24 * support (see RFC 4279) to OpenSSL.
25 *
26 * No patent licenses or other rights except those expressly stated in
27 * the OpenSSL open source license shall be deemed granted or received
28 * expressly, by implication, estoppel, or otherwise.
29 *
30 * No assurances are provided by Nokia that the Contribution does not
31 * infringe the patent or other intellectual property rights of any third
32 * party or that the license provides you with all the necessary rights
33 * to make use of the Contribution.
34 *
35 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
36 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
37 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
38 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
39 * OTHERWISE.
40 */
bbb8de09 41
463a7b8c 42#include <assert.h>
d02b48c6 43#include <stdio.h>
7b63c0fa 44#include "ssl_locl.h"
ec577822
BM		 45#include <openssl/objects.h>
46#include <openssl/lhash.h>
bb7cd4e3 47#include <openssl/x509v3.h>
6434abbf 48#include <openssl/rand.h>
67c8e7f4 49#include <openssl/ocsp.h>
3c27208f
RS		 50#include <openssl/dh.h>
51#include <openssl/engine.h>
07bbc92c 52#include <openssl/async.h>
3c27208f 53#include <openssl/ct.h>
0f113f3e 54
df2ee0e2 55const char SSL_version_str[] = OPENSSL_VERSION_TEXT;
0f113f3e
MC		 56
57SSL3_ENC_METHOD ssl3_undef_enc_method = {
58 /*
59 * evil casts, but these functions are only called if there's a library
60 * bug
61 */
72716e79 62 (int (*)(SSL *, SSL3_RECORD *, size_t, int))ssl_undefined_function,
d102d9df 63 (int (*)(SSL *, SSL3_RECORD *, unsigned char *, int))ssl_undefined_function,
0f113f3e 64 ssl_undefined_function,
8c1a5343 65 (int (*)(SSL *, unsigned char *, unsigned char *, size_t, size_t *))
0f113f3e
MC		 66 ssl_undefined_function,
67 (int (*)(SSL *, int))ssl_undefined_function,
6db6bc5a 68 (size_t (*)(SSL *, const char *, size_t, unsigned char *))
0f113f3e 69 ssl_undefined_function,
0f113f3e
MC		 70 NULL, /* client_finished_label */
71 0, /* client_finished_label_len */
72 NULL, /* server_finished_label */
73 0, /* server_finished_label_len */
74 (int (*)(int))ssl_undefined_function,
75 (int (*)(SSL *, unsigned char *, size_t, const char *,
76 size_t, const unsigned char *, size_t,
77 int use_context))ssl_undefined_function,
78};
d02b48c6 79
07bbc92c
MC		 80struct ssl_async_args {
81 SSL *s;
82 void *buf;
348240c6 83 size_t num;
a230b26e 84 enum { READFUNC, WRITEFUNC, OTHERFUNC } type;
add2f5ca 85 union {
eda75751 86 int (*func_read) (SSL *, void *, size_t, size_t *);
7ee8627f 87 int (*func_write) (SSL *, const void *, size_t, size_t *);
a230b26e 88 int (*func_other) (SSL *);
add2f5ca 89 } f;
07bbc92c
MC		 90};
91
919ba009
VD		 92static const struct {
93 uint8_t mtype;
94 uint8_t ord;
a230b26e 95 int nid;
919ba009 96} dane_mds[] = {
a230b26e
EK		 97 {
98 DANETLS_MATCHING_FULL, 0, NID_undef
99 },
100 {
101 DANETLS_MATCHING_2256, 1, NID_sha256
102 },
103 {
104 DANETLS_MATCHING_2512, 2, NID_sha512
105 },
919ba009
VD		 106};
107
108static int dane_ctx_enable(struct dane_ctx_st *dctx)
109{
110 const EVP_MD **mdevp;
111 uint8_t *mdord;
112 uint8_t mdmax = DANETLS_MATCHING_LAST;
a230b26e 113 int n = ((int)mdmax) + 1; /* int to handle PrivMatch(255) */
919ba009
VD		 114 size_t i;
115
5ae4ceb9
VD		 116 if (dctx->mdevp != NULL)
117 return 1;
118
919ba009
VD		 119 mdevp = OPENSSL_zalloc(n * sizeof(*mdevp));
120 mdord = OPENSSL_zalloc(n * sizeof(*mdord));
121
122 if (mdord == NULL || mdevp == NULL) {
b3bd3d5a 123 OPENSSL_free(mdord);
919ba009
VD		 124 OPENSSL_free(mdevp);
125 SSLerr(SSL_F_DANE_CTX_ENABLE, ERR_R_MALLOC_FAILURE);
126 return 0;
127 }
128
129 /* Install default entries */
130 for (i = 0; i < OSSL_NELEM(dane_mds); ++i) {
131 const EVP_MD *md;
132
133 if (dane_mds[i].nid == NID_undef ||
134 (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL)
135 continue;
136 mdevp[dane_mds[i].mtype] = md;
137 mdord[dane_mds[i].mtype] = dane_mds[i].ord;
138 }
139
140 dctx->mdevp = mdevp;
141 dctx->mdord = mdord;
142 dctx->mdmax = mdmax;
143
144 return 1;
145}
146
147static void dane_ctx_final(struct dane_ctx_st *dctx)
148{
149 OPENSSL_free(dctx->mdevp);
150 dctx->mdevp = NULL;
151
152 OPENSSL_free(dctx->mdord);
153 dctx->mdord = NULL;
154 dctx->mdmax = 0;
155}
156
157static void tlsa_free(danetls_record *t)
158{
159 if (t == NULL)
160 return;
161 OPENSSL_free(t->data);
162 EVP_PKEY_free(t->spki);
163 OPENSSL_free(t);
164}
165
b9aec69a 166static void dane_final(SSL_DANE *dane)
919ba009
VD		 167{
168 sk_danetls_record_pop_free(dane->trecs, tlsa_free);
169 dane->trecs = NULL;
170
171 sk_X509_pop_free(dane->certs, X509_free);
172 dane->certs = NULL;
173
174 X509_free(dane->mcert);
175 dane->mcert = NULL;
176 dane->mtlsa = NULL;
177 dane->mdpth = -1;
178 dane->pdpth = -1;
179}
180
181/*
182 * dane_copy - Copy dane configuration, sans verification state.
183 */
184static int ssl_dane_dup(SSL *to, SSL *from)
185{
186 int num;
187 int i;
188
189 if (!DANETLS_ENABLED(&from->dane))
190 return 1;
191
192 dane_final(&to->dane);
5ae4ceb9 193 to->dane.flags = from->dane.flags;
9f6b22b8
VD		 194 to->dane.dctx = &to->ctx->dane;
195 to->dane.trecs = sk_danetls_record_new_null();
196
197 if (to->dane.trecs == NULL) {
198 SSLerr(SSL_F_SSL_DANE_DUP, ERR_R_MALLOC_FAILURE);
199 return 0;
200 }
919ba009 201
a230b26e 202 num = sk_danetls_record_num(from->dane.trecs);
919ba009
VD		 203 for (i = 0; i < num; ++i) {
204 danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);
9f6b22b8 205
919ba009
VD		 206 if (SSL_dane_tlsa_add(to, t->usage, t->selector, t->mtype,
207 t->data, t->dlen) <= 0)
208 return 0;
209 }
210 return 1;
211}
212
a230b26e
EK		 213static int dane_mtype_set(struct dane_ctx_st *dctx,
214 const EVP_MD *md, uint8_t mtype, uint8_t ord)
919ba009
VD		 215{
216 int i;
217
218 if (mtype == DANETLS_MATCHING_FULL && md != NULL) {
a230b26e 219 SSLerr(SSL_F_DANE_MTYPE_SET, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL);
919ba009
VD		 220 return 0;
221 }
222
223 if (mtype > dctx->mdmax) {
224 const EVP_MD **mdevp;
225 uint8_t *mdord;
a230b26e 226 int n = ((int)mtype) + 1;
919ba009
VD		 227
228 mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(*mdevp));
229 if (mdevp == NULL) {
230 SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);
231 return -1;
232 }
233 dctx->mdevp = mdevp;
234
235 mdord = OPENSSL_realloc(dctx->mdord, n * sizeof(*mdord));
236 if (mdord == NULL) {
237 SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);
238 return -1;
239 }
240 dctx->mdord = mdord;
241
242 /* Zero-fill any gaps */
a230b26e 243 for (i = dctx->mdmax + 1; i < mtype; ++i) {
919ba009
VD		 244 mdevp[i] = NULL;
245 mdord[i] = 0;
246 }
247
248 dctx->mdmax = mtype;
249 }
250
251 dctx->mdevp[mtype] = md;
252 /* Coerce ordinal of disabled matching types to 0 */
253 dctx->mdord[mtype] = (md == NULL) ? 0 : ord;
254
255 return 1;
256}
257
b9aec69a 258static const EVP_MD *tlsa_md_get(SSL_DANE *dane, uint8_t mtype)
919ba009
VD		 259{
260 if (mtype > dane->dctx->mdmax)
261 return NULL;
262 return dane->dctx->mdevp[mtype];
263}
264
a230b26e
EK		 265static int dane_tlsa_add(SSL_DANE *dane,
266 uint8_t usage,
267 uint8_t selector,
268 uint8_t mtype, unsigned char *data, size_t dlen)
919ba009
VD		 269{
270 danetls_record *t;
271 const EVP_MD *md = NULL;
272 int ilen = (int)dlen;
273 int i;
9f6b22b8 274 int num;
919ba009
VD		 275
276 if (dane->trecs == NULL) {
277 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_NOT_ENABLED);
278 return -1;
279 }
280
281 if (ilen < 0 || dlen != (size_t)ilen) {
282 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DATA_LENGTH);
283 return 0;
284 }
285
286 if (usage > DANETLS_USAGE_LAST) {
287 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE);
288 return 0;
289 }
290
291 if (selector > DANETLS_SELECTOR_LAST) {
292 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_SELECTOR);
293 return 0;
294 }
295
296 if (mtype != DANETLS_MATCHING_FULL) {
297 md = tlsa_md_get(dane, mtype);
298 if (md == NULL) {
299 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE);
300 return 0;
301 }
302 }
303
304 if (md != NULL && dlen != (size_t)EVP_MD_size(md)) {
305 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH);
306 return 0;
307 }
308 if (!data) {
309 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_NULL_DATA);
310 return 0;
311 }
312
313 if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL) {
314 SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
315 return -1;
316 }
317
318 t->usage = usage;
319 t->selector = selector;
320 t->mtype = mtype;
348240c6 321 t->data = OPENSSL_malloc(dlen);
919ba009
VD		 322 if (t->data == NULL) {
323 tlsa_free(t);
324 SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
325 return -1;
326 }
348240c6
MC		 327 memcpy(t->data, data, dlen);
328 t->dlen = dlen;
919ba009
VD		 329
330 /* Validate and cache full certificate or public key */
331 if (mtype == DANETLS_MATCHING_FULL) {
332 const unsigned char *p = data;
333 X509 *cert = NULL;
334 EVP_PKEY *pkey = NULL;
335
336 switch (selector) {
337 case DANETLS_SELECTOR_CERT:
348240c6 338 if (!d2i_X509(&cert, &p, ilen) || p < data ||
919ba009
VD		 339 dlen != (size_t)(p - data)) {
340 tlsa_free(t);
341 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
342 return 0;
343 }
344 if (X509_get0_pubkey(cert) == NULL) {
345 tlsa_free(t);
346 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
347 return 0;
348 }
349
350 if ((DANETLS_USAGE_BIT(usage) & DANETLS_TA_MASK) == 0) {
351 X509_free(cert);
352 break;
353 }
354
355 /*
356 * For usage DANE-TA(2), we support authentication via "2 0 0" TLSA
357 * records that contain full certificates of trust-anchors that are
358 * not present in the wire chain. For usage PKIX-TA(0), we augment
359 * the chain with untrusted Full(0) certificates from DNS, in case
360 * they are missing from the chain.
361 */
362 if ((dane->certs == NULL &&
363 (dane->certs = sk_X509_new_null()) == NULL) ||
364 !sk_X509_push(dane->certs, cert)) {
365 SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
366 X509_free(cert);
367 tlsa_free(t);
368 return -1;
369 }
370 break;
371
372 case DANETLS_SELECTOR_SPKI:
348240c6 373 if (!d2i_PUBKEY(&pkey, &p, ilen) || p < data ||
919ba009
VD		 374 dlen != (size_t)(p - data)) {
375 tlsa_free(t);
376 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY);
377 return 0;
378 }
379
380 /*
381 * For usage DANE-TA(2), we support authentication via "2 1 0" TLSA
382 * records that contain full bare keys of trust-anchors that are
383 * not present in the wire chain.
384 */
385 if (usage == DANETLS_USAGE_DANE_TA)
386 t->spki = pkey;
387 else
388 EVP_PKEY_free(pkey);
389 break;
390 }
391 }
392
393 /*-
394 * Find the right insertion point for the new record.
395 *
396 * See crypto/x509/x509_vfy.c. We sort DANE-EE(3) records first, so that
397 * they can be processed first, as they require no chain building, and no
398 * expiration or hostname checks. Because DANE-EE(3) is numerically
399 * largest, this is accomplished via descending sort by "usage".
400 *
401 * We also sort in descending order by matching ordinal to simplify
402 * the implementation of digest agility in the verification code.
403 *
404 * The choice of order for the selector is not significant, so we
405 * use the same descending order for consistency.
406 */
9f6b22b8
VD		 407 num = sk_danetls_record_num(dane->trecs);
408 for (i = 0; i < num; ++i) {
919ba009 409 danetls_record *rec = sk_danetls_record_value(dane->trecs, i);
9f6b22b8 410
919ba009
VD		 411 if (rec->usage > usage)
412 continue;
413 if (rec->usage < usage)
414 break;
415 if (rec->selector > selector)
416 continue;
417 if (rec->selector < selector)
418 break;
419 if (dane->dctx->mdord[rec->mtype] > dane->dctx->mdord[mtype])
420 continue;
421 break;
422 }
423
424 if (!sk_danetls_record_insert(dane->trecs, t, i)) {
425 tlsa_free(t);
426 SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
427 return -1;
428 }
429 dane->umask |= DANETLS_USAGE_BIT(usage);
430
431 return 1;
432}
433
d31fb0b5
RS		 434static void clear_ciphers(SSL *s)
435{
436 /* clear the current cipher */
437 ssl_clear_cipher_ctx(s);
438 ssl_clear_hash_ctx(&s->read_hash);
439 ssl_clear_hash_ctx(&s->write_hash);
440}
441
4f43d0e7 442int SSL_clear(SSL *s)
0f113f3e 443{
0f113f3e
MC		 444 if (s->method == NULL) {
445 SSLerr(SSL_F_SSL_CLEAR, SSL_R_NO_METHOD_SPECIFIED);
446 return (0);
447 }
d02b48c6 448
0f113f3e
MC		 449 if (ssl_clear_bad_session(s)) {
450 SSL_SESSION_free(s->session);
451 s->session = NULL;
452 }
d62bfb39 453
0f113f3e
MC		 454 s->error = 0;
455 s->hit = 0;
456 s->shutdown = 0;
d02b48c6 457
0f113f3e
MC		 458 if (s->renegotiate) {
459 SSLerr(SSL_F_SSL_CLEAR, ERR_R_INTERNAL_ERROR);
460 return 0;
461 }
d02b48c6 462
fe3a3291 463 ossl_statem_clear(s);
413c4f45 464
0f113f3e
MC		 465 s->version = s->method->version;
466 s->client_version = s->version;
467 s->rwstate = SSL_NOTHING;
d02b48c6 468
25aaa98a
RS		 469 BUF_MEM_free(s->init_buf);
470 s->init_buf = NULL;
d31fb0b5 471 clear_ciphers(s);
0f113f3e 472 s->first_packet = 0;
d02b48c6 473
919ba009
VD		 474 /* Reset DANE verification result state */
475 s->dane.mdpth = -1;
476 s->dane.pdpth = -1;
477 X509_free(s->dane.mcert);
478 s->dane.mcert = NULL;
479 s->dane.mtlsa = NULL;
480
481 /* Clear the verification result peername */
482 X509_VERIFY_PARAM_move_peername(s->param, NULL);
483
0f113f3e
MC		 484 /*
485 * Check to see if we were changed into a different method, if so, revert
486 * back if we are not doing session-id reuse.
487 */
024f543c 488 if (!ossl_statem_get_in_handshake(s) && (s->session == NULL)
0f113f3e
MC		 489 && (s->method != s->ctx->method)) {
490 s->method->ssl_free(s);
491 s->method = s->ctx->method;
492 if (!s->method->ssl_new(s))
493 return (0);
494 } else
0f113f3e 495 s->method->ssl_clear(s);
33d23b87 496
af9752e5 497 RECORD_LAYER_clear(&s->rlayer);
33d23b87 498
0f113f3e
MC		 499 return (1);
500}
d02b48c6 501
4f43d0e7 502/** Used to change an SSL_CTXs default SSL method type */
0f113f3e
MC		 503int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
504{
505 STACK_OF(SSL_CIPHER) *sk;
506
507 ctx->method = meth;
508
509 sk = ssl_create_cipher_list(ctx->method, &(ctx->cipher_list),
510 &(ctx->cipher_list_by_id),
511 SSL_DEFAULT_CIPHER_LIST, ctx->cert);
512 if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) {
a230b26e 513 SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
0f113f3e
MC		 514 return (0);
515 }
516 return (1);
517}
d02b48c6 518
4f43d0e7 519SSL *SSL_new(SSL_CTX *ctx)
0f113f3e
MC		 520{
521 SSL *s;
522
523 if (ctx == NULL) {
524 SSLerr(SSL_F_SSL_NEW, SSL_R_NULL_SSL_CTX);
525 return (NULL);
526 }
527 if (ctx->method == NULL) {
528 SSLerr(SSL_F_SSL_NEW, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
529 return (NULL);
530 }
531
b51bce94 532 s = OPENSSL_zalloc(sizeof(*s));
0f113f3e
MC		 533 if (s == NULL)
534 goto err;
0f113f3e 535
16203f7b
AG		 536 s->lock = CRYPTO_THREAD_lock_new();
537 if (s->lock == NULL) {
538 SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
539 OPENSSL_free(s);
540 return NULL;
541 }
542
c036e210 543 RECORD_LAYER_init(&s->rlayer, s);
28d59af8 544
0f113f3e 545 s->options = ctx->options;
5ae4ceb9 546 s->dane.flags = ctx->dane.flags;
7946ab33
KR		 547 s->min_proto_version = ctx->min_proto_version;
548 s->max_proto_version = ctx->max_proto_version;
0f113f3e
MC		 549 s->mode = ctx->mode;
550 s->max_cert_list = ctx->max_cert_list;
0e04674e 551 s->references = 1;
0f113f3e 552
2c382349
KR		 553 /*
554 * Earlier library versions used to copy the pointer to the CERT, not
555 * its contents; only when setting new parameters for the per-SSL
556 * copy, ssl_cert_new would be called (and the direct reference to
557 * the per-SSL_CTX settings would be lost, but those still were
558 * indirectly accessed for various purposes, and for that reason they
559 * used to be known as s->ctx->default_cert). Now we don't look at the
560 * SSL_CTX's CERT after having duplicated it once.
561 */
562 s->cert = ssl_cert_dup(ctx->cert);
563 if (s->cert == NULL)
564 goto err;
0f113f3e 565
52e1d7b1 566 RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
0f113f3e
MC		 567 s->msg_callback = ctx->msg_callback;
568 s->msg_callback_arg = ctx->msg_callback_arg;
569 s->verify_mode = ctx->verify_mode;
570 s->not_resumable_session_cb = ctx->not_resumable_session_cb;
0f113f3e
MC		 571 s->sid_ctx_length = ctx->sid_ctx_length;
572 OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
573 memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
574 s->verify_callback = ctx->default_verify_callback;
575 s->generate_session_id = ctx->generate_session_id;
576
577 s->param = X509_VERIFY_PARAM_new();
a71edf3b 578 if (s->param == NULL)
0f113f3e
MC		 579 goto err;
580 X509_VERIFY_PARAM_inherit(s->param, ctx->param);
0f113f3e
MC		 581 s->quiet_shutdown = ctx->quiet_shutdown;
582 s->max_send_fragment = ctx->max_send_fragment;
d102d9df
MC		 583 s->split_send_fragment = ctx->split_send_fragment;
584 s->max_pipelines = ctx->max_pipelines;
94777c9c
MC		 585 if (s->max_pipelines > 1)
586 RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
dad78fb1
MC		 587 if (ctx->default_read_buf_len > 0)
588 SSL_set_default_read_buffer_len(s, ctx->default_read_buf_len);
bf21446a 589
16203f7b 590 SSL_CTX_up_ref(ctx);
0f113f3e 591 s->ctx = ctx;
aff8c126
RS		 592 s->ext.debug_cb = 0;
593 s->ext.debug_arg = NULL;
594 s->ext.ticket_expected = 0;
595 s->ext.status_type = ctx->ext.status_type;
596 s->ext.status_expected = 0;
597 s->ext.ocsp.ids = NULL;
598 s->ext.ocsp.exts = NULL;
599 s->ext.ocsp.resp = NULL;
600 s->ext.ocsp.resp_len = 0;
16203f7b 601 SSL_CTX_up_ref(ctx);
222da979 602 s->session_ctx = ctx;
a230b26e 603#ifndef OPENSSL_NO_EC
aff8c126
RS		 604 if (ctx->ext.ecpointformats) {
605 s->ext.ecpointformats =
606 OPENSSL_memdup(ctx->ext.ecpointformats,
607 ctx->ext.ecpointformats_len);
608 if (!s->ext.ecpointformats)
0f113f3e 609 goto err;
aff8c126
RS		 610 s->ext.ecpointformats_len =
611 ctx->ext.ecpointformats_len;
612 }
613 if (ctx->ext.supportedgroups) {
614 s->ext.supportedgroups =
615 OPENSSL_memdup(ctx->ext.supportedgroups,
616 ctx->ext.supportedgroups_len);
617 if (!s->ext.supportedgroups)
0f113f3e 618 goto err;
aff8c126 619 s->ext.supportedgroups_len = ctx->ext.supportedgroups_len;
0f113f3e 620 }
a230b26e
EK		 621#endif
622#ifndef OPENSSL_NO_NEXTPROTONEG
aff8c126 623 s->ext.npn = NULL;
a230b26e 624#endif
6f017a8f 625
aff8c126
RS		 626 if (s->ctx->ext.alpn) {
627 s->ext.alpn = OPENSSL_malloc(s->ctx->ext.alpn_len);
628 if (s->ext.alpn == NULL)
0f113f3e 629 goto err;
aff8c126
RS		 630 memcpy(s->ext.alpn, s->ctx->ext.alpn, s->ctx->ext.alpn_len);
631 s->ext.alpn_len = s->ctx->ext.alpn_len;
0f113f3e 632 }
d02b48c6 633
696178ed 634 s->verified_chain = NULL;
0f113f3e 635 s->verify_result = X509_V_OK;
d02b48c6 636
a974e64a
MC		 637 s->default_passwd_callback = ctx->default_passwd_callback;
638 s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;
639
0f113f3e 640 s->method = ctx->method;
d02b48c6 641
0f113f3e
MC		 642 if (!s->method->ssl_new(s))
643 goto err;
d02b48c6 644
0f113f3e 645 s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
bf21446a 646
61986d32 647 if (!SSL_clear(s))
69f68237 648 goto err;
58964a49 649
25a807bc
F		 650 if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data))
651 goto err;
58964a49 652
ddac1974 653#ifndef OPENSSL_NO_PSK
0f113f3e
MC		 654 s->psk_client_callback = ctx->psk_client_callback;
655 s->psk_server_callback = ctx->psk_server_callback;
ddac1974
NL		 656#endif
657
07bbc92c
MC		 658 s->job = NULL;
659
ed29e82a
RP		 660#ifndef OPENSSL_NO_CT
661 if (!SSL_set_ct_validation_callback(s, ctx->ct_validation_callback,
a230b26e 662 ctx->ct_validation_callback_arg))
ed29e82a
RP		 663 goto err;
664#endif
665
16203f7b 666 return s;
0f113f3e 667 err:
62adbcee 668 SSL_free(s);
0f113f3e 669 SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
16203f7b 670 return NULL;
0f113f3e 671}
d02b48c6 672
e417070c
RS		 673int SSL_is_dtls(const SSL *s)
674{
675 return SSL_IS_DTLS(s) ? 1 : 0;
676}
677
c5ebfcab 678int SSL_up_ref(SSL *s)
a18a31e4 679{
16203f7b 680 int i;
c5ebfcab 681
2f545ae4 682 if (CRYPTO_UP_REF(&s->references, &i, s->lock) <= 0)
c5ebfcab
F		 683 return 0;
684
685 REF_PRINT_COUNT("SSL", s);
686 REF_ASSERT_ISNT(i < 2);
687 return ((i > 1) ? 1 : 0);
a18a31e4
MC		 688}
689
0f113f3e
MC		 690int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
691 unsigned int sid_ctx_len)
692{
693 if (sid_ctx_len > sizeof ctx->sid_ctx) {
694 SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,
695 SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
696 return 0;
697 }
698 ctx->sid_ctx_length = sid_ctx_len;
699 memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
4eb77b26
BM		 700
701 return 1;
0f113f3e 702}
4eb77b26 703
0f113f3e
MC		 704int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
705 unsigned int sid_ctx_len)
706{
707 if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
708 SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,
709 SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
710 return 0;
711 }
712 ssl->sid_ctx_length = sid_ctx_len;
713 memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
b4cadc6e
BL		 714
715 return 1;
0f113f3e 716}
b4cadc6e 717
dc644fe2 718int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
0f113f3e 719{
16203f7b 720 CRYPTO_THREAD_write_lock(ctx->lock);
0f113f3e 721 ctx->generate_session_id = cb;
16203f7b 722 CRYPTO_THREAD_unlock(ctx->lock);
0f113f3e
MC		 723 return 1;
724}
dc644fe2
GT		 725
726int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
0f113f3e 727{
16203f7b 728 CRYPTO_THREAD_write_lock(ssl->lock);
0f113f3e 729 ssl->generate_session_id = cb;
16203f7b 730 CRYPTO_THREAD_unlock(ssl->lock);
0f113f3e
MC		 731 return 1;
732}
dc644fe2 733
f85c9904 734int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
0f113f3e
MC		 735 unsigned int id_len)
736{
737 /*
738 * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
739 * we can "construct" a session to give us the desired check - ie. to
740 * find if there's a session in the hash table that would conflict with
741 * any new session built out of this id/id_len and the ssl_version in use
742 * by this SSL.
743 */
744 SSL_SESSION r, *p;
745
746 if (id_len > sizeof r.session_id)
747 return 0;
748
749 r.ssl_version = ssl->version;
750 r.session_id_length = id_len;
751 memcpy(r.session_id, id, id_len);
752
e2bb9b9b
TS		 753 CRYPTO_THREAD_read_lock(ssl->session_ctx->lock);
754 p = lh_SSL_SESSION_retrieve(ssl->session_ctx->sessions, &r);
755 CRYPTO_THREAD_unlock(ssl->session_ctx->lock);
0f113f3e
MC		 756 return (p != NULL);
757}
dc644fe2 758
bb7cd4e3 759int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
0f113f3e
MC		 760{
761 return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
762}
bb7cd4e3
DSH		 763
764int SSL_set_purpose(SSL *s, int purpose)
0f113f3e
MC		 765{
766 return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
767}
926a56bf 768
bb7cd4e3 769int SSL_CTX_set_trust(SSL_CTX *s, int trust)
0f113f3e
MC		 770{
771 return X509_VERIFY_PARAM_set_trust(s->param, trust);
772}
bb7cd4e3
DSH		 773
774int SSL_set_trust(SSL *s, int trust)
0f113f3e
MC		 775{
776 return X509_VERIFY_PARAM_set_trust(s->param, trust);
777}
bb7cd4e3 778
919ba009
VD		 779int SSL_set1_host(SSL *s, const char *hostname)
780{
781 return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0);
782}
783
784int SSL_add1_host(SSL *s, const char *hostname)
785{
786 return X509_VERIFY_PARAM_add1_host(s->param, hostname, 0);
787}
788
789void SSL_set_hostflags(SSL *s, unsigned int flags)
790{
791 X509_VERIFY_PARAM_set_hostflags(s->param, flags);
792}
793
4588cb44 794const char *SSL_get0_peername(SSL *s)
919ba009
VD		 795{
796 return X509_VERIFY_PARAM_get0_peername(s->param);
797}
798
799int SSL_CTX_dane_enable(SSL_CTX *ctx)
800{
801 return dane_ctx_enable(&ctx->dane);
802}
803
5ae4ceb9
VD		 804unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags)
805{
806 unsigned long orig = ctx->dane.flags;
807
808 ctx->dane.flags |= flags;
809 return orig;
810}
811
812unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags)
813{
814 unsigned long orig = ctx->dane.flags;
815
816 ctx->dane.flags &= ~flags;
817 return orig;
818}
819
919ba009
VD		 820int SSL_dane_enable(SSL *s, const char *basedomain)
821{
b9aec69a 822 SSL_DANE *dane = &s->dane;
919ba009
VD		 823
824 if (s->ctx->dane.mdmax == 0) {
825 SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_CONTEXT_NOT_DANE_ENABLED);
826 return 0;
827 }
828 if (dane->trecs != NULL) {
829 SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_DANE_ALREADY_ENABLED);
830 return 0;
831 }
832
8d887efa
VD		 833 /*
834 * Default SNI name. This rejects empty names, while set1_host below
835 * accepts them and disables host name checks. To avoid side-effects with
836 * invalid input, set the SNI name first.
837 */
aff8c126 838 if (s->ext.hostname == NULL) {
dccd20d1 839 if (!SSL_set_tlsext_host_name(s, basedomain)) {
8d887efa 840 SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
dccd20d1 841 return -1;
8d887efa
VD		 842 }
843 }
844
919ba009
VD		 845 /* Primary RFC6125 reference identifier */
846 if (!X509_VERIFY_PARAM_set1_host(s->param, basedomain, 0)) {
847 SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
848 return -1;
849 }
850
919ba009
VD		 851 dane->mdpth = -1;
852 dane->pdpth = -1;
853 dane->dctx = &s->ctx->dane;
854 dane->trecs = sk_danetls_record_new_null();
855
856 if (dane->trecs == NULL) {
857 SSLerr(SSL_F_SSL_DANE_ENABLE, ERR_R_MALLOC_FAILURE);
858 return -1;
859 }
860 return 1;
861}
862
5ae4ceb9
VD		 863unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags)
864{
865 unsigned long orig = ssl->dane.flags;
866
867 ssl->dane.flags |= flags;
868 return orig;
869}
870
871unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags)
872{
873 unsigned long orig = ssl->dane.flags;
874
875 ssl->dane.flags &= ~flags;
876 return orig;
877}
878
919ba009
VD		 879int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki)
880{
b9aec69a 881 SSL_DANE *dane = &s->dane;
919ba009 882
c0a445a9 883 if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
919ba009
VD		 884 return -1;
885 if (dane->mtlsa) {
886 if (mcert)
887 *mcert = dane->mcert;
888 if (mspki)
889 *mspki = (dane->mcert == NULL) ? dane->mtlsa->spki : NULL;
890 }
891 return dane->mdpth;
892}
893
894int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
895 uint8_t *mtype, unsigned const char **data, size_t *dlen)
896{
b9aec69a 897 SSL_DANE *dane = &s->dane;
919ba009 898
c0a445a9 899 if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
919ba009
VD		 900 return -1;
901 if (dane->mtlsa) {
902 if (usage)
903 *usage = dane->mtlsa->usage;
904 if (selector)
905 *selector = dane->mtlsa->selector;
906 if (mtype)
907 *mtype = dane->mtlsa->mtype;
908 if (data)
909 *data = dane->mtlsa->data;
910 if (dlen)
911 *dlen = dane->mtlsa->dlen;
912 }
913 return dane->mdpth;
914}
915
b9aec69a 916SSL_DANE *SSL_get0_dane(SSL *s)
919ba009
VD		 917{
918 return &s->dane;
919}
920
921int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
922 uint8_t mtype, unsigned char *data, size_t dlen)
923{
924 return dane_tlsa_add(&s->dane, usage, selector, mtype, data, dlen);
925}
926
a230b26e
EK		 927int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, uint8_t mtype,
928 uint8_t ord)
919ba009
VD		 929{
930 return dane_mtype_set(&ctx->dane, md, mtype, ord);
931}
932
ccf11751 933int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
0f113f3e
MC		 934{
935 return X509_VERIFY_PARAM_set1(ctx->param, vpm);
936}
ccf11751
DSH		 937
938int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
0f113f3e
MC		 939{
940 return X509_VERIFY_PARAM_set1(ssl->param, vpm);
941}
ccf11751 942
7af31968 943X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
0f113f3e
MC		 944{
945 return ctx->param;
946}
7af31968
DSH		 947
948X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
0f113f3e
MC		 949{
950 return ssl->param;
951}
7af31968 952
a5ee80b9 953void SSL_certs_clear(SSL *s)
0f113f3e
MC		 954{
955 ssl_cert_clear_certs(s->cert);
956}
a5ee80b9 957
4f43d0e7 958void SSL_free(SSL *s)
0f113f3e
MC		 959{
960 int i;
58964a49 961
0f113f3e
MC		 962 if (s == NULL)
963 return;
e03ddfae 964
2f545ae4 965 CRYPTO_DOWN_REF(&s->references, &i, s->lock);
f3f1cf84 966 REF_PRINT_COUNT("SSL", s);
0f113f3e
MC		 967 if (i > 0)
968 return;
f3f1cf84 969 REF_ASSERT_ISNT(i < 0);
d02b48c6 970
222561fe 971 X509_VERIFY_PARAM_free(s->param);
919ba009 972 dane_final(&s->dane);
0f113f3e
MC		 973 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
974
2e7dc7cd
MC		 975 ssl_free_wbio_buffer(s);
976
65e2d672 977 BIO_free_all(s->wbio);
325cfa85 978 BIO_free_all(s->rbio);
0f113f3e 979
25aaa98a 980 BUF_MEM_free(s->init_buf);
0f113f3e
MC		 981
982 /* add extra stuff */
25aaa98a
RS		 983 sk_SSL_CIPHER_free(s->cipher_list);
984 sk_SSL_CIPHER_free(s->cipher_list_by_id);
0f113f3e
MC		 985
986 /* Make the next call work :-) */
987 if (s->session != NULL) {
988 ssl_clear_bad_session(s);
989 SSL_SESSION_free(s->session);
990 }
991
d31fb0b5 992 clear_ciphers(s);
d02b48c6 993
e0e920b1 994 ssl_cert_free(s->cert);
0f113f3e 995 /* Free up if allocated */
d02b48c6 996
aff8c126 997 OPENSSL_free(s->ext.hostname);
222da979 998 SSL_CTX_free(s->session_ctx);
e481f9b9 999#ifndef OPENSSL_NO_EC
aff8c126
RS		 1000 OPENSSL_free(s->ext.ecpointformats);
1001 OPENSSL_free(s->ext.supportedgroups);
a230b26e 1002#endif /* OPENSSL_NO_EC */
aff8c126 1003 sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts, X509_EXTENSION_free);
3e41ac35 1004#ifndef OPENSSL_NO_OCSP
aff8c126 1005 sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free);
3e41ac35 1006#endif
ed29e82a
RP		 1007#ifndef OPENSSL_NO_CT
1008 SCT_LIST_free(s->scts);
aff8c126 1009 OPENSSL_free(s->ext.scts);
ed29e82a 1010#endif
aff8c126
RS		 1011 OPENSSL_free(s->ext.ocsp.resp);
1012 OPENSSL_free(s->ext.alpn);
0f113f3e 1013
222561fe 1014 sk_X509_NAME_pop_free(s->client_CA, X509_NAME_free);
0f113f3e 1015
696178ed
DSH		 1016 sk_X509_pop_free(s->verified_chain, X509_free);
1017
0f113f3e
MC		 1018 if (s->method != NULL)
1019 s->method->ssl_free(s);
1020
f161995e 1021 RECORD_LAYER_release(&s->rlayer);
33d23b87 1022
e0e920b1 1023 SSL_CTX_free(s->ctx);
7c3908dd 1024
ff75a257
MC		 1025 ASYNC_WAIT_CTX_free(s->waitctx);
1026
e481f9b9 1027#if !defined(OPENSSL_NO_NEXTPROTONEG)
aff8c126 1028 OPENSSL_free(s->ext.npn);
ee2ffc27
BL		 1029#endif
1030
e783bae2 1031#ifndef OPENSSL_NO_SRTP
25aaa98a 1032 sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
0f113f3e
MC		 1033#endif
1034
16203f7b
AG		 1035 CRYPTO_THREAD_lock_free(s->lock);
1036
0f113f3e
MC		 1037 OPENSSL_free(s);
1038}
1039
65e2d672 1040void SSL_set0_rbio(SSL *s, BIO *rbio)
3ffbe008 1041{
65e2d672 1042 BIO_free_all(s->rbio);
3ffbe008
MC		 1043 s->rbio = rbio;
1044}
1045
65e2d672 1046void SSL_set0_wbio(SSL *s, BIO *wbio)
0f113f3e
MC		 1047{
1048 /*
1049 * If the output buffering BIO is still in place, remove it
1050 */
2e7dc7cd
MC		 1051 if (s->bbio != NULL)
1052 s->wbio = BIO_pop(s->wbio);
1053
65e2d672 1054 BIO_free_all(s->wbio);
0f113f3e 1055 s->wbio = wbio;
2e7dc7cd
MC		 1056
1057 /* Re-attach |bbio| to the new |wbio|. */
1058 if (s->bbio != NULL)
1059 s->wbio = BIO_push(s->bbio, s->wbio);
0f113f3e 1060}
d02b48c6 1061
3ffbe008
MC		 1062void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
1063{
65e2d672
MC		 1064 /*
1065 * For historical reasons, this function has many different cases in
1066 * ownership handling.
1067 */
1068
1069 /* If nothing has changed, do nothing */
1070 if (rbio == SSL_get_rbio(s) && wbio == SSL_get_wbio(s))
1071 return;
1072
1073 /*
1074 * If the two arguments are equal then one fewer reference is granted by the
1075 * caller than we want to take
1076 */
1077 if (rbio != NULL && rbio == wbio)
1078 BIO_up_ref(rbio);
1079
1080 /*
1081 * If only the wbio is changed only adopt one reference.
1082 */
1083 if (rbio == SSL_get_rbio(s)) {
1084 SSL_set0_wbio(s, wbio);
1085 return;
1086 }
1087 /*
1088 * There is an asymmetry here for historical reasons. If only the rbio is
1089 * changed AND the rbio and wbio were originally different, then we only
1090 * adopt one reference.
1091 */
1092 if (wbio == SSL_get_wbio(s) && SSL_get_rbio(s) != SSL_get_wbio(s)) {
1093 SSL_set0_rbio(s, rbio);
1094 return;
1095 }
1096
1097 /* Otherwise, adopt both references. */
1098 SSL_set0_rbio(s, rbio);
1099 SSL_set0_wbio(s, wbio);
3ffbe008
MC		 1100}
1101
0821bcd4 1102BIO *SSL_get_rbio(const SSL *s)
0f113f3e 1103{
2e7dc7cd 1104 return s->rbio;
0f113f3e 1105}
d02b48c6 1106
0821bcd4 1107BIO *SSL_get_wbio(const SSL *s)
0f113f3e 1108{
2e7dc7cd
MC		 1109 if (s->bbio != NULL) {
1110 /*
1111 * If |bbio| is active, the true caller-configured BIO is its
1112 * |next_bio|.
1113 */
1114 return BIO_next(s->bbio);
1115 }
1116 return s->wbio;
0f113f3e 1117}
d02b48c6 1118
0821bcd4 1119int SSL_get_fd(const SSL *s)
0f113f3e 1120{
2e7dc7cd 1121 return SSL_get_rfd(s);
0f113f3e 1122}
24cbf3ef 1123
0821bcd4 1124int SSL_get_rfd(const SSL *s)
0f113f3e
MC		 1125{
1126 int ret = -1;
1127 BIO *b, *r;
1128
1129 b = SSL_get_rbio(s);
1130 r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1131 if (r != NULL)
1132 BIO_get_fd(r, &ret);
1133 return (ret);
1134}
d02b48c6 1135
0821bcd4 1136int SSL_get_wfd(const SSL *s)
0f113f3e
MC		 1137{
1138 int ret = -1;
1139 BIO *b, *r;
1140
1141 b = SSL_get_wbio(s);
1142 r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1143 if (r != NULL)
1144 BIO_get_fd(r, &ret);
1145 return (ret);
1146}
24cbf3ef 1147
bc36ee62 1148#ifndef OPENSSL_NO_SOCK
0f113f3e
MC		 1149int SSL_set_fd(SSL *s, int fd)
1150{
1151 int ret = 0;
1152 BIO *bio = NULL;
1153
1154 bio = BIO_new(BIO_s_socket());
1155
1156 if (bio == NULL) {
1157 SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
1158 goto err;
1159 }
1160 BIO_set_fd(bio, fd, BIO_NOCLOSE);
1161 SSL_set_bio(s, bio, bio);
1162 ret = 1;
1163 err:
1164 return (ret);
1165}
d02b48c6 1166
0f113f3e
MC		 1167int SSL_set_wfd(SSL *s, int fd)
1168{
2e7dc7cd 1169 BIO *rbio = SSL_get_rbio(s);
0f113f3e 1170
2e7dc7cd
MC		 1171 if (rbio == NULL || BIO_method_type(rbio) != BIO_TYPE_SOCKET
1172 || (int)BIO_get_fd(rbio, NULL) != fd) {
1173 BIO *bio = BIO_new(BIO_s_socket());
0f113f3e
MC		 1174
1175 if (bio == NULL) {
1176 SSLerr(SSL_F_SSL_SET_WFD, ERR_R_BUF_LIB);
2e7dc7cd 1177 return 0;
0f113f3e
MC		 1178 }
1179 BIO_set_fd(bio, fd, BIO_NOCLOSE);
65e2d672 1180 SSL_set0_wbio(s, bio);
2e7dc7cd 1181 } else {
65e2d672
MC		 1182 BIO_up_ref(rbio);
1183 SSL_set0_wbio(s, rbio);
2e7dc7cd
MC		 1184 }
1185 return 1;
0f113f3e
MC		 1186}
1187
1188int SSL_set_rfd(SSL *s, int fd)
1189{
2e7dc7cd 1190 BIO *wbio = SSL_get_wbio(s);
0f113f3e 1191
2e7dc7cd
MC		 1192 if (wbio == NULL || BIO_method_type(wbio) != BIO_TYPE_SOCKET
1193 || ((int)BIO_get_fd(wbio, NULL) != fd)) {
1194 BIO *bio = BIO_new(BIO_s_socket());
0f113f3e
MC		 1195
1196 if (bio == NULL) {
1197 SSLerr(SSL_F_SSL_SET_RFD, ERR_R_BUF_LIB);
2e7dc7cd 1198 return 0;
0f113f3e
MC		 1199 }
1200 BIO_set_fd(bio, fd, BIO_NOCLOSE);
65e2d672 1201 SSL_set0_rbio(s, bio);
2e7dc7cd 1202 } else {
65e2d672
MC		 1203 BIO_up_ref(wbio);
1204 SSL_set0_rbio(s, wbio);
2e7dc7cd
MC		 1205 }
1206
1207 return 1;
0f113f3e
MC		 1208}
1209#endif
ca03109c
BM		 1210
1211/* return length of latest Finished message we sent, copy to 'buf' */
0821bcd4 1212size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
0f113f3e
MC		 1213{
1214 size_t ret = 0;
1215
1216 if (s->s3 != NULL) {
1217 ret = s->s3->tmp.finish_md_len;
1218 if (count > ret)
1219 count = ret;
1220 memcpy(buf, s->s3->tmp.finish_md, count);
1221 }
1222 return ret;
1223}
ca03109c
BM		 1224
1225/* return length of latest Finished message we expected, copy to 'buf' */
0821bcd4 1226size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
0f113f3e
MC		 1227{
1228 size_t ret = 0;
ca03109c 1229
0f113f3e
MC		 1230 if (s->s3 != NULL) {
1231 ret = s->s3->tmp.peer_finish_md_len;
1232 if (count > ret)
1233 count = ret;
1234 memcpy(buf, s->s3->tmp.peer_finish_md, count);
1235 }
1236 return ret;
1237}
ca03109c 1238
0821bcd4 1239int SSL_get_verify_mode(const SSL *s)
0f113f3e
MC		 1240{
1241 return (s->verify_mode);
1242}
d02b48c6 1243
0821bcd4 1244int SSL_get_verify_depth(const SSL *s)
0f113f3e
MC		 1245{
1246 return X509_VERIFY_PARAM_get_depth(s->param);
1247}
7f89714e 1248
0f113f3e
MC		 1249int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
1250 return (s->verify_callback);
1251}
d02b48c6 1252
0821bcd4 1253int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
0f113f3e
MC		 1254{
1255 return (ctx->verify_mode);
1256}
d02b48c6 1257
0821bcd4 1258int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
0f113f3e
MC		 1259{
1260 return X509_VERIFY_PARAM_get_depth(ctx->param);
1261}
1262
1263int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
1264 return (ctx->default_verify_callback);
1265}
1266
1267void SSL_set_verify(SSL *s, int mode,
1268 int (*callback) (int ok, X509_STORE_CTX *ctx))
1269{
1270 s->verify_mode = mode;
1271 if (callback != NULL)
1272 s->verify_callback = callback;
1273}
1274
1275void SSL_set_verify_depth(SSL *s, int depth)
1276{
1277 X509_VERIFY_PARAM_set_depth(s->param, depth);
1278}
1279
1280void SSL_set_read_ahead(SSL *s, int yes)
1281{
52e1d7b1 1282 RECORD_LAYER_set_read_ahead(&s->rlayer, yes);
0f113f3e 1283}
d02b48c6 1284
0821bcd4 1285int SSL_get_read_ahead(const SSL *s)
0f113f3e 1286{
52e1d7b1 1287 return RECORD_LAYER_get_read_ahead(&s->rlayer);
0f113f3e 1288}
d02b48c6 1289
0821bcd4 1290int SSL_pending(const SSL *s)
0f113f3e 1291{
8b0e934a
MC		 1292 size_t pending = s->method->ssl_pending(s);
1293
0f113f3e
MC		 1294 /*
1295 * SSL_pending cannot work properly if read-ahead is enabled
1296 * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)), and it is
1297 * impossible to fix since SSL_pending cannot report errors that may be
1298 * observed while scanning the new data. (Note that SSL_pending() is
1299 * often used as a boolean value, so we'd better not return -1.)
8b0e934a
MC		 1300 *
1301 * SSL_pending also cannot work properly if the value >INT_MAX. In that case
1302 * we just return INT_MAX.
0f113f3e 1303 */
348240c6 1304 return pending < INT_MAX ? (int)pending : INT_MAX;
0f113f3e 1305}
d02b48c6 1306
49580f25
MC		 1307int SSL_has_pending(const SSL *s)
1308{
1309 /*
1310 * Similar to SSL_pending() but returns a 1 to indicate that we have
1311 * unprocessed data available or 0 otherwise (as opposed to the number of
1312 * bytes available). Unlike SSL_pending() this will take into account
1313 * read_ahead data. A 1 return simply indicates that we have unprocessed
1314 * data. That data may not result in any application data, or we may fail
1315 * to parse the records for some reason.
1316 */
1317 if (SSL_pending(s))
1318 return 1;
1319
1320 return RECORD_LAYER_read_pending(&s->rlayer);
1321}
1322
0821bcd4 1323X509 *SSL_get_peer_certificate(const SSL *s)
0f113f3e
MC		 1324{
1325 X509 *r;
d02b48c6 1326
0f113f3e
MC		 1327 if ((s == NULL) || (s->session == NULL))
1328 r = NULL;
1329 else
1330 r = s->session->peer;
d02b48c6 1331
0f113f3e
MC		 1332 if (r == NULL)
1333 return (r);
d02b48c6 1334
05f0fb9f 1335 X509_up_ref(r);
0f113f3e
MC		 1336
1337 return (r);
1338}
d02b48c6 1339
0821bcd4 1340STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
0f113f3e
MC		 1341{
1342 STACK_OF(X509) *r;
1343
c34b0f99 1344 if ((s == NULL) || (s->session == NULL))
0f113f3e
MC		 1345 r = NULL;
1346 else
c34b0f99 1347 r = s->session->peer_chain;
0f113f3e
MC		 1348
1349 /*
1350 * If we are a client, cert_chain includes the peer's own certificate; if
1351 * we are a server, it does not.
1352 */
1353
1354 return (r);
1355}
1356
1357/*
1358 * Now in theory, since the calling process own 't' it should be safe to
1359 * modify. We need to be able to read f without being hassled
1360 */
17dd65e6 1361int SSL_copy_session_id(SSL *t, const SSL *f)
0f113f3e 1362{
16203f7b 1363 int i;
0f113f3e 1364 /* Do we need to to SSL locking? */
61986d32 1365 if (!SSL_set_session(t, SSL_get_session(f))) {
17dd65e6 1366 return 0;
69f68237 1367 }
0f113f3e
MC		 1368
1369 /*
87d9cafa 1370 * what if we are setup for one protocol version but want to talk another
0f113f3e
MC		 1371 */
1372 if (t->method != f->method) {
919ba009
VD		 1373 t->method->ssl_free(t);
1374 t->method = f->method;
1375 if (t->method->ssl_new(t) == 0)
1376 return 0;
0f113f3e
MC		 1377 }
1378
2f545ae4 1379 CRYPTO_UP_REF(&f->cert->references, &i, f->cert->lock);
24a0d393
KR		 1380 ssl_cert_free(t->cert);
1381 t->cert = f->cert;
348240c6 1382 if (!SSL_set_session_id_context(t, f->sid_ctx, (int)f->sid_ctx_length)) {
17dd65e6 1383 return 0;
69f68237 1384 }
17dd65e6
MC		 1385
1386 return 1;
0f113f3e 1387}
d02b48c6 1388
58964a49 1389/* Fix this so it checks all the valid key/cert options */
0821bcd4 1390int SSL_CTX_check_private_key(const SSL_CTX *ctx)
0f113f3e 1391{
a230b26e
EK		 1392 if ((ctx == NULL) || (ctx->cert->key->x509 == NULL)) {
1393 SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY, SSL_R_NO_CERTIFICATE_ASSIGNED);
0f113f3e
MC		 1394 return (0);
1395 }
1396 if (ctx->cert->key->privatekey == NULL) {
a230b26e 1397 SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
0f113f3e
MC		 1398 return (0);
1399 }
1400 return (X509_check_private_key
1401 (ctx->cert->key->x509, ctx->cert->key->privatekey));
1402}
d02b48c6 1403
58964a49 1404/* Fix this function so that it takes an optional type parameter */
0821bcd4 1405int SSL_check_private_key(const SSL *ssl)
0f113f3e
MC		 1406{
1407 if (ssl == NULL) {
1408 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
1409 return (0);
1410 }
0f113f3e
MC		 1411 if (ssl->cert->key->x509 == NULL) {
1412 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_CERTIFICATE_ASSIGNED);
1413 return (0);
1414 }
1415 if (ssl->cert->key->privatekey == NULL) {
1416 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
1417 return (0);
1418 }
1419 return (X509_check_private_key(ssl->cert->key->x509,
1420 ssl->cert->key->privatekey));
1421}
d02b48c6 1422
07bbc92c
MC		 1423int SSL_waiting_for_async(SSL *s)
1424{
e8aa8b6c 1425 if (s->job)
82676094
MC		 1426 return 1;
1427
07bbc92c
MC		 1428 return 0;
1429}
1430
ff75a257 1431int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds)
f4da39d2 1432{
ff75a257
MC		 1433 ASYNC_WAIT_CTX *ctx = s->waitctx;
1434
1435 if (ctx == NULL)
1436 return 0;
1437 return ASYNC_WAIT_CTX_get_all_fds(ctx, fds, numfds);
1438}
f4da39d2 1439
ff75a257
MC		 1440int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds,
1441 OSSL_ASYNC_FD *delfd, size_t *numdelfds)
1442{
1443 ASYNC_WAIT_CTX *ctx = s->waitctx;
1444
1445 if (ctx == NULL)
1446 return 0;
1447 return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd,
1448 numdelfds);
f4da39d2
MC		 1449}
1450
4f43d0e7 1451int SSL_accept(SSL *s)
0f113f3e 1452{
c4c32155 1453 if (s->handshake_func == NULL) {
0f113f3e
MC		 1454 /* Not properly initialized yet */
1455 SSL_set_accept_state(s);
07bbc92c 1456 }
add2f5ca
MC		 1457
1458 return SSL_do_handshake(s);
0f113f3e 1459}
d02b48c6 1460
4f43d0e7 1461int SSL_connect(SSL *s)
0f113f3e 1462{
c4c32155 1463 if (s->handshake_func == NULL) {
0f113f3e
MC		 1464 /* Not properly initialized yet */
1465 SSL_set_connect_state(s);
add2f5ca 1466 }
b31b04d9 1467
add2f5ca 1468 return SSL_do_handshake(s);
0f113f3e 1469}
d02b48c6 1470
0821bcd4 1471long SSL_get_default_timeout(const SSL *s)
0f113f3e
MC		 1472{
1473 return (s->method->get_timeout());
1474}
1475
7fecbf6f 1476static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
a230b26e
EK		 1477 int (*func) (void *))
1478{
add2f5ca 1479 int ret;
ff75a257
MC		 1480 if (s->waitctx == NULL) {
1481 s->waitctx = ASYNC_WAIT_CTX_new();
1482 if (s->waitctx == NULL)
1483 return -1;
1484 }
e8aa8b6c 1485 switch (ASYNC_start_job(&s->job, s->waitctx, &ret, func, args,
a230b26e 1486 sizeof(struct ssl_async_args))) {
add2f5ca
MC		 1487 case ASYNC_ERR:
1488 s->rwstate = SSL_NOTHING;
7fecbf6f 1489 SSLerr(SSL_F_SSL_START_ASYNC_JOB, SSL_R_FAILED_TO_INIT_ASYNC);
add2f5ca
MC		 1490 return -1;
1491 case ASYNC_PAUSE:
1492 s->rwstate = SSL_ASYNC_PAUSED;
1493 return -1;
fc7f190c
MC		 1494 case ASYNC_NO_JOBS:
1495 s->rwstate = SSL_ASYNC_NO_JOBS;
1496 return -1;
add2f5ca
MC		 1497 case ASYNC_FINISH:
1498 s->job = NULL;
1499 return ret;
1500 default:
1501 s->rwstate = SSL_NOTHING;
7fecbf6f 1502 SSLerr(SSL_F_SSL_START_ASYNC_JOB, ERR_R_INTERNAL_ERROR);
add2f5ca
MC		 1503 /* Shouldn't happen */
1504 return -1;
1505 }
1506}
07bbc92c 1507
add2f5ca 1508static int ssl_io_intern(void *vargs)
07bbc92c
MC		 1509{
1510 struct ssl_async_args *args;
1511 SSL *s;
1512 void *buf;
348240c6 1513 size_t num;
07bbc92c
MC		 1514
1515 args = (struct ssl_async_args *)vargs;
1516 s = args->s;
1517 buf = args->buf;
1518 num = args->num;
ec447924
MC		 1519 switch (args->type) {
1520 case READFUNC:
7ee8627f 1521 return args->f.func_read(s, buf, num, &s->asyncrw);
ec447924 1522 case WRITEFUNC:
7ee8627f 1523 return args->f.func_write(s, buf, num, &s->asyncrw);
ec447924
MC		 1524 case OTHERFUNC:
1525 return args->f.func_other(s);
1526 }
1527 return -1;
07bbc92c
MC		 1528}
1529
0f113f3e 1530int SSL_read(SSL *s, void *buf, int num)
eda75751
MC		 1531{
1532 int ret;
54105ddd 1533 size_t readbytes;
eda75751
MC		 1534
1535 if (num < 0) {
1536 SSLerr(SSL_F_SSL_READ, SSL_R_BAD_LENGTH);
1537 return -1;
1538 }
1539
54105ddd 1540 ret = SSL_read_ex(s, buf, (size_t)num, &readbytes);
eda75751
MC		 1541
1542 /*
1543 * The cast is safe here because ret should be <= INT_MAX because num is
1544 * <= INT_MAX
1545 */
1546 if (ret > 0)
54105ddd 1547 ret = (int)readbytes;
eda75751
MC		 1548
1549 return ret;
1550}
1551
54105ddd 1552int SSL_read_ex(SSL *s, void *buf, size_t num, size_t *readbytes)
0f113f3e 1553{
c4c32155 1554 if (s->handshake_func == NULL) {
eda75751 1555 SSLerr(SSL_F_SSL_READ_EX, SSL_R_UNINITIALIZED);
0f113f3e
MC		 1556 return -1;
1557 }
1558
1559 if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1560 s->rwstate = SSL_NOTHING;
1561 return (0);
1562 }
07bbc92c 1563
e8aa8b6c 1564 if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
add2f5ca 1565 struct ssl_async_args args;
eda75751 1566 int ret;
add2f5ca
MC		 1567
1568 args.s = s;
1569 args.buf = buf;
1570 args.num = num;
ec447924
MC		 1571 args.type = READFUNC;
1572 args.f.func_read = s->method->ssl_read;
add2f5ca 1573
eda75751 1574 ret = ssl_start_async_job(s, &args, ssl_io_intern);
54105ddd 1575 *readbytes = s->asyncrw;
eda75751 1576 return ret;
07bbc92c 1577 } else {
54105ddd 1578 return s->method->ssl_read(s, buf, num, readbytes);
07bbc92c 1579 }
0f113f3e
MC		 1580}
1581
1582int SSL_peek(SSL *s, void *buf, int num)
eda75751
MC		 1583{
1584 int ret;
54105ddd 1585 size_t readbytes;
eda75751
MC		 1586
1587 if (num < 0) {
1588 SSLerr(SSL_F_SSL_PEEK, SSL_R_BAD_LENGTH);
1589 return -1;
1590 }
1591
54105ddd 1592 ret = SSL_peek_ex(s, buf, (size_t)num, &readbytes);
eda75751
MC		 1593
1594 /*
1595 * The cast is safe here because ret should be <= INT_MAX because num is
1596 * <= INT_MAX
1597 */
1598 if (ret > 0)
54105ddd 1599 ret = (int)readbytes;
eda75751
MC		 1600
1601 return ret;
1602}
1603
54105ddd 1604int SSL_peek_ex(SSL *s, void *buf, size_t num, size_t *readbytes)
0f113f3e 1605{
c4c32155 1606 if (s->handshake_func == NULL) {
eda75751 1607 SSLerr(SSL_F_SSL_PEEK_EX, SSL_R_UNINITIALIZED);
0f113f3e
MC		 1608 return -1;
1609 }
1610
1611 if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1612 return (0);
1613 }
e8aa8b6c 1614 if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
add2f5ca 1615 struct ssl_async_args args;
eda75751 1616 int ret;
0f113f3e 1617
add2f5ca
MC		 1618 args.s = s;
1619 args.buf = buf;
1620 args.num = num;
ec447924
MC		 1621 args.type = READFUNC;
1622 args.f.func_read = s->method->ssl_peek;
07bbc92c 1623
eda75751 1624 ret = ssl_start_async_job(s, &args, ssl_io_intern);
54105ddd 1625 *readbytes = s->asyncrw;
eda75751 1626 return ret;
add2f5ca 1627 } else {
54105ddd 1628 return s->method->ssl_peek(s, buf, num, readbytes);
add2f5ca 1629 }
07bbc92c
MC		 1630}
1631
0f113f3e 1632int SSL_write(SSL *s, const void *buf, int num)
7ee8627f
MC		 1633{
1634 int ret;
1635 size_t written;
1636
1637 if (num < 0) {
1638 SSLerr(SSL_F_SSL_WRITE, SSL_R_BAD_LENGTH);
1639 return -1;
1640 }
1641
1642 ret = SSL_write_ex(s, buf, (size_t)num, &written);
1643
1644 /*
1645 * The cast is safe here because ret should be <= INT_MAX because num is
1646 * <= INT_MAX
1647 */
1648 if (ret > 0)
1649 ret = (int)written;
1650
1651 return ret;
1652}
1653
1654int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written)
0f113f3e 1655{
c4c32155 1656 if (s->handshake_func == NULL) {
7ee8627f 1657 SSLerr(SSL_F_SSL_WRITE_EX, SSL_R_UNINITIALIZED);
0f113f3e
MC		 1658 return -1;
1659 }
1660
1661 if (s->shutdown & SSL_SENT_SHUTDOWN) {
1662 s->rwstate = SSL_NOTHING;
7ee8627f 1663 SSLerr(SSL_F_SSL_WRITE_EX, SSL_R_PROTOCOL_IS_SHUTDOWN);
0f113f3e
MC		 1664 return (-1);
1665 }
07bbc92c 1666
e8aa8b6c 1667 if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
7ee8627f 1668 int ret;
add2f5ca
MC		 1669 struct ssl_async_args args;
1670
1671 args.s = s;
1672 args.buf = (void *)buf;
1673 args.num = num;
ec447924
MC		 1674 args.type = WRITEFUNC;
1675 args.f.func_write = s->method->ssl_write;
add2f5ca 1676
7ee8627f
MC		 1677 ret = ssl_start_async_job(s, &args, ssl_io_intern);
1678 *written = s->asyncrw;
1679 return ret;
07bbc92c 1680 } else {
7ee8627f 1681 return s->method->ssl_write(s, buf, num, written);
07bbc92c 1682 }
0f113f3e 1683}
d02b48c6 1684
4f43d0e7 1685int SSL_shutdown(SSL *s)
0f113f3e
MC		 1686{
1687 /*
1688 * Note that this function behaves differently from what one might
1689 * expect. Return values are 0 for no success (yet), 1 for success; but
1690 * calling it once is usually not enough, even if blocking I/O is used
1691 * (see ssl3_shutdown).
1692 */
1693
c4c32155 1694 if (s->handshake_func == NULL) {
0f113f3e
MC		 1695 SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
1696 return -1;
1697 }
1698
64f9f406 1699 if (!SSL_in_init(s)) {
e8aa8b6c 1700 if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
64f9f406 1701 struct ssl_async_args args;
ec447924 1702
64f9f406
MC		 1703 args.s = s;
1704 args.type = OTHERFUNC;
1705 args.f.func_other = s->method->ssl_shutdown;
ec447924 1706
64f9f406
MC		 1707 return ssl_start_async_job(s, &args, ssl_io_intern);
1708 } else {
1709 return s->method->ssl_shutdown(s);
1710 }
ec447924 1711 } else {
64f9f406
MC		 1712 SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_SHUTDOWN_WHILE_IN_INIT);
1713 return -1;
ec447924 1714 }
0f113f3e 1715}
d02b48c6 1716
4f43d0e7 1717int SSL_renegotiate(SSL *s)
0f113f3e 1718{
2c0980d2
MC		 1719 /*
1720 * TODO(TLS1.3): Return an error for now. Perhaps we should do a KeyUpdate
1721 * instead when we support that?
1722 */
cda6b998 1723 if (SSL_IS_TLS13(s))
2c0980d2 1724 return 0;
cda6b998 1725
0f113f3e
MC		 1726 if (s->renegotiate == 0)
1727 s->renegotiate = 1;
44959ee4 1728
0f113f3e 1729 s->new_session = 1;
44959ee4 1730
0f113f3e
MC		 1731 return (s->method->ssl_renegotiate(s));
1732}
d02b48c6 1733
44959ee4 1734int SSL_renegotiate_abbreviated(SSL *s)
0f113f3e 1735{
2c0980d2
MC		 1736 /*
1737 * TODO(TLS1.3): Return an error for now. Perhaps we should do a KeyUpdate
1738 * instead when we support that?
1739 */
cda6b998 1740 if (SSL_IS_TLS13(s))
2c0980d2 1741 return 0;
cda6b998 1742
0f113f3e
MC		 1743 if (s->renegotiate == 0)
1744 s->renegotiate = 1;
c519e89f 1745
0f113f3e 1746 s->new_session = 0;
c519e89f 1747
0f113f3e
MC		 1748 return (s->method->ssl_renegotiate(s));
1749}
44959ee4 1750
6b0e9fac 1751int SSL_renegotiate_pending(SSL *s)
0f113f3e
MC		 1752{
1753 /*
1754 * becomes true when negotiation is requested; false again once a
1755 * handshake has finished
1756 */
1757 return (s->renegotiate != 0);
1758}
1759
1760long SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
1761{
1762 long l;
1763
1764 switch (cmd) {
1765 case SSL_CTRL_GET_READ_AHEAD:
52e1d7b1 1766 return (RECORD_LAYER_get_read_ahead(&s->rlayer));
0f113f3e 1767 case SSL_CTRL_SET_READ_AHEAD:
52e1d7b1
MC		 1768 l = RECORD_LAYER_get_read_ahead(&s->rlayer);
1769 RECORD_LAYER_set_read_ahead(&s->rlayer, larg);
0f113f3e
MC		 1770 return (l);
1771
1772 case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1773 s->msg_callback_arg = parg;
1774 return 1;
1775
0f113f3e
MC		 1776 case SSL_CTRL_MODE:
1777 return (s->mode |= larg);
1778 case SSL_CTRL_CLEAR_MODE:
1779 return (s->mode &= ~larg);
1780 case SSL_CTRL_GET_MAX_CERT_LIST:
348240c6 1781 return (long)(s->max_cert_list);
0f113f3e 1782 case SSL_CTRL_SET_MAX_CERT_LIST:
348240c6
MC		 1783 if (larg < 0)
1784 return 0;
1785 l = (long)s->max_cert_list;
1786 s->max_cert_list = (size_t)larg;
1787 return l;
0f113f3e
MC		 1788 case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1789 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1790 return 0;
1791 s->max_send_fragment = larg;
d102d9df
MC		 1792 if (s->max_send_fragment < s->split_send_fragment)
1793 s->split_send_fragment = s->max_send_fragment;
1794 return 1;
1795 case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
7ee8627f 1796 if ((size_t)larg > s->max_send_fragment || larg == 0)
d102d9df
MC		 1797 return 0;
1798 s->split_send_fragment = larg;
0f113f3e 1799 return 1;
d102d9df
MC		 1800 case SSL_CTRL_SET_MAX_PIPELINES:
1801 if (larg < 1 || larg > SSL_MAX_PIPELINES)
1802 return 0;
1803 s->max_pipelines = larg;
94777c9c
MC		 1804 if (larg > 1)
1805 RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
07077415 1806 return 1;
0f113f3e
MC		 1807 case SSL_CTRL_GET_RI_SUPPORT:
1808 if (s->s3)
1809 return s->s3->send_connection_binding;
1810 else
1811 return 0;
1812 case SSL_CTRL_CERT_FLAGS:
1813 return (s->cert->cert_flags |= larg);
1814 case SSL_CTRL_CLEAR_CERT_FLAGS:
1815 return (s->cert->cert_flags &= ~larg);
1816
1817 case SSL_CTRL_GET_RAW_CIPHERLIST:
1818 if (parg) {
76106e60 1819 if (s->s3->tmp.ciphers_raw == NULL)
0f113f3e 1820 return 0;
76106e60
DSH		 1821 *(unsigned char **)parg = s->s3->tmp.ciphers_raw;
1822 return (int)s->s3->tmp.ciphers_rawlen;
e9fa092e
EK		 1823 } else {
1824 return TLS_CIPHER_LEN;
1825 }
c5364614 1826 case SSL_CTRL_GET_EXTMS_SUPPORT:
024f543c 1827 if (!s->session || SSL_in_init(s) || ossl_statem_get_in_handshake(s))
a230b26e 1828 return -1;
dccd20d1 1829 if (s->session->flags & SSL_SESS_FLAG_EXTMS)
c5364614
DSH		 1830 return 1;
1831 else
1832 return 0;
7946ab33 1833 case SSL_CTRL_SET_MIN_PROTO_VERSION:
4fa52141
VD		 1834 return ssl_set_version_bound(s->ctx->method->version, (int)larg,
1835 &s->min_proto_version);
7946ab33 1836 case SSL_CTRL_SET_MAX_PROTO_VERSION:
4fa52141
VD		 1837 return ssl_set_version_bound(s->ctx->method->version, (int)larg,
1838 &s->max_proto_version);
0f113f3e
MC		 1839 default:
1840 return (s->method->ssl_ctrl(s, cmd, larg, parg));
1841 }
1842}
1843
1844long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
1845{
1846 switch (cmd) {
1847 case SSL_CTRL_SET_MSG_CALLBACK:
1848 s->msg_callback = (void (*)
1849 (int write_p, int version, int content_type,
1850 const void *buf, size_t len, SSL *ssl,
1851 void *arg))(fp);
1852 return 1;
1853
1854 default:
1855 return (s->method->ssl_callback_ctrl(s, cmd, fp));
1856 }
1857}
d3442bc7 1858
3c1d6bbc 1859LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
0f113f3e
MC		 1860{
1861 return ctx->sessions;
1862}
1863
1864long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
1865{
1866 long l;
1867 /* For some cases with ctx == NULL perform syntax checks */
1868 if (ctx == NULL) {
1869 switch (cmd) {
14536c8c 1870#ifndef OPENSSL_NO_EC
de4d764e
MC		 1871 case SSL_CTRL_SET_GROUPS_LIST:
1872 return tls1_set_groups_list(NULL, NULL, parg);
0f113f3e
MC		 1873#endif
1874 case SSL_CTRL_SET_SIGALGS_LIST:
1875 case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
1876 return tls1_set_sigalgs_list(NULL, parg, 0);
1877 default:
1878 return 0;
1879 }
1880 }
1881
1882 switch (cmd) {
1883 case SSL_CTRL_GET_READ_AHEAD:
1884 return (ctx->read_ahead);
1885 case SSL_CTRL_SET_READ_AHEAD:
1886 l = ctx->read_ahead;
1887 ctx->read_ahead = larg;
1888 return (l);
1889
1890 case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1891 ctx->msg_callback_arg = parg;
1892 return 1;
1893
1894 case SSL_CTRL_GET_MAX_CERT_LIST:
348240c6 1895 return (long)(ctx->max_cert_list);
0f113f3e 1896 case SSL_CTRL_SET_MAX_CERT_LIST:
348240c6
MC		 1897 if (larg < 0)
1898 return 0;
1899 l = (long)ctx->max_cert_list;
1900 ctx->max_cert_list = (size_t)larg;
1901 return l;
0f113f3e
MC		 1902
1903 case SSL_CTRL_SET_SESS_CACHE_SIZE:
348240c6
MC		 1904 if (larg < 0)
1905 return 0;
1906 l = (long)ctx->session_cache_size;
1907 ctx->session_cache_size = (size_t)larg;
1908 return l;
0f113f3e 1909 case SSL_CTRL_GET_SESS_CACHE_SIZE:
348240c6 1910 return (long)(ctx->session_cache_size);
0f113f3e
MC		 1911 case SSL_CTRL_SET_SESS_CACHE_MODE:
1912 l = ctx->session_cache_mode;
1913 ctx->session_cache_mode = larg;
1914 return (l);
1915 case SSL_CTRL_GET_SESS_CACHE_MODE:
1916 return (ctx->session_cache_mode);
1917
1918 case SSL_CTRL_SESS_NUMBER:
1919 return (lh_SSL_SESSION_num_items(ctx->sessions));
1920 case SSL_CTRL_SESS_CONNECT:
1921 return (ctx->stats.sess_connect);
1922 case SSL_CTRL_SESS_CONNECT_GOOD:
1923 return (ctx->stats.sess_connect_good);
1924 case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
1925 return (ctx->stats.sess_connect_renegotiate);
1926 case SSL_CTRL_SESS_ACCEPT:
1927 return (ctx->stats.sess_accept);
1928 case SSL_CTRL_SESS_ACCEPT_GOOD:
1929 return (ctx->stats.sess_accept_good);
1930 case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
1931 return (ctx->stats.sess_accept_renegotiate);
1932 case SSL_CTRL_SESS_HIT:
1933 return (ctx->stats.sess_hit);
1934 case SSL_CTRL_SESS_CB_HIT:
1935 return (ctx->stats.sess_cb_hit);
1936 case SSL_CTRL_SESS_MISSES:
1937 return (ctx->stats.sess_miss);
1938 case SSL_CTRL_SESS_TIMEOUTS:
1939 return (ctx->stats.sess_timeout);
1940 case SSL_CTRL_SESS_CACHE_FULL:
1941 return (ctx->stats.sess_cache_full);
0f113f3e
MC		 1942 case SSL_CTRL_MODE:
1943 return (ctx->mode |= larg);
1944 case SSL_CTRL_CLEAR_MODE:
1945 return (ctx->mode &= ~larg);
1946 case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1947 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1948 return 0;
1949 ctx->max_send_fragment = larg;
d102d9df 1950 if (ctx->max_send_fragment < ctx->split_send_fragment)
bfb155c1 1951 ctx->split_send_fragment = ctx->max_send_fragment;
0f113f3e 1952 return 1;
d102d9df 1953 case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
7ee8627f 1954 if ((size_t)larg > ctx->max_send_fragment || larg == 0)
d102d9df
MC		 1955 return 0;
1956 ctx->split_send_fragment = larg;
1957 return 1;
1958 case SSL_CTRL_SET_MAX_PIPELINES:
1959 if (larg < 1 || larg > SSL_MAX_PIPELINES)
1960 return 0;
1961 ctx->max_pipelines = larg;
07077415 1962 return 1;
0f113f3e
MC		 1963 case SSL_CTRL_CERT_FLAGS:
1964 return (ctx->cert->cert_flags |= larg);
1965 case SSL_CTRL_CLEAR_CERT_FLAGS:
1966 return (ctx->cert->cert_flags &= ~larg);
7946ab33 1967 case SSL_CTRL_SET_MIN_PROTO_VERSION:
4fa52141
VD		 1968 return ssl_set_version_bound(ctx->method->version, (int)larg,
1969 &ctx->min_proto_version);
7946ab33 1970 case SSL_CTRL_SET_MAX_PROTO_VERSION:
4fa52141
VD		 1971 return ssl_set_version_bound(ctx->method->version, (int)larg,
1972 &ctx->max_proto_version);
0f113f3e
MC		 1973 default:
1974 return (ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg));
1975 }
1976}
1977
1978long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
1979{
1980 switch (cmd) {
1981 case SSL_CTRL_SET_MSG_CALLBACK:
1982 ctx->msg_callback = (void (*)
1983 (int write_p, int version, int content_type,
1984 const void *buf, size_t len, SSL *ssl,
1985 void *arg))(fp);
1986 return 1;
1987
1988 default:
1989 return (ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp));
1990 }
1991}
d3442bc7 1992
ccd86b68 1993int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
0f113f3e 1994{
90d9e49a
DSH		 1995 if (a->id > b->id)
1996 return 1;
1997 if (a->id < b->id)
1998 return -1;
1999 return 0;
0f113f3e
MC		 2000}
2001
2002int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
2003 const SSL_CIPHER *const *bp)
2004{
90d9e49a
DSH		 2005 if ((*ap)->id > (*bp)->id)
2006 return 1;
2007 if ((*ap)->id < (*bp)->id)
2008 return -1;
2009 return 0;
0f113f3e 2010}
d02b48c6 2011
4f43d0e7 2012/** return a STACK of the ciphers available for the SSL and in order of
d02b48c6 2013 * preference */
0821bcd4 2014STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
0f113f3e
MC		 2015{
2016 if (s != NULL) {
2017 if (s->cipher_list != NULL) {
2018 return (s->cipher_list);
2019 } else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) {
2020 return (s->ctx->cipher_list);
2021 }
2022 }
2023 return (NULL);
2024}
2025
831eef2c
NM		 2026STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s)
2027{
2028 if ((s == NULL) || (s->session == NULL) || !s->server)
2029 return NULL;
2030 return s->session->ciphers;
2031}
2032
8b8e5bed 2033STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
0f113f3e
MC		 2034{
2035 STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
2036 int i;
2037 ciphers = SSL_get_ciphers(s);
2038 if (!ciphers)
2039 return NULL;
2040 ssl_set_client_disabled(s);
2041 for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
2042 const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
2043 if (!ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED)) {
2044 if (!sk)
2045 sk = sk_SSL_CIPHER_new_null();
2046 if (!sk)
2047 return NULL;
2048 if (!sk_SSL_CIPHER_push(sk, c)) {
2049 sk_SSL_CIPHER_free(sk);
2050 return NULL;
2051 }
2052 }
2053 }
2054 return sk;
2055}
8b8e5bed 2056
4f43d0e7 2057/** return a STACK of the ciphers available for the SSL and in order of
d02b48c6 2058 * algorithm id */
f73e07cf 2059STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
0f113f3e
MC		 2060{
2061 if (s != NULL) {
2062 if (s->cipher_list_by_id != NULL) {
2063 return (s->cipher_list_by_id);
2064 } else if ((s->ctx != NULL) && (s->ctx->cipher_list_by_id != NULL)) {
2065 return (s->ctx->cipher_list_by_id);
2066 }
2067 }
2068 return (NULL);
2069}
d02b48c6 2070
4f43d0e7 2071/** The old interface to get the same thing as SSL_get_ciphers() */
0f113f3e
MC		 2072const char *SSL_get_cipher_list(const SSL *s, int n)
2073{
4a640fb6 2074 const SSL_CIPHER *c;
0f113f3e
MC		 2075 STACK_OF(SSL_CIPHER) *sk;
2076
2077 if (s == NULL)
2078 return (NULL);
2079 sk = SSL_get_ciphers(s);
2080 if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
2081 return (NULL);
2082 c = sk_SSL_CIPHER_value(sk, n);
2083 if (c == NULL)
2084 return (NULL);
2085 return (c->name);
2086}
d02b48c6 2087
9d5ac953
KY		 2088/** return a STACK of the ciphers available for the SSL_CTX and in order of
2089 * preference */
2090STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx)
2091{
2092 if (ctx != NULL)
2093 return ctx->cipher_list;
2094 return NULL;
2095}
2096
25f923dd 2097/** specify the ciphers to be used by default by the SSL_CTX */
018e57c7 2098int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
0f113f3e
MC		 2099{
2100 STACK_OF(SSL_CIPHER) *sk;
2101
2102 sk = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
2103 &ctx->cipher_list_by_id, str, ctx->cert);
2104 /*
2105 * ssl_create_cipher_list may return an empty stack if it was unable to
2106 * find a cipher matching the given rule string (for example if the rule
2107 * string specifies a cipher which has been disabled). This is not an
2108 * error as far as ssl_create_cipher_list is concerned, and hence
2109 * ctx->cipher_list and ctx->cipher_list_by_id has been updated.
2110 */
2111 if (sk == NULL)
2112 return 0;
2113 else if (sk_SSL_CIPHER_num(sk) == 0) {
2114 SSLerr(SSL_F_SSL_CTX_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
2115 return 0;
2116 }
2117 return 1;
2118}
d02b48c6 2119
4f43d0e7 2120/** specify the ciphers to be used by the SSL */
0f113f3e
MC		 2121int SSL_set_cipher_list(SSL *s, const char *str)
2122{
2123 STACK_OF(SSL_CIPHER) *sk;
2124
2125 sk = ssl_create_cipher_list(s->ctx->method, &s->cipher_list,
2126 &s->cipher_list_by_id, str, s->cert);
2127 /* see comment in SSL_CTX_set_cipher_list */
2128 if (sk == NULL)
2129 return 0;
2130 else if (sk_SSL_CIPHER_num(sk) == 0) {
2131 SSLerr(SSL_F_SSL_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
2132 return 0;
2133 }
2134 return 1;
2135}
d02b48c6 2136
0f113f3e
MC		 2137char *SSL_get_shared_ciphers(const SSL *s, char *buf, int len)
2138{
2139 char *p;
2140 STACK_OF(SSL_CIPHER) *sk;
4a640fb6 2141 const SSL_CIPHER *c;
0f113f3e
MC		 2142 int i;
2143
2144 if ((s->session == NULL) || (s->session->ciphers == NULL) || (len < 2))
2145 return (NULL);
2146
2147 p = buf;
2148 sk = s->session->ciphers;
2149
2150 if (sk_SSL_CIPHER_num(sk) == 0)
2151 return NULL;
2152
2153 for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
2154 int n;
2155
2156 c = sk_SSL_CIPHER_value(sk, i);
2157 n = strlen(c->name);
2158 if (n + 1 > len) {
2159 if (p != buf)
2160 --p;
2161 *p = '\0';
2162 return buf;
2163 }
a89c9a0d 2164 memcpy(p, c->name, n + 1);
0f113f3e
MC		 2165 p += n;
2166 *(p++) = ':';
2167 len -= n + 1;
2168 }
2169 p[-1] = '\0';
2170 return (buf);
2171}
2172
52b8dad8 2173/** return a servername extension value if provided in Client Hello, or NULL.
f1fd4544 2174 * So far, only host_name types are defined (RFC 3546).
ed3883d2
BM		 2175 */
2176
f1fd4544 2177const char *SSL_get_servername(const SSL *s, const int type)
0f113f3e
MC		 2178{
2179 if (type != TLSEXT_NAMETYPE_host_name)
2180 return NULL;
a13c20f6 2181
aff8c126
RS		 2182 return s->session && !s->ext.hostname ?
2183 s->session->ext.hostname : s->ext.hostname;
0f113f3e 2184}
ed3883d2 2185
f1fd4544 2186int SSL_get_servername_type(const SSL *s)
0f113f3e
MC		 2187{
2188 if (s->session
aff8c126
RS		 2189 && (!s->ext.hostname ? s->session->
2190 ext.hostname : s->ext.hostname))
0f113f3e
MC		 2191 return TLSEXT_NAMETYPE_host_name;
2192 return -1;
2193}
ee2ffc27 2194
0f113f3e
MC		 2195/*
2196 * SSL_select_next_proto implements the standard protocol selection. It is
ee2ffc27 2197 * expected that this function is called from the callback set by
0f113f3e
MC		 2198 * SSL_CTX_set_next_proto_select_cb. The protocol data is assumed to be a
2199 * vector of 8-bit, length prefixed byte strings. The length byte itself is
2200 * not included in the length. A byte string of length 0 is invalid. No byte
2201 * string may be truncated. The current, but experimental algorithm for
2202 * selecting the protocol is: 1) If the server doesn't support NPN then this
2203 * is indicated to the callback. In this case, the client application has to
2204 * abort the connection or have a default application level protocol. 2) If
2205 * the server supports NPN, but advertises an empty list then the client
f430ba31 2206 * selects the first protocol in its list, but indicates via the API that this
0f113f3e
MC		 2207 * fallback case was enacted. 3) Otherwise, the client finds the first
2208 * protocol in the server's list that it supports and selects this protocol.
2209 * This is because it's assumed that the server has better information about
2210 * which protocol a client should use. 4) If the client doesn't support any
2211 * of the server's advertised protocols, then this is treated the same as
2212 * case 2. It returns either OPENSSL_NPN_NEGOTIATED if a common protocol was
2213 * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
ee2ffc27 2214 */
0f113f3e
MC		 2215int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
2216 const unsigned char *server,
2217 unsigned int server_len,
a230b26e 2218 const unsigned char *client, unsigned int client_len)
0f113f3e
MC		 2219{
2220 unsigned int i, j;
2221 const unsigned char *result;
2222 int status = OPENSSL_NPN_UNSUPPORTED;
2223
2224 /*
2225 * For each protocol in server preference order, see if we support it.
2226 */
2227 for (i = 0; i < server_len;) {
2228 for (j = 0; j < client_len;) {
2229 if (server[i] == client[j] &&
2230 memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) {
2231 /* We found a match */
2232 result = &server[i];
2233 status = OPENSSL_NPN_NEGOTIATED;
2234 goto found;
2235 }
2236 j += client[j];
2237 j++;
2238 }
2239 i += server[i];
2240 i++;
2241 }
2242
2243 /* There's no overlap between our protocols and the server's list. */
2244 result = client;
2245 status = OPENSSL_NPN_NO_OVERLAP;
2246
2247 found:
2248 *out = (unsigned char *)result + 1;
2249 *outlen = result[0];
2250 return status;
2251}
ee2ffc27 2252
e481f9b9 2253#ifndef OPENSSL_NO_NEXTPROTONEG
0f113f3e
MC		 2254/*
2255 * SSL_get0_next_proto_negotiated sets *data and *len to point to the
2256 * client's requested protocol for this connection and returns 0. If the
2257 * client didn't request any protocol, then *data is set to NULL. Note that
2258 * the client can request any protocol it chooses. The value returned from
2259 * this function need not be a member of the list of supported protocols
ee2ffc27
BL		 2260 * provided by the callback.
2261 */
0f113f3e
MC		 2262void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
2263 unsigned *len)
2264{
aff8c126 2265 *data = s->ext.npn;
0f113f3e
MC		 2266 if (!*data) {
2267 *len = 0;
2268 } else {
aff8c126 2269 *len = (unsigned int)s->ext.npn_len;
0f113f3e
MC		 2270 }
2271}
2272
2273/*
aff8c126 2274 * SSL_CTX_set_npn_advertised_cb sets a callback that is called when
0f113f3e
MC		 2275 * a TLS server needs a list of supported protocols for Next Protocol
2276 * Negotiation. The returned list must be in wire format. The list is
2277 * returned by setting |out| to point to it and |outlen| to its length. This
2278 * memory will not be modified, but one should assume that the SSL* keeps a
2279 * reference to it. The callback should return SSL_TLSEXT_ERR_OK if it
2280 * wishes to advertise. Otherwise, no such extension will be included in the
2281 * ServerHello.
2282 */
aff8c126 2283void SSL_CTX_set_npn_advertised_cb(SSL_CTX *ctx,
8cbfcc70 2284 SSL_CTX_npn_advertised_cb_func cb,
aff8c126 2285 void *arg)
0f113f3e 2286{
aff8c126
RS		 2287 ctx->ext.npn_advertised_cb = cb;
2288 ctx->ext.npn_advertised_cb_arg = arg;
0f113f3e
MC		 2289}
2290
2291/*
2292 * SSL_CTX_set_next_proto_select_cb sets a callback that is called when a
ee2ffc27
BL		 2293 * client needs to select a protocol from the server's provided list. |out|
2294 * must be set to point to the selected protocol (which may be within |in|).
0f113f3e
MC		 2295 * The length of the protocol name must be written into |outlen|. The
2296 * server's advertised protocols are provided in |in| and |inlen|. The
2297 * callback can assume that |in| is syntactically valid. The client must
2298 * select a protocol. It is fatal to the connection if this callback returns
2299 * a value other than SSL_TLSEXT_ERR_OK.
ee2ffc27 2300 */
aff8c126 2301void SSL_CTX_set_npn_select_cb(SSL_CTX *ctx,
8cbfcc70 2302 SSL_CTX_npn_select_cb_func cb,
aff8c126 2303 void *arg)
0f113f3e 2304{
aff8c126
RS		 2305 ctx->ext.npn_select_cb = cb;
2306 ctx->ext.npn_select_cb_arg = arg;
0f113f3e 2307}
e481f9b9 2308#endif
a398f821 2309
0f113f3e
MC		 2310/*
2311 * SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|.
6f017a8f 2312 * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
0f113f3e
MC		 2313 * length-prefixed strings). Returns 0 on success.
2314 */
2315int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
817cd0d5 2316 unsigned int protos_len)
0f113f3e 2317{
aff8c126
RS		 2318 OPENSSL_free(ctx->ext.alpn);
2319 ctx->ext.alpn = OPENSSL_memdup(protos, protos_len);
2320 if (ctx->ext.alpn == NULL) {
72e9be3d 2321 SSLerr(SSL_F_SSL_CTX_SET_ALPN_PROTOS, ERR_R_MALLOC_FAILURE);
0f113f3e 2322 return 1;
72e9be3d 2323 }
aff8c126 2324 ctx->ext.alpn_len = protos_len;
0f113f3e
MC		 2325
2326 return 0;
2327}
2328
2329/*
2330 * SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|.
6f017a8f 2331 * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
0f113f3e
MC		 2332 * length-prefixed strings). Returns 0 on success.
2333 */
2334int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
817cd0d5 2335 unsigned int protos_len)
0f113f3e 2336{
aff8c126
RS		 2337 OPENSSL_free(ssl->ext.alpn);
2338 ssl->ext.alpn = OPENSSL_memdup(protos, protos_len);
2339 if (ssl->ext.alpn == NULL) {
72e9be3d 2340 SSLerr(SSL_F_SSL_SET_ALPN_PROTOS, ERR_R_MALLOC_FAILURE);
0f113f3e 2341 return 1;
72e9be3d 2342 }
aff8c126 2343 ssl->ext.alpn_len = protos_len;
0f113f3e
MC		 2344
2345 return 0;
2346}
2347
2348/*
2349 * SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is
2350 * called during ClientHello processing in order to select an ALPN protocol
2351 * from the client's list of offered protocols.
2352 */
2353void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
8cbfcc70
RS		 2354 SSL_CTX_alpn_select_cb_func cb,
2355 void *arg)
0f113f3e 2356{
aff8c126
RS		 2357 ctx->ext.alpn_select_cb = cb;
2358 ctx->ext.alpn_select_cb_arg = arg;
0f113f3e
MC		 2359}
2360
2361/*
2362 * SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from
2363 * |ssl|. On return it sets |*data| to point to |*len| bytes of protocol name
2364 * (not including the leading length-prefix byte). If the server didn't
2365 * respond with a negotiated protocol then |*len| will be zero.
2366 */
6f017a8f 2367void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
817cd0d5 2368 unsigned int *len)
0f113f3e
MC		 2369{
2370 *data = NULL;
2371 if (ssl->s3)
2372 *data = ssl->s3->alpn_selected;
2373 if (*data == NULL)
2374 *len = 0;
2375 else
348240c6 2376 *len = (unsigned int)ssl->s3->alpn_selected_len;
0f113f3e
MC		 2377}
2378
74b4b494 2379int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
0f113f3e
MC		 2380 const char *label, size_t llen,
2381 const unsigned char *p, size_t plen,
2382 int use_context)
2383{
c8a18468 2384 if (s->version < TLS1_VERSION && s->version != DTLS1_BAD_VER)
0f113f3e 2385 return -1;
e0af0405 2386
0f113f3e
MC		 2387 return s->method->ssl3_enc->export_keying_material(s, out, olen, label,
2388 llen, p, plen,
2389 use_context);
2390}
e0af0405 2391
3c1d6bbc 2392static unsigned long ssl_session_hash(const SSL_SESSION *a)
0f113f3e 2393{
bd5d27c1 2394 const unsigned char *session_id = a->session_id;
0f113f3e 2395 unsigned long l;
bd5d27c1
DB		 2396 unsigned char tmp_storage[4];
2397
2398 if (a->session_id_length < sizeof(tmp_storage)) {
2399 memset(tmp_storage, 0, sizeof(tmp_storage));
2400 memcpy(tmp_storage, a->session_id, a->session_id_length);
2401 session_id = tmp_storage;
2402 }
0f113f3e
MC		 2403
2404 l = (unsigned long)
bd5d27c1
DB		 2405 ((unsigned long)session_id[0]) |
2406 ((unsigned long)session_id[1] << 8L) |
2407 ((unsigned long)session_id[2] << 16L) |
2408 ((unsigned long)session_id[3] << 24L);
0f113f3e
MC		 2409 return (l);
2410}
2411
2412/*
2413 * NB: If this function (or indeed the hash function which uses a sort of
dc644fe2 2414 * coarser function than this one) is changed, ensure
0f113f3e
MC		 2415 * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on
2416 * being able to construct an SSL_SESSION that will collide with any existing
2417 * session with a matching session ID.
2418 */
2419static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b)
2420{
2421 if (a->ssl_version != b->ssl_version)
2422 return (1);
2423 if (a->session_id_length != b->session_id_length)
2424 return (1);
2425 return (memcmp(a->session_id, b->session_id, a->session_id_length));
2426}
2427
2428/*
2429 * These wrapper functions should remain rather than redeclaring
d0fa136c 2430 * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
0f113f3e
MC		 2431 * variable. The reason is that the functions aren't static, they're exposed
2432 * via ssl.h.
2433 */
97b17195 2434
4ebb342f 2435SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
0f113f3e
MC		 2436{
2437 SSL_CTX *ret = NULL;
2438
2439 if (meth == NULL) {
2440 SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);
2441 return (NULL);
2442 }
2443
0fc32b07
MC		 2444 if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
2445 return NULL;
7fa792d1 2446
0f113f3e 2447 if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
4fa52141 2448 SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);
0f113f3e
MC		 2449 return NULL;
2450 }
2451
2452 if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
2453 SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
2454 goto err;
2455 }
b51bce94 2456 ret = OPENSSL_zalloc(sizeof(*ret));
0f113f3e
MC		 2457 if (ret == NULL)
2458 goto err;
2459
0f113f3e 2460 ret->method = meth;
7946ab33
KR		 2461 ret->min_proto_version = 0;
2462 ret->max_proto_version = 0;
0f113f3e
MC		 2463 ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2464 ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
64b25758 2465 /* We take the system default. */
0f113f3e 2466 ret->session_timeout = meth->get_timeout();
0f113f3e 2467 ret->references = 1;
16203f7b
AG		 2468 ret->lock = CRYPTO_THREAD_lock_new();
2469 if (ret->lock == NULL) {
2470 SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2471 OPENSSL_free(ret);
2472 return NULL;
2473 }
0f113f3e 2474 ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
0f113f3e 2475 ret->verify_mode = SSL_VERIFY_NONE;
0f113f3e
MC		 2476 if ((ret->cert = ssl_cert_new()) == NULL)
2477 goto err;
2478
62d0577e 2479 ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
0f113f3e
MC		 2480 if (ret->sessions == NULL)
2481 goto err;
2482 ret->cert_store = X509_STORE_new();
2483 if (ret->cert_store == NULL)
2484 goto err;
ed29e82a
RP		 2485#ifndef OPENSSL_NO_CT
2486 ret->ctlog_store = CTLOG_STORE_new();
2487 if (ret->ctlog_store == NULL)
2488 goto err;
2489#endif
61986d32 2490 if (!ssl_create_cipher_list(ret->method,
a230b26e
EK		 2491 &ret->cipher_list, &ret->cipher_list_by_id,
2492 SSL_DEFAULT_CIPHER_LIST, ret->cert)
2493 || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
0f113f3e
MC		 2494 SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_LIBRARY_HAS_NO_CIPHERS);
2495 goto err2;
2496 }
2497
2498 ret->param = X509_VERIFY_PARAM_new();
a71edf3b 2499 if (ret->param == NULL)
0f113f3e
MC		 2500 goto err;
2501
2502 if ((ret->md5 = EVP_get_digestbyname("ssl3-md5")) == NULL) {
2503 SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
2504 goto err2;
2505 }
2506 if ((ret->sha1 = EVP_get_digestbyname("ssl3-sha1")) == NULL) {
2507 SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
2508 goto err2;
2509 }
2510
2511 if ((ret->client_CA = sk_X509_NAME_new_null()) == NULL)
2512 goto err;
2513
25a807bc
F		 2514 if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data))
2515 goto err;
0f113f3e 2516
0f113f3e
MC		 2517 /* No compression for DTLS */
2518 if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
2519 ret->comp_methods = SSL_COMP_get_compression_methods();
2520
2521 ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
d102d9df 2522 ret->split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
566dda07 2523
4e2e1ec9 2524 /* Setup RFC5077 ticket keys */
aff8c126
RS		 2525 if ((RAND_bytes(ret->ext.tick_key_name,
2526 sizeof(ret->ext.tick_key_name)) <= 0)
2527 || (RAND_bytes(ret->ext.tick_hmac_key,
2528 sizeof(ret->ext.tick_hmac_key)) <= 0)
2529 || (RAND_bytes(ret->ext.tick_aes_key,
2530 sizeof(ret->ext.tick_aes_key)) <= 0))
0f113f3e 2531 ret->options |= SSL_OP_NO_TICKET;
6434abbf 2532
edc032b5 2533#ifndef OPENSSL_NO_SRP
61986d32 2534 if (!SSL_CTX_SRP_CTX_init(ret))
69f68237 2535 goto err;
edc032b5 2536#endif
4db9677b 2537#ifndef OPENSSL_NO_ENGINE
0f113f3e
MC		 2538# ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
2539# define eng_strx(x) #x
2540# define eng_str(x) eng_strx(x)
2541 /* Use specific client engine automatically... ignore errors */
2542 {
2543 ENGINE *eng;
2544 eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
2545 if (!eng) {
2546 ERR_clear_error();
2547 ENGINE_load_builtin_engines();
2548 eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
2549 }
2550 if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
2551 ERR_clear_error();
2552 }
2553# endif
2554#endif
2555 /*
2556 * Default is to connect to non-RI servers. When RI is more widely
2557 * deployed might change this.
2558 */
2559 ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
dc5744cb
EK		 2560 /*
2561 * Disable compression by default to prevent CRIME. Applications can
2562 * re-enable compression by configuring
2563 * SSL_CTX_clear_options(ctx, SSL_OP_NO_COMPRESSION);
2564 * or by using the SSL_CONF library.
2565 */
2566 ret->options |= SSL_OP_NO_COMPRESSION;
0f113f3e 2567
aff8c126 2568 ret->ext.status_type = TLSEXT_STATUSTYPE_nothing;
ba261f71 2569
16203f7b 2570 return ret;
0f113f3e
MC		 2571 err:
2572 SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2573 err2:
e0e920b1 2574 SSL_CTX_free(ret);
16203f7b 2575 return NULL;
0f113f3e 2576}
d02b48c6 2577
c5ebfcab 2578int SSL_CTX_up_ref(SSL_CTX *ctx)
a18a31e4 2579{
16203f7b 2580 int i;
c5ebfcab 2581
2f545ae4 2582 if (CRYPTO_UP_REF(&ctx->references, &i, ctx->lock) <= 0)
c5ebfcab
F		 2583 return 0;
2584
2585 REF_PRINT_COUNT("SSL_CTX", ctx);
2586 REF_ASSERT_ISNT(i < 2);
2587 return ((i > 1) ? 1 : 0);
a18a31e4
MC		 2588}
2589
4f43d0e7 2590void SSL_CTX_free(SSL_CTX *a)
0f113f3e
MC		 2591{
2592 int i;
d02b48c6 2593
0f113f3e
MC		 2594 if (a == NULL)
2595 return;
d02b48c6 2596
2f545ae4 2597 CRYPTO_DOWN_REF(&a->references, &i, a->lock);
f3f1cf84 2598 REF_PRINT_COUNT("SSL_CTX", a);
0f113f3e
MC		 2599 if (i > 0)
2600 return;
f3f1cf84 2601 REF_ASSERT_ISNT(i < 0);
0f113f3e 2602
222561fe 2603 X509_VERIFY_PARAM_free(a->param);
919ba009 2604 dane_ctx_final(&a->dane);
0f113f3e
MC		 2605
2606 /*
2607 * Free internal session cache. However: the remove_cb() may reference
2608 * the ex_data of SSL_CTX, thus the ex_data store can only be removed
2609 * after the sessions were flushed.
2610 * As the ex_data handling routines might also touch the session cache,
2611 * the most secure solution seems to be: empty (flush) the cache, then
2612 * free ex_data, then finally free the cache.
2613 * (See ticket [openssl.org #212].)
2614 */
2615 if (a->sessions != NULL)
2616 SSL_CTX_flush_sessions(a, 0);
2617
2618 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
25aaa98a 2619 lh_SSL_SESSION_free(a->sessions);
222561fe 2620 X509_STORE_free(a->cert_store);
ed29e82a
RP		 2621#ifndef OPENSSL_NO_CT
2622 CTLOG_STORE_free(a->ctlog_store);
2623#endif
25aaa98a
RS		 2624 sk_SSL_CIPHER_free(a->cipher_list);
2625 sk_SSL_CIPHER_free(a->cipher_list_by_id);
e0e920b1 2626 ssl_cert_free(a->cert);
222561fe
RS		 2627 sk_X509_NAME_pop_free(a->client_CA, X509_NAME_free);
2628 sk_X509_pop_free(a->extra_certs, X509_free);
0f113f3e 2629 a->comp_methods = NULL;
e783bae2 2630#ifndef OPENSSL_NO_SRTP
25aaa98a 2631 sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles);
e783bae2 2632#endif
edc032b5 2633#ifndef OPENSSL_NO_SRP
0f113f3e 2634 SSL_CTX_SRP_CTX_free(a);
edc032b5 2635#endif
bdfe932d 2636#ifndef OPENSSL_NO_ENGINE
7c96dbcd 2637 ENGINE_finish(a->client_cert_engine);
ddac1974 2638#endif
8671b898 2639
e481f9b9 2640#ifndef OPENSSL_NO_EC
aff8c126
RS		 2641 OPENSSL_free(a->ext.ecpointformats);
2642 OPENSSL_free(a->ext.supportedgroups);
8671b898 2643#endif
aff8c126 2644 OPENSSL_free(a->ext.alpn);
8671b898 2645
16203f7b
AG		 2646 CRYPTO_THREAD_lock_free(a->lock);
2647
0f113f3e
MC		 2648 OPENSSL_free(a);
2649}
d02b48c6 2650
3ae76679 2651void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
0f113f3e
MC		 2652{
2653 ctx->default_passwd_callback = cb;
2654}
2655
2656void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
2657{
2658 ctx->default_passwd_callback_userdata = u;
2659}
2660
0c452abc
CH		 2661pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)
2662{
2663 return ctx->default_passwd_callback;
2664}
2665
2666void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx)
2667{
2668 return ctx->default_passwd_callback_userdata;
2669}
2670
a974e64a
MC		 2671void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb)
2672{
2673 s->default_passwd_callback = cb;
2674}
2675
2676void SSL_set_default_passwd_cb_userdata(SSL *s, void *u)
2677{
2678 s->default_passwd_callback_userdata = u;
2679}
2680
0c452abc
CH		 2681pem_password_cb *SSL_get_default_passwd_cb(SSL *s)
2682{
2683 return s->default_passwd_callback;
2684}
2685
2686void *SSL_get_default_passwd_cb_userdata(SSL *s)
2687{
2688 return s->default_passwd_callback_userdata;
2689}
2690
0f113f3e
MC		 2691void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
2692 int (*cb) (X509_STORE_CTX *, void *),
2693 void *arg)
2694{
2695 ctx->app_verify_callback = cb;
2696 ctx->app_verify_arg = arg;
2697}
2698
2699void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
2700 int (*cb) (int, X509_STORE_CTX *))
2701{
2702 ctx->verify_mode = mode;
2703 ctx->default_verify_callback = cb;
2704}
2705
2706void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
2707{
2708 X509_VERIFY_PARAM_set_depth(ctx->param, depth);
2709}
2710
a230b26e 2711void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg), void *arg)
0f113f3e
MC		 2712{
2713 ssl_cert_set_cert_cb(c->cert, cb, arg);
2714}
2715
2716void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
2717{
2718 ssl_cert_set_cert_cb(s->cert, cb, arg);
2719}
18d71588 2720
2cf28d61 2721void ssl_set_masks(SSL *s)
0f113f3e 2722{
60f43e9e 2723#if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_GOST)
0f113f3e 2724 CERT_PKEY *cpk;
60f43e9e 2725#endif
6383d316 2726 CERT *c = s->cert;
f7d53487 2727 uint32_t *pvalid = s->s3->tmp.valid_flags;
bc71f910 2728 int rsa_enc, rsa_sign, dh_tmp, dsa_sign;
361a1191 2729 unsigned long mask_k, mask_a;
10bf4fc2 2730#ifndef OPENSSL_NO_EC
361a1191 2731 int have_ecc_cert, ecdsa_ok;
0f113f3e 2732 X509 *x = NULL;
14536c8c 2733#endif
0f113f3e
MC		 2734 if (c == NULL)
2735 return;
d02b48c6 2736
bc36ee62 2737#ifndef OPENSSL_NO_DH
0f113f3e 2738 dh_tmp = (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto);
d02b48c6 2739#else
361a1191 2740 dh_tmp = 0;
d02b48c6
RE		 2741#endif
2742
6383d316 2743 rsa_enc = pvalid[SSL_PKEY_RSA_ENC] & CERT_PKEY_VALID;
6383d316 2744 rsa_sign = pvalid[SSL_PKEY_RSA_SIGN] & CERT_PKEY_SIGN;
6383d316 2745 dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_SIGN;
14536c8c 2746#ifndef OPENSSL_NO_EC
6383d316 2747 have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID;
14536c8c 2748#endif
0f113f3e
MC		 2749 mask_k = 0;
2750 mask_a = 0;
0e1dba93 2751
d02b48c6 2752#ifdef CIPHER_DEBUG
b7557ccf
AG		 2753 fprintf(stderr, "dht=%d re=%d rs=%d ds=%d\n",
2754 dh_tmp, rsa_enc, rsa_sign, dsa_sign);
0f113f3e
MC		 2755#endif
2756
2a9b9654 2757#ifndef OPENSSL_NO_GOST
e44380a9
DB		 2758 cpk = &(c->pkeys[SSL_PKEY_GOST12_512]);
2759 if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2760 mask_k |= SSL_kGOST;
2761 mask_a |= SSL_aGOST12;
2762 }
2763 cpk = &(c->pkeys[SSL_PKEY_GOST12_256]);
2764 if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2765 mask_k |= SSL_kGOST;
2766 mask_a |= SSL_aGOST12;
2767 }
0f113f3e
MC		 2768 cpk = &(c->pkeys[SSL_PKEY_GOST01]);
2769 if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2770 mask_k |= SSL_kGOST;
2771 mask_a |= SSL_aGOST01;
2772 }
2a9b9654 2773#endif
0f113f3e 2774
361a1191 2775 if (rsa_enc)
0f113f3e 2776 mask_k |= SSL_kRSA;
d02b48c6 2777
0f113f3e
MC		 2778 if (dh_tmp)
2779 mask_k |= SSL_kDHE;
d02b48c6 2780
0f113f3e
MC		 2781 if (rsa_enc || rsa_sign) {
2782 mask_a |= SSL_aRSA;
0f113f3e 2783 }
d02b48c6 2784
0f113f3e
MC		 2785 if (dsa_sign) {
2786 mask_a |= SSL_aDSS;
0f113f3e 2787 }
d02b48c6 2788
0f113f3e 2789 mask_a |= SSL_aNULL;
d02b48c6 2790
0f113f3e
MC		 2791 /*
2792 * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites
2793 * depending on the key usage extension.
2794 */
14536c8c 2795#ifndef OPENSSL_NO_EC
0f113f3e 2796 if (have_ecc_cert) {
a8d8e06b 2797 uint32_t ex_kusage;
0f113f3e
MC		 2798 cpk = &c->pkeys[SSL_PKEY_ECC];
2799 x = cpk->x509;
a8d8e06b 2800 ex_kusage = X509_get_key_usage(x);
a8d8e06b 2801 ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE;
6383d316 2802 if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN))
0f113f3e 2803 ecdsa_ok = 0;
c7c46256 2804 if (ecdsa_ok)
0f113f3e 2805 mask_a |= SSL_aECDSA;
0f113f3e 2806 }
14536c8c 2807#endif
ea262260 2808
10bf4fc2 2809#ifndef OPENSSL_NO_EC
fe6ef247 2810 mask_k |= SSL_kECDHE;
ea262260 2811#endif
ddac1974
NL		 2812
2813#ifndef OPENSSL_NO_PSK
0f113f3e
MC		 2814 mask_k |= SSL_kPSK;
2815 mask_a |= SSL_aPSK;
526f94ad
DSH		 2816 if (mask_k & SSL_kRSA)
2817 mask_k |= SSL_kRSAPSK;
2818 if (mask_k & SSL_kDHE)
2819 mask_k |= SSL_kDHEPSK;
2820 if (mask_k & SSL_kECDHE)
2821 mask_k |= SSL_kECDHEPSK;
ddac1974
NL		 2822#endif
2823
4d69f9e6
DSH		 2824 s->s3->tmp.mask_k = mask_k;
2825 s->s3->tmp.mask_a = mask_a;
0f113f3e 2826}
d02b48c6 2827
ef236ec3
DSH		 2828#ifndef OPENSSL_NO_EC
2829
a2f9200f 2830int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
0f113f3e 2831{
ce0c1f2b 2832 if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aECDSA) {
0f113f3e 2833 /* key usage, if present, must allow signing */
ce0c1f2b 2834 if (!(X509_get_key_usage(x) & X509v3_KU_DIGITAL_SIGNATURE)) {
0f113f3e
MC		 2835 SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2836 SSL_R_ECC_CERT_NOT_FOR_SIGNING);
2837 return 0;
2838 }
2839 }
0f113f3e
MC		 2840 return 1; /* all checks are ok */
2841}
ea262260 2842
ef236ec3
DSH		 2843#endif
2844
2daceb03 2845static int ssl_get_server_cert_index(const SSL *s)
0f113f3e
MC		 2846{
2847 int idx;
3f305a80 2848
c19b863e
DSH		 2849 if (SSL_IS_TLS13(s)) {
2850 if (s->s3->tmp.sigalg == NULL) {
2851 SSLerr(SSL_F_SSL_GET_SERVER_CERT_INDEX, ERR_R_INTERNAL_ERROR);
2852 return -1;
2853 }
2854 return s->s3->tmp.cert_idx;
2855 }
2856
0f113f3e
MC		 2857 idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
2858 if (idx == SSL_PKEY_RSA_ENC && !s->cert->pkeys[SSL_PKEY_RSA_ENC].x509)
2859 idx = SSL_PKEY_RSA_SIGN;
e44380a9
DB		 2860 if (idx == SSL_PKEY_GOST_EC) {
2861 if (s->cert->pkeys[SSL_PKEY_GOST12_512].x509)
2862 idx = SSL_PKEY_GOST12_512;
2863 else if (s->cert->pkeys[SSL_PKEY_GOST12_256].x509)
2864 idx = SSL_PKEY_GOST12_256;
2865 else if (s->cert->pkeys[SSL_PKEY_GOST01].x509)
2866 idx = SSL_PKEY_GOST01;
2867 else
2868 idx = -1;
2869 }
0f113f3e
MC		 2870 if (idx == -1)
2871 SSLerr(SSL_F_SSL_GET_SERVER_CERT_INDEX, ERR_R_INTERNAL_ERROR);
2872 return idx;
2873}
a9e1c50b 2874
6383d316 2875CERT_PKEY *ssl_get_server_send_pkey(SSL *s)
0f113f3e
MC		 2876{
2877 CERT *c;
2878 int i;
ea262260 2879
0f113f3e
MC		 2880 c = s->cert;
2881 if (!s->s3 || !s->s3->tmp.new_cipher)
2882 return NULL;
2cf28d61 2883 ssl_set_masks(s);
a9e1c50b 2884
0f113f3e 2885 i = ssl_get_server_cert_index(s);
a9e1c50b 2886
0f113f3e
MC		 2887 /* This may or may not be an error. */
2888 if (i < 0)
2889 return NULL;
a9e1c50b 2890
0f113f3e
MC		 2891 /* May be NULL. */
2892 return &c->pkeys[i];
2893}
d02b48c6 2894
0f113f3e
MC		 2895EVP_PKEY *ssl_get_sign_pkey(SSL *s, const SSL_CIPHER *cipher,
2896 const EVP_MD **pmd)
2897{
2898 unsigned long alg_a;
2899 CERT *c;
2900 int idx = -1;
d02b48c6 2901
0f113f3e
MC		 2902 alg_a = cipher->algorithm_auth;
2903 c = s->cert;
d02b48c6 2904
a230b26e 2905 if ((alg_a & SSL_aDSS) && (c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
0f113f3e
MC		 2906 idx = SSL_PKEY_DSA_SIGN;
2907 else if (alg_a & SSL_aRSA) {
2908 if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
2909 idx = SSL_PKEY_RSA_SIGN;
2910 else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
2911 idx = SSL_PKEY_RSA_ENC;
2912 } else if ((alg_a & SSL_aECDSA) &&
2913 (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
2914 idx = SSL_PKEY_ECC;
2915 if (idx == -1) {
2916 SSLerr(SSL_F_SSL_GET_SIGN_PKEY, ERR_R_INTERNAL_ERROR);
2917 return (NULL);
2918 }
2919 if (pmd)
d376e57d 2920 *pmd = s->s3->tmp.md[idx];
0f113f3e
MC		 2921 return c->pkeys[idx].privatekey;
2922}
d02b48c6 2923
a398f821 2924int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
0f113f3e
MC		 2925 size_t *serverinfo_length)
2926{
2927 CERT *c = NULL;
2928 int i = 0;
2929 *serverinfo_length = 0;
2930
2931 c = s->cert;
2932 i = ssl_get_server_cert_index(s);
2933
2934 if (i == -1)
2935 return 0;
2936 if (c->pkeys[i].serverinfo == NULL)
2937 return 0;
2938
2939 *serverinfo = c->pkeys[i].serverinfo;
2940 *serverinfo_length = c->pkeys[i].serverinfo_length;
2941 return 1;
2942}
0f113f3e
MC		 2943
2944void ssl_update_cache(SSL *s, int mode)
2945{
2946 int i;
2947
2948 /*
2949 * If the session_id_length is 0, we are not supposed to cache it, and it
2950 * would be rather hard to do anyway :-)
2951 */
2952 if (s->session->session_id_length == 0)
2953 return;
2954
2955 i = s->session_ctx->session_cache_mode;
2956 if ((i & mode) && (!s->hit)
2957 && ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
2958 || SSL_CTX_add_session(s->session_ctx, s->session))
2959 && (s->session_ctx->new_session_cb != NULL)) {
16203f7b 2960 SSL_SESSION_up_ref(s->session);
0f113f3e
MC		 2961 if (!s->session_ctx->new_session_cb(s, s->session))
2962 SSL_SESSION_free(s->session);
2963 }
2964
2965 /* auto flush every 255 connections */
2966 if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) {
2967 if ((((mode & SSL_SESS_CACHE_CLIENT)
2968 ? s->session_ctx->stats.sess_connect_good
2969 : s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff) {
2970 SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL));
2971 }
2972 }
2973}
d02b48c6 2974
ba168244 2975const SSL_METHOD *SSL_CTX_get_ssl_method(SSL_CTX *ctx)
0f113f3e
MC		 2976{
2977 return ctx->method;
2978}
ba168244 2979
4ebb342f 2980const SSL_METHOD *SSL_get_ssl_method(SSL *s)
0f113f3e
MC		 2981{
2982 return (s->method);
2983}
d02b48c6 2984
4ebb342f 2985int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
0f113f3e 2986{
0f113f3e
MC		 2987 int ret = 1;
2988
2989 if (s->method != meth) {
919ba009 2990 const SSL_METHOD *sm = s->method;
a230b26e 2991 int (*hf) (SSL *) = s->handshake_func;
0f113f3e 2992
919ba009 2993 if (sm->version == meth->version)
0f113f3e
MC		 2994 s->method = meth;
2995 else {
919ba009 2996 sm->ssl_free(s);
0f113f3e
MC		 2997 s->method = meth;
2998 ret = s->method->ssl_new(s);
2999 }
3000
919ba009 3001 if (hf == sm->ssl_connect)
0f113f3e 3002 s->handshake_func = meth->ssl_connect;
919ba009 3003 else if (hf == sm->ssl_accept)
0f113f3e
MC		 3004 s->handshake_func = meth->ssl_accept;
3005 }
3006 return (ret);
3007}
3008
3009int SSL_get_error(const SSL *s, int i)
3010{
3011 int reason;
3012 unsigned long l;
3013 BIO *bio;
3014
3015 if (i > 0)
3016 return (SSL_ERROR_NONE);
3017
3018 /*
3019 * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
3020 * where we do encode the error
3021 */
3022 if ((l = ERR_peek_error()) != 0) {
3023 if (ERR_GET_LIB(l) == ERR_LIB_SYS)
3024 return (SSL_ERROR_SYSCALL);
3025 else
3026 return (SSL_ERROR_SSL);
3027 }
3028
8051ab2b
MC		 3029 if (SSL_want_read(s)) {
3030 bio = SSL_get_rbio(s);
3031 if (BIO_should_read(bio))
3032 return (SSL_ERROR_WANT_READ);
3033 else if (BIO_should_write(bio))
3034 /*
3035 * This one doesn't make too much sense ... We never try to write
3036 * to the rbio, and an application program where rbio and wbio
3037 * are separate couldn't even know what it should wait for.
3038 * However if we ever set s->rwstate incorrectly (so that we have
3039 * SSL_want_read(s) instead of SSL_want_write(s)) and rbio and
3040 * wbio *are* the same, this test works around that bug; so it
3041 * might be safer to keep it.
3042 */
3043 return (SSL_ERROR_WANT_WRITE);
3044 else if (BIO_should_io_special(bio)) {
3045 reason = BIO_get_retry_reason(bio);
3046 if (reason == BIO_RR_CONNECT)
3047 return (SSL_ERROR_WANT_CONNECT);
3048 else if (reason == BIO_RR_ACCEPT)
3049 return (SSL_ERROR_WANT_ACCEPT);
3050 else
3051 return (SSL_ERROR_SYSCALL); /* unknown */
0f113f3e 3052 }
8051ab2b 3053 }
0f113f3e 3054
8051ab2b
MC		 3055 if (SSL_want_write(s)) {
3056 /*
3057 * Access wbio directly - in order to use the buffered bio if
3058 * present
3059 */
3060 bio = s->wbio;
3061 if (BIO_should_write(bio))
3062 return (SSL_ERROR_WANT_WRITE);
3063 else if (BIO_should_read(bio))
2e7dc7cd 3064 /*
8051ab2b 3065 * See above (SSL_want_read(s) with BIO_should_write(bio))
2e7dc7cd 3066 */
8051ab2b
MC		 3067 return (SSL_ERROR_WANT_READ);
3068 else if (BIO_should_io_special(bio)) {
3069 reason = BIO_get_retry_reason(bio);
3070 if (reason == BIO_RR_CONNECT)
3071 return (SSL_ERROR_WANT_CONNECT);
3072 else if (reason == BIO_RR_ACCEPT)
3073 return (SSL_ERROR_WANT_ACCEPT);
3074 else
3075 return (SSL_ERROR_SYSCALL);
0f113f3e 3076 }
07bbc92c 3077 }
8051ab2b
MC		 3078 if (SSL_want_x509_lookup(s)) {
3079 return (SSL_ERROR_WANT_X509_LOOKUP);
0f113f3e 3080 }
8051ab2b
MC		 3081 if (SSL_want_async(s)) {
3082 return SSL_ERROR_WANT_ASYNC;
3083 }
3084 if (SSL_want_async_job(s)) {
3085 return SSL_ERROR_WANT_ASYNC_JOB;
3086 }
3087
3088 if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
3089 (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
3090 return (SSL_ERROR_ZERO_RETURN);
3091
0f113f3e
MC		 3092 return (SSL_ERROR_SYSCALL);
3093}
d02b48c6 3094
add2f5ca
MC		 3095static int ssl_do_handshake_intern(void *vargs)
3096{
3097 struct ssl_async_args *args;
3098 SSL *s;
3099
3100 args = (struct ssl_async_args *)vargs;
3101 s = args->s;
3102
3103 return s->handshake_func(s);
3104}
3105
4f43d0e7 3106int SSL_do_handshake(SSL *s)
0f113f3e
MC		 3107{
3108 int ret = 1;
3109
3110 if (s->handshake_func == NULL) {
3111 SSLerr(SSL_F_SSL_DO_HANDSHAKE, SSL_R_CONNECTION_TYPE_NOT_SET);
add2f5ca 3112 return -1;
0f113f3e
MC		 3113 }
3114
c7f47786 3115 s->method->ssl_renegotiate_check(s, 0);
0f113f3e
MC		 3116
3117 if (SSL_in_init(s) || SSL_in_before(s)) {
e8aa8b6c 3118 if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
add2f5ca
MC		 3119 struct ssl_async_args args;
3120
3121 args.s = s;
3122
7fecbf6f 3123 ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern);
add2f5ca
MC		 3124 } else {
3125 ret = s->handshake_func(s);
3126 }
0f113f3e 3127 }
add2f5ca 3128 return ret;
0f113f3e
MC		 3129}
3130
4f43d0e7 3131void SSL_set_accept_state(SSL *s)
0f113f3e
MC		 3132{
3133 s->server = 1;
3134 s->shutdown = 0;
fe3a3291 3135 ossl_statem_clear(s);
0f113f3e 3136 s->handshake_func = s->method->ssl_accept;
d31fb0b5 3137 clear_ciphers(s);
0f113f3e 3138}
d02b48c6 3139
4f43d0e7 3140void SSL_set_connect_state(SSL *s)
0f113f3e
MC		 3141{
3142 s->server = 0;
3143 s->shutdown = 0;
fe3a3291 3144 ossl_statem_clear(s);
0f113f3e 3145 s->handshake_func = s->method->ssl_connect;
d31fb0b5 3146 clear_ciphers(s);
0f113f3e 3147}
d02b48c6 3148
4f43d0e7 3149int ssl_undefined_function(SSL *s)
0f113f3e
MC		 3150{
3151 SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3152 return (0);
3153}
d02b48c6 3154
41a15c4f 3155int ssl_undefined_void_function(void)
0f113f3e
MC		 3156{
3157 SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,
3158 ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3159 return (0);
3160}
41a15c4f 3161
0821bcd4 3162int ssl_undefined_const_function(const SSL *s)
0f113f3e 3163{
0f113f3e
MC		 3164 return (0);
3165}
0821bcd4 3166
2b8fa1d5 3167const SSL_METHOD *ssl_bad_method(int ver)
0f113f3e
MC		 3168{
3169 SSLerr(SSL_F_SSL_BAD_METHOD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3170 return (NULL);
3171}
d02b48c6 3172
3eb2aff4 3173const char *ssl_protocol_to_string(int version)
7d650072 3174{
2abacef1
MC		 3175 switch(version)
3176 {
3177 case TLS1_3_VERSION:
582a17d6 3178 return "TLSv1.3";
2abacef1
MC		 3179
3180 case TLS1_2_VERSION:
7d650072 3181 return "TLSv1.2";
2abacef1
MC		 3182
3183 case TLS1_1_VERSION:
7d650072 3184 return "TLSv1.1";
2abacef1
MC		 3185
3186 case TLS1_VERSION:
ee3a6c64 3187 return "TLSv1";
2abacef1
MC		 3188
3189 case SSL3_VERSION:
7d650072 3190 return "SSLv3";
2abacef1
MC		 3191
3192 case DTLS1_BAD_VER:
7d650072 3193 return "DTLSv0.9";
2abacef1
MC		 3194
3195 case DTLS1_VERSION:
7d650072 3196 return "DTLSv1";
2abacef1
MC		 3197
3198 case DTLS1_2_VERSION:
7d650072 3199 return "DTLSv1.2";
2abacef1
MC		 3200
3201 default:
3202 return "unknown";
3203 }
0f113f3e 3204}
d02b48c6 3205
7d650072
KR		 3206const char *SSL_get_version(const SSL *s)
3207{
3eb2aff4 3208 return ssl_protocol_to_string(s->version);
7d650072
KR		 3209}
3210
4f43d0e7 3211SSL *SSL_dup(SSL *s)
0f113f3e
MC		 3212{
3213 STACK_OF(X509_NAME) *sk;
3214 X509_NAME *xn;
3215 SSL *ret;
3216 int i;
3217
919ba009
VD		 3218 /* If we're not quiescent, just up_ref! */
3219 if (!SSL_in_init(s) || !SSL_in_before(s)) {
2f545ae4 3220 CRYPTO_UP_REF(&s->references, &i, s->lock);
919ba009
VD		 3221 return s;
3222 }
3223
3224 /*
3225 * Otherwise, copy configuration state, and session if set.
3226 */
0f113f3e
MC		 3227 if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
3228 return (NULL);
3229
0f113f3e 3230 if (s->session != NULL) {
919ba009
VD		 3231 /*
3232 * Arranges to share the same session via up_ref. This "copies"
3233 * session-id, SSL_METHOD, sid_ctx, and 'cert'
3234 */
61986d32 3235 if (!SSL_copy_session_id(ret, s))
17dd65e6 3236 goto err;
0f113f3e
MC		 3237 } else {
3238 /*
3239 * No session has been established yet, so we have to expect that
3240 * s->cert or ret->cert will be changed later -- they should not both
3241 * point to the same object, and thus we can't use
3242 * SSL_copy_session_id.
3243 */
919ba009
VD		 3244 if (!SSL_set_ssl_method(ret, s->method))
3245 goto err;
0f113f3e
MC		 3246
3247 if (s->cert != NULL) {
e0e920b1 3248 ssl_cert_free(ret->cert);
0f113f3e
MC		 3249 ret->cert = ssl_cert_dup(s->cert);
3250 if (ret->cert == NULL)
3251 goto err;
3252 }
3253
348240c6
MC		 3254 if (!SSL_set_session_id_context(ret, s->sid_ctx,
3255 (int)s->sid_ctx_length))
69f68237 3256 goto err;
0f113f3e
MC		 3257 }
3258
9f6b22b8
VD		 3259 if (!ssl_dane_dup(ret, s))
3260 goto err;
919ba009 3261 ret->version = s->version;
0f113f3e
MC		 3262 ret->options = s->options;
3263 ret->mode = s->mode;
3264 SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
3265 SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
3266 ret->msg_callback = s->msg_callback;
3267 ret->msg_callback_arg = s->msg_callback_arg;
3268 SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
3269 SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
3270 ret->generate_session_id = s->generate_session_id;
3271
3272 SSL_set_info_callback(ret, SSL_get_info_callback(s));
3273
0f113f3e
MC		 3274 /* copy app data, a little dangerous perhaps */
3275 if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
3276 goto err;
3277
3278 /* setup rbio, and wbio */
3279 if (s->rbio != NULL) {
3280 if (!BIO_dup_state(s->rbio, (char *)&ret->rbio))
3281 goto err;
3282 }
3283 if (s->wbio != NULL) {
3284 if (s->wbio != s->rbio) {
3285 if (!BIO_dup_state(s->wbio, (char *)&ret->wbio))
3286 goto err;
65e2d672
MC		 3287 } else {
3288 BIO_up_ref(ret->rbio);
0f113f3e 3289 ret->wbio = ret->rbio;
65e2d672 3290 }
0f113f3e 3291 }
919ba009 3292
0f113f3e 3293 ret->server = s->server;
919ba009
VD		 3294 if (s->handshake_func) {
3295 if (s->server)
3296 SSL_set_accept_state(ret);
3297 else
3298 SSL_set_connect_state(ret);
3299 }
0f113f3e 3300 ret->shutdown = s->shutdown;
0f113f3e
MC		 3301 ret->hit = s->hit;
3302
a974e64a
MC		 3303 ret->default_passwd_callback = s->default_passwd_callback;
3304 ret->default_passwd_callback_userdata = s->default_passwd_callback_userdata;
3305
0f113f3e
MC		 3306 X509_VERIFY_PARAM_inherit(ret->param, s->param);
3307
3308 /* dup the cipher_list and cipher_list_by_id stacks */
3309 if (s->cipher_list != NULL) {
3310 if ((ret->cipher_list = sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
3311 goto err;
3312 }
3313 if (s->cipher_list_by_id != NULL)
3314 if ((ret->cipher_list_by_id = sk_SSL_CIPHER_dup(s->cipher_list_by_id))
3315 == NULL)
3316 goto err;
3317
3318 /* Dup the client_CA list */
3319 if (s->client_CA != NULL) {
3320 if ((sk = sk_X509_NAME_dup(s->client_CA)) == NULL)
3321 goto err;
3322 ret->client_CA = sk;
3323 for (i = 0; i < sk_X509_NAME_num(sk); i++) {
3324 xn = sk_X509_NAME_value(sk, i);
3325 if (sk_X509_NAME_set(sk, i, X509_NAME_dup(xn)) == NULL) {
3326 X509_NAME_free(xn);
3327 goto err;
3328 }
3329 }
3330 }
66696478 3331 return ret;
0f113f3e 3332
0f113f3e 3333 err:
66696478
RS		 3334 SSL_free(ret);
3335 return NULL;
0f113f3e 3336}
d02b48c6 3337
4f43d0e7 3338void ssl_clear_cipher_ctx(SSL *s)
0f113f3e
MC		 3339{
3340 if (s->enc_read_ctx != NULL) {
846ec07d 3341 EVP_CIPHER_CTX_free(s->enc_read_ctx);
0f113f3e
MC		 3342 s->enc_read_ctx = NULL;
3343 }
3344 if (s->enc_write_ctx != NULL) {
846ec07d 3345 EVP_CIPHER_CTX_free(s->enc_write_ctx);
0f113f3e
MC		 3346 s->enc_write_ctx = NULL;
3347 }
09b6c2ef 3348#ifndef OPENSSL_NO_COMP
efa7dd64
RS		 3349 COMP_CTX_free(s->expand);
3350 s->expand = NULL;
3351 COMP_CTX_free(s->compress);
3352 s->compress = NULL;
0f113f3e
MC		 3353#endif
3354}
d02b48c6 3355
0821bcd4 3356X509 *SSL_get_certificate(const SSL *s)
0f113f3e
MC		 3357{
3358 if (s->cert != NULL)
3359 return (s->cert->key->x509);
3360 else
3361 return (NULL);
3362}
d02b48c6 3363
a25f9adc 3364EVP_PKEY *SSL_get_privatekey(const SSL *s)
0f113f3e
MC		 3365{
3366 if (s->cert != NULL)
3367 return (s->cert->key->privatekey);
3368 else
3369 return (NULL);
3370}
d02b48c6 3371
a25f9adc 3372X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
0f113f3e
MC		 3373{
3374 if (ctx->cert != NULL)
3375 return ctx->cert->key->x509;
3376 else
3377 return NULL;
3378}
a25f9adc
DSH		 3379
3380EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
0f113f3e
MC		 3381{
3382 if (ctx->cert != NULL)
3383 return ctx->cert->key->privatekey;
3384 else
3385 return NULL;
3386}
a25f9adc 3387
babb3798 3388const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
0f113f3e
MC		 3389{
3390 if ((s->session != NULL) && (s->session->cipher != NULL))
3391 return (s->session->cipher);
3392 return (NULL);
3393}
3394
377dcdba 3395const COMP_METHOD *SSL_get_current_compression(SSL *s)
0f113f3e 3396{
9a555706
RS		 3397#ifndef OPENSSL_NO_COMP
3398 return s->compress ? COMP_CTX_get_method(s->compress) : NULL;
3399#else
3400 return NULL;
3401#endif
0f113f3e 3402}
377dcdba
RL		 3403
3404const COMP_METHOD *SSL_get_current_expansion(SSL *s)
0f113f3e 3405{
9a555706
RS		 3406#ifndef OPENSSL_NO_COMP
3407 return s->expand ? COMP_CTX_get_method(s->expand) : NULL;
3408#else
3409 return NULL;
0f113f3e 3410#endif
9a555706 3411}
0f113f3e 3412
46417569 3413int ssl_init_wbio_buffer(SSL *s)
0f113f3e
MC		 3414{
3415 BIO *bbio;
3416
2e7dc7cd
MC		 3417 if (s->bbio != NULL) {
3418 /* Already buffered. */
3419 return 1;
0f113f3e 3420 }
46417569 3421
2e7dc7cd
MC		 3422 bbio = BIO_new(BIO_f_buffer());
3423 if (bbio == NULL || !BIO_set_read_buffer_size(bbio, 1)) {
3424 BIO_free(bbio);
0f113f3e 3425 SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER, ERR_R_BUF_LIB);
46417569 3426 return 0;
0f113f3e 3427 }
2e7dc7cd
MC		 3428 s->bbio = bbio;
3429 s->wbio = BIO_push(bbio, s->wbio);
46417569
MC		 3430
3431 return 1;
0f113f3e 3432}
413c4f45 3433
4f43d0e7 3434void ssl_free_wbio_buffer(SSL *s)
0f113f3e 3435{
62adbcee 3436 /* callers ensure s is never null */
0f113f3e
MC		 3437 if (s->bbio == NULL)
3438 return;
3439
2e7dc7cd
MC		 3440 s->wbio = BIO_pop(s->wbio);
3441 assert(s->wbio != NULL);
0f113f3e
MC		 3442 BIO_free(s->bbio);
3443 s->bbio = NULL;
3444}
3445
3446void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
3447{
3448 ctx->quiet_shutdown = mode;
3449}
58964a49 3450
0821bcd4 3451int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
0f113f3e
MC		 3452{
3453 return (ctx->quiet_shutdown);
3454}
58964a49 3455
0f113f3e
MC		 3456void SSL_set_quiet_shutdown(SSL *s, int mode)
3457{
3458 s->quiet_shutdown = mode;
3459}
58964a49 3460
0821bcd4 3461int SSL_get_quiet_shutdown(const SSL *s)
0f113f3e
MC		 3462{
3463 return (s->quiet_shutdown);
3464}
58964a49 3465
0f113f3e
MC		 3466void SSL_set_shutdown(SSL *s, int mode)
3467{
3468 s->shutdown = mode;
3469}
58964a49 3470
0821bcd4 3471int SSL_get_shutdown(const SSL *s)
0f113f3e 3472{
6546e9b2 3473 return s->shutdown;
0f113f3e 3474}
58964a49 3475
0821bcd4 3476int SSL_version(const SSL *s)
0f113f3e 3477{
6546e9b2
AG		 3478 return s->version;
3479}
3480
3481int SSL_client_version(const SSL *s)
3482{
3483 return s->client_version;
0f113f3e 3484}
58964a49 3485
0821bcd4 3486SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
0f113f3e 3487{
6546e9b2 3488 return ssl->ctx;
0f113f3e
MC		 3489}
3490
3491SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
3492{
24a0d393 3493 CERT *new_cert;
0f113f3e
MC		 3494 if (ssl->ctx == ctx)
3495 return ssl->ctx;
0f113f3e 3496 if (ctx == NULL)
222da979 3497 ctx = ssl->session_ctx;
24a0d393
KR		 3498 new_cert = ssl_cert_dup(ctx->cert);
3499 if (new_cert == NULL) {
3500 return NULL;
0f113f3e 3501 }
24a0d393
KR		 3502 ssl_cert_free(ssl->cert);
3503 ssl->cert = new_cert;
0f113f3e
MC		 3504
3505 /*
3506 * Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
3507 * so setter APIs must prevent invalid lengths from entering the system.
3508 */
3509 OPENSSL_assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx));
3510
3511 /*
3512 * If the session ID context matches that of the parent SSL_CTX,
3513 * inherit it from the new SSL_CTX as well. If however the context does
3514 * not match (i.e., it was set per-ssl with SSL_set_session_id_context),
3515 * leave it unchanged.
3516 */
3517 if ((ssl->ctx != NULL) &&
3518 (ssl->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
3519 (memcmp(ssl->sid_ctx, ssl->ctx->sid_ctx, ssl->sid_ctx_length) == 0)) {
3520 ssl->sid_ctx_length = ctx->sid_ctx_length;
3521 memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
3522 }
3523
16203f7b 3524 SSL_CTX_up_ref(ctx);
a230b26e 3525 SSL_CTX_free(ssl->ctx); /* decrement reference count */
0f113f3e
MC		 3526 ssl->ctx = ctx;
3527
16203f7b 3528 return ssl->ctx;
0f113f3e 3529}
ed3883d2 3530
4f43d0e7 3531int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
0f113f3e
MC		 3532{
3533 return (X509_STORE_set_default_paths(ctx->cert_store));
3534}
58964a49 3535
d84a7b20
MC		 3536int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx)
3537{
3538 X509_LOOKUP *lookup;
3539
3540 lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_hash_dir());
3541 if (lookup == NULL)
3542 return 0;
3543 X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
3544
3545 /* Clear any errors if the default directory does not exist */
3546 ERR_clear_error();
3547
3548 return 1;
3549}
3550
3551int SSL_CTX_set_default_verify_file(SSL_CTX *ctx)
3552{
3553 X509_LOOKUP *lookup;
3554
3555 lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_file());
3556 if (lookup == NULL)
3557 return 0;
3558
3559 X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
3560
3561 /* Clear any errors if the default file does not exist */
3562 ERR_clear_error();
3563
3564 return 1;
3565}
3566
303c0028 3567int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
0f113f3e
MC		 3568 const char *CApath)
3569{
3570 return (X509_STORE_load_locations(ctx->cert_store, CAfile, CApath));
3571}
58964a49 3572
45d87a1f 3573void SSL_set_info_callback(SSL *ssl,
0f113f3e
MC		 3574 void (*cb) (const SSL *ssl, int type, int val))
3575{
3576 ssl->info_callback = cb;
3577}
3578
3579/*
3580 * One compiler (Diab DCC) doesn't like argument names in returned function
3581 * pointer.
3582 */
3583void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
3584 int /* type */ ,
3585 int /* val */ ) {
3586 return ssl->info_callback;
3587}
58964a49 3588
0f113f3e
MC		 3589void SSL_set_verify_result(SSL *ssl, long arg)
3590{
3591 ssl->verify_result = arg;
3592}
58964a49 3593
0821bcd4 3594long SSL_get_verify_result(const SSL *ssl)
0f113f3e
MC		 3595{
3596 return (ssl->verify_result);
3597}
3598
d9f1c639 3599size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
858618e7 3600{
6b8f5d0d 3601 if (outlen == 0)
858618e7
NM		 3602 return sizeof(ssl->s3->client_random);
3603 if (outlen > sizeof(ssl->s3->client_random))
3604 outlen = sizeof(ssl->s3->client_random);
3605 memcpy(out, ssl->s3->client_random, outlen);
d9f1c639 3606 return outlen;
858618e7
NM		 3607}
3608
d9f1c639 3609size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
858618e7 3610{
6b8f5d0d 3611 if (outlen == 0)
858618e7
NM		 3612 return sizeof(ssl->s3->server_random);
3613 if (outlen > sizeof(ssl->s3->server_random))
3614 outlen = sizeof(ssl->s3->server_random);
3615 memcpy(out, ssl->s3->server_random, outlen);
d9f1c639 3616 return outlen;
858618e7
NM		 3617}
3618
d9f1c639 3619size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
a230b26e 3620 unsigned char *out, size_t outlen)
858618e7 3621{
d9f1c639
MC		 3622 if (outlen == 0)
3623 return session->master_key_length;
8c1a5343 3624 if (outlen > session->master_key_length)
858618e7
NM		 3625 outlen = session->master_key_length;
3626 memcpy(out, session->master_key, outlen);
d9f1c639 3627 return outlen;
858618e7
NM		 3628}
3629
0f113f3e
MC		 3630int SSL_set_ex_data(SSL *s, int idx, void *arg)
3631{
3632 return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
3633}
3634
3635void *SSL_get_ex_data(const SSL *s, int idx)
3636{
3637 return (CRYPTO_get_ex_data(&s->ex_data, idx));
3638}
3639
0f113f3e
MC		 3640int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
3641{
3642 return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
3643}
3644
3645void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
3646{
3647 return (CRYPTO_get_ex_data(&s->ex_data, idx));
3648}
58964a49 3649
4f43d0e7 3650int ssl_ok(SSL *s)
0f113f3e
MC		 3651{
3652 return (1);
3653}
dfeab068 3654
0821bcd4 3655X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
0f113f3e
MC		 3656{
3657 return (ctx->cert_store);
3658}
413c4f45 3659
0f113f3e
MC		 3660void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
3661{
222561fe 3662 X509_STORE_free(ctx->cert_store);
0f113f3e
MC		 3663 ctx->cert_store = store;
3664}
413c4f45 3665
b50052db
TS		 3666void SSL_CTX_set1_cert_store(SSL_CTX *ctx, X509_STORE *store)
3667{
3668 if (store != NULL)
3669 X509_STORE_up_ref(store);
3670 SSL_CTX_set_cert_store(ctx, store);
3671}
3672
0821bcd4 3673int SSL_want(const SSL *s)
0f113f3e
MC		 3674{
3675 return (s->rwstate);
3676}
413c4f45 3677
0f113f3e 3678/**
4f43d0e7
BL		 3679 * \brief Set the callback for generating temporary DH keys.
3680 * \param ctx the SSL context.
3681 * \param dh the callback
3682 */
3683
bc36ee62 3684#ifndef OPENSSL_NO_DH
0f113f3e
MC		 3685void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
3686 DH *(*dh) (SSL *ssl, int is_export,
3687 int keylength))
3688{
3689 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
3690}
f8c3c05d 3691
0f113f3e
MC		 3692void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export,
3693 int keylength))
3694{
3695 SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
3696}
79df9d62 3697#endif
15d21c2d 3698
ddac1974
NL		 3699#ifndef OPENSSL_NO_PSK
3700int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
0f113f3e
MC		 3701{
3702 if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
a230b26e 3703 SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
0f113f3e
MC		 3704 return 0;
3705 }
df6da24b 3706 OPENSSL_free(ctx->cert->psk_identity_hint);
0f113f3e 3707 if (identity_hint != NULL) {
7644a9ae 3708 ctx->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
df6da24b 3709 if (ctx->cert->psk_identity_hint == NULL)
0f113f3e
MC		 3710 return 0;
3711 } else
df6da24b 3712 ctx->cert->psk_identity_hint = NULL;
0f113f3e
MC		 3713 return 1;
3714}
ddac1974
NL		 3715
3716int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
0f113f3e
MC		 3717{
3718 if (s == NULL)
3719 return 0;
3720
0f113f3e
MC		 3721 if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3722 SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
3723 return 0;
3724 }
df6da24b 3725 OPENSSL_free(s->cert->psk_identity_hint);
0f113f3e 3726 if (identity_hint != NULL) {
7644a9ae 3727 s->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
df6da24b 3728 if (s->cert->psk_identity_hint == NULL)
0f113f3e
MC		 3729 return 0;
3730 } else
df6da24b 3731 s->cert->psk_identity_hint = NULL;
0f113f3e
MC		 3732 return 1;
3733}
ddac1974
NL		 3734
3735const char *SSL_get_psk_identity_hint(const SSL *s)
0f113f3e
MC		 3736{
3737 if (s == NULL || s->session == NULL)
3738 return NULL;
3739 return (s->session->psk_identity_hint);
3740}
ddac1974
NL		 3741
3742const char *SSL_get_psk_identity(const SSL *s)
0f113f3e
MC		 3743{
3744 if (s == NULL || s->session == NULL)
3745 return NULL;
3746 return (s->session->psk_identity);
3747}
7806f3dd 3748
8cbfcc70 3749void SSL_set_psk_client_callback(SSL *s, SSL_psk_client_cb_func cb)
0f113f3e
MC		 3750{
3751 s->psk_client_callback = cb;
3752}
7806f3dd 3753
8cbfcc70 3754void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb)
0f113f3e
MC		 3755{
3756 ctx->psk_client_callback = cb;
3757}
7806f3dd 3758
8cbfcc70 3759void SSL_set_psk_server_callback(SSL *s, SSL_psk_server_cb_func cb)
0f113f3e
MC		 3760{
3761 s->psk_server_callback = cb;
3762}
7806f3dd 3763
8cbfcc70 3764void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb)
0f113f3e
MC		 3765{
3766 ctx->psk_server_callback = cb;
3767}
3768#endif
3769
3770void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
3771 void (*cb) (int write_p, int version,
3772 int content_type, const void *buf,
3773 size_t len, SSL *ssl, void *arg))
3774{
3775 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3776}
3777
3778void SSL_set_msg_callback(SSL *ssl,
3779 void (*cb) (int write_p, int version,
3780 int content_type, const void *buf,
3781 size_t len, SSL *ssl, void *arg))
3782{
3783 SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3784}
a661b653 3785
7c2d4fee 3786void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
0f113f3e
MC		 3787 int (*cb) (SSL *ssl,
3788 int
3789 is_forward_secure))
3790{
3791 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3792 (void (*)(void))cb);
3793}
3794
7c2d4fee 3795void SSL_set_not_resumable_session_callback(SSL *ssl,
0f113f3e
MC		 3796 int (*cb) (SSL *ssl,
3797 int is_forward_secure))
3798{
3799 SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3800 (void (*)(void))cb);
3801}
3802
3803/*
3804 * Allocates new EVP_MD_CTX and sets pointer to it into given pointer
8483a003 3805 * variable, freeing EVP_MD_CTX previously stored in that variable, if any.
48722ff5
F		 3806 * If EVP_MD pointer is passed, initializes ctx with this md.
3807 * Returns the newly allocated ctx;
8671b898 3808 */
b948e2c5 3809
0f113f3e 3810EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md)
b948e2c5 3811{
0f113f3e 3812 ssl_clear_hash_ctx(hash);
bfb0641f 3813 *hash = EVP_MD_CTX_new();
5f3d93e4 3814 if (*hash == NULL || (md && EVP_DigestInit_ex(*hash, md, NULL) <= 0)) {
bfb0641f 3815 EVP_MD_CTX_free(*hash);
5f3d93e4
MC		 3816 *hash = NULL;
3817 return NULL;
3818 }
0f113f3e 3819 return *hash;
b948e2c5 3820}
0f113f3e
MC		 3821
3822void ssl_clear_hash_ctx(EVP_MD_CTX **hash)
b948e2c5
DSH		 3823{
3824
0d9824c1 3825 EVP_MD_CTX_free(*hash);
0f113f3e 3826 *hash = NULL;
b948e2c5 3827}
a661b653 3828
48fbcbac 3829/* Retrieve handshake hashes */
8c1a5343
MC		 3830int ssl_handshake_hash(SSL *s, unsigned char *out, size_t outlen,
3831 size_t *hashlen)
48fbcbac 3832{
6e59a892 3833 EVP_MD_CTX *ctx = NULL;
28ba2541 3834 EVP_MD_CTX *hdgst = s->s3->handshake_dgst;
8c1a5343
MC		 3835 int hashleni = EVP_MD_CTX_size(hdgst);
3836 int ret = 0;
3837
3838 if (hashleni < 0 || (size_t)hashleni > outlen)
28ba2541 3839 goto err;
8c1a5343 3840
bfb0641f 3841 ctx = EVP_MD_CTX_new();
8c1a5343 3842 if (ctx == NULL)
6e59a892 3843 goto err;
8c1a5343 3844
6e59a892
RL		 3845 if (!EVP_MD_CTX_copy_ex(ctx, hdgst)
3846 || EVP_DigestFinal_ex(ctx, out, NULL) <= 0)
8c1a5343
MC		 3847 goto err;
3848
3849 *hashlen = hashleni;
3850
3851 ret = 1;
48fbcbac 3852 err:
bfb0641f 3853 EVP_MD_CTX_free(ctx);
48fbcbac
DSH		 3854 return ret;
3855}
3856
b577fd0b 3857int SSL_session_reused(SSL *s)
0f113f3e
MC		 3858{
3859 return s->hit;
3860}
08557cf2 3861
87adf1fa 3862int SSL_is_server(SSL *s)
0f113f3e
MC		 3863{
3864 return s->server;
3865}
87adf1fa 3866
47153c72
RS		 3867#if OPENSSL_API_COMPAT < 0x10100000L
3868void SSL_set_debug(SSL *s, int debug)
3869{
3870 /* Old function was do-nothing anyway... */
3871 (void)s;
3872 (void)debug;
3873}
3874#endif
3875
b362ccab 3876void SSL_set_security_level(SSL *s, int level)
0f113f3e
MC		 3877{
3878 s->cert->sec_level = level;
3879}
b362ccab
DSH		 3880
3881int SSL_get_security_level(const SSL *s)
0f113f3e
MC		 3882{
3883 return s->cert->sec_level;
3884}
b362ccab 3885
0f113f3e 3886void SSL_set_security_callback(SSL *s,
a230b26e
EK		 3887 int (*cb) (const SSL *s, const SSL_CTX *ctx,
3888 int op, int bits, int nid,
3889 void *other, void *ex))
0f113f3e
MC		 3890{
3891 s->cert->sec_cb = cb;
3892}
b362ccab 3893
a230b26e
EK		 3894int (*SSL_get_security_callback(const SSL *s)) (const SSL *s,
3895 const SSL_CTX *ctx, int op,
3896 int bits, int nid, void *other,
3897 void *ex) {
0f113f3e
MC		 3898 return s->cert->sec_cb;
3899}
b362ccab
DSH		 3900
3901void SSL_set0_security_ex_data(SSL *s, void *ex)
0f113f3e
MC		 3902{
3903 s->cert->sec_ex = ex;
3904}
b362ccab
DSH		 3905
3906void *SSL_get0_security_ex_data(const SSL *s)
0f113f3e
MC		 3907{
3908 return s->cert->sec_ex;
3909}
b362ccab
DSH		 3910
3911void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
0f113f3e
MC		 3912{
3913 ctx->cert->sec_level = level;
3914}
b362ccab
DSH		 3915
3916int SSL_CTX_get_security_level(const SSL_CTX *ctx)
0f113f3e
MC		 3917{
3918 return ctx->cert->sec_level;
3919}
b362ccab 3920
0f113f3e 3921void SSL_CTX_set_security_callback(SSL_CTX *ctx,
a230b26e
EK		 3922 int (*cb) (const SSL *s, const SSL_CTX *ctx,
3923 int op, int bits, int nid,
3924 void *other, void *ex))
0f113f3e
MC		 3925{
3926 ctx->cert->sec_cb = cb;
3927}
b362ccab 3928
e4646a89
KR		 3929int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
3930 const SSL_CTX *ctx,
0f113f3e
MC		 3931 int op, int bits,
3932 int nid,
3933 void *other,
3934 void *ex) {
3935 return ctx->cert->sec_cb;
3936}
b362ccab
DSH		 3937
3938void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
0f113f3e
MC		 3939{
3940 ctx->cert->sec_ex = ex;
3941}
b362ccab
DSH		 3942
3943void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
0f113f3e
MC		 3944{
3945 return ctx->cert->sec_ex;
3946}
b362ccab 3947
8106cb8b
VD		 3948/*
3949 * Get/Set/Clear options in SSL_CTX or SSL, formerly macros, now functions that
3950 * can return unsigned long, instead of the generic long return value from the
3951 * control interface.
3952 */
3953unsigned long SSL_CTX_get_options(const SSL_CTX *ctx)
3954{
3955 return ctx->options;
3956}
a230b26e
EK		 3957
3958unsigned long SSL_get_options(const SSL *s)
8106cb8b
VD		 3959{
3960 return s->options;
3961}
a230b26e 3962
8106cb8b
VD		 3963unsigned long SSL_CTX_set_options(SSL_CTX *ctx, unsigned long op)
3964{
3965 return ctx->options |= op;
3966}
a230b26e 3967
8106cb8b
VD		 3968unsigned long SSL_set_options(SSL *s, unsigned long op)
3969{
3970 return s->options |= op;
3971}
a230b26e 3972
8106cb8b
VD		 3973unsigned long SSL_CTX_clear_options(SSL_CTX *ctx, unsigned long op)
3974{
3975 return ctx->options &= ~op;
3976}
a230b26e 3977
8106cb8b
VD		 3978unsigned long SSL_clear_options(SSL *s, unsigned long op)
3979{
3980 return s->options &= ~op;
3981}
3982
696178ed
DSH		 3983STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s)
3984{
3985 return s->verified_chain;
3986}
3987
0f113f3e 3988IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
ed29e82a
RP		 3989
3990#ifndef OPENSSL_NO_CT
3991
3992/*
3993 * Moves SCTs from the |src| stack to the |dst| stack.
3994 * The source of each SCT will be set to |origin|.
3995 * If |dst| points to a NULL pointer, a new stack will be created and owned by
3996 * the caller.
3997 * Returns the number of SCTs moved, or a negative integer if an error occurs.
3998 */
a230b26e
EK		 3999static int ct_move_scts(STACK_OF(SCT) **dst, STACK_OF(SCT) *src,
4000 sct_source_t origin)
ed29e82a
RP		 4001{
4002 int scts_moved = 0;
4003 SCT *sct = NULL;
4004
4005 if (*dst == NULL) {
4006 *dst = sk_SCT_new_null();
4007 if (*dst == NULL) {
4008 SSLerr(SSL_F_CT_MOVE_SCTS, ERR_R_MALLOC_FAILURE);
4009 goto err;
4010 }
4011 }
4012
4013 while ((sct = sk_SCT_pop(src)) != NULL) {
4014 if (SCT_set_source(sct, origin) != 1)
4015 goto err;
4016
4017 if (sk_SCT_push(*dst, sct) <= 0)
4018 goto err;
4019 scts_moved += 1;
4020 }
4021
4022 return scts_moved;
a230b26e 4023 err:
ed29e82a 4024 if (sct != NULL)
a230b26e 4025 sk_SCT_push(src, sct); /* Put the SCT back */
cc7113e8 4026 return -1;
ed29e82a
RP		 4027}
4028
4029/*
a230b26e 4030 * Look for data collected during ServerHello and parse if found.
6b13bd1d 4031 * Returns the number of SCTs extracted.
a230b26e 4032 */
ed29e82a
RP		 4033static int ct_extract_tls_extension_scts(SSL *s)
4034{
4035 int scts_extracted = 0;
4036
aff8c126
RS		 4037 if (s->ext.scts != NULL) {
4038 const unsigned char *p = s->ext.scts;
4039 STACK_OF(SCT) *scts = o2i_SCT_LIST(NULL, &p, s->ext.scts_len);
ed29e82a
RP		 4040
4041 scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_TLS_EXTENSION);
4042
4043 SCT_LIST_free(scts);
4044 }
4045
4046 return scts_extracted;
4047}
4048
4049/*
4050 * Checks for an OCSP response and then attempts to extract any SCTs found if it
4051 * contains an SCT X509 extension. They will be stored in |s->scts|.
4052 * Returns:
4053 * - The number of SCTs extracted, assuming an OCSP response exists.
4054 * - 0 if no OCSP response exists or it contains no SCTs.
4055 * - A negative integer if an error occurs.
4056 */
4057static int ct_extract_ocsp_response_scts(SSL *s)
4058{
a230b26e 4059# ifndef OPENSSL_NO_OCSP
ed29e82a
RP		 4060 int scts_extracted = 0;
4061 const unsigned char *p;
4062 OCSP_BASICRESP *br = NULL;
4063 OCSP_RESPONSE *rsp = NULL;
4064 STACK_OF(SCT) *scts = NULL;
4065 int i;
4066
aff8c126 4067 if (s->ext.ocsp.resp == NULL || s->ext.ocsp.resp_len == 0)
ed29e82a
RP		 4068 goto err;
4069
aff8c126
RS		 4070 p = s->ext.ocsp.resp;
4071 rsp = d2i_OCSP_RESPONSE(NULL, &p, (int)s->ext.ocsp.resp_len);
ed29e82a
RP		 4072 if (rsp == NULL)
4073 goto err;
4074
4075 br = OCSP_response_get1_basic(rsp);
4076 if (br == NULL)
4077 goto err;
4078
4079 for (i = 0; i < OCSP_resp_count(br); ++i) {
4080 OCSP_SINGLERESP *single = OCSP_resp_get0(br, i);
4081
4082 if (single == NULL)
4083 continue;
4084
a230b26e
EK		 4085 scts =
4086 OCSP_SINGLERESP_get1_ext_d2i(single, NID_ct_cert_scts, NULL, NULL);
4087 scts_extracted =
4088 ct_move_scts(&s->scts, scts, SCT_SOURCE_OCSP_STAPLED_RESPONSE);
ed29e82a
RP		 4089 if (scts_extracted < 0)
4090 goto err;
4091 }
a230b26e 4092 err:
ed29e82a
RP		 4093 SCT_LIST_free(scts);
4094 OCSP_BASICRESP_free(br);
4095 OCSP_RESPONSE_free(rsp);
4096 return scts_extracted;
a230b26e 4097# else
3e41ac35
MC		 4098 /* Behave as if no OCSP response exists */
4099 return 0;
a230b26e 4100# endif
ed29e82a
RP		 4101}
4102
4103/*
4104 * Attempts to extract SCTs from the peer certificate.
4105 * Return the number of SCTs extracted, or a negative integer if an error
4106 * occurs.
4107 */
4108static int ct_extract_x509v3_extension_scts(SSL *s)
4109{
4110 int scts_extracted = 0;
3f3c7d26 4111 X509 *cert = s->session != NULL ? s->session->peer : NULL;
ed29e82a
RP		 4112
4113 if (cert != NULL) {
4114 STACK_OF(SCT) *scts =
4115 X509_get_ext_d2i(cert, NID_ct_precert_scts, NULL, NULL);
4116
4117 scts_extracted =
4118 ct_move_scts(&s->scts, scts, SCT_SOURCE_X509V3_EXTENSION);
4119
4120 SCT_LIST_free(scts);
4121 }
4122
4123 return scts_extracted;
4124}
4125
4126/*
4127 * Attempts to find all received SCTs by checking TLS extensions, the OCSP
4128 * response (if it exists) and X509v3 extensions in the certificate.
4129 * Returns NULL if an error occurs.
4130 */
4131const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s)
4132{
4133 if (!s->scts_parsed) {
4134 if (ct_extract_tls_extension_scts(s) < 0 ||
4135 ct_extract_ocsp_response_scts(s) < 0 ||
4136 ct_extract_x509v3_extension_scts(s) < 0)
4137 goto err;
4138
4139 s->scts_parsed = 1;
4140 }
4141 return s->scts;
a230b26e 4142 err:
ed29e82a
RP		 4143 return NULL;
4144}
4145
a230b26e 4146static int ct_permissive(const CT_POLICY_EVAL_CTX * ctx,
43341433 4147 const STACK_OF(SCT) *scts, void *unused_arg)
ed29e82a 4148{
43341433
VD		 4149 return 1;
4150}
4151
a230b26e 4152static int ct_strict(const CT_POLICY_EVAL_CTX * ctx,
43341433
VD		 4153 const STACK_OF(SCT) *scts, void *unused_arg)
4154{
4155 int count = scts != NULL ? sk_SCT_num(scts) : 0;
4156 int i;
ed29e82a 4157
43341433
VD		 4158 for (i = 0; i < count; ++i) {
4159 SCT *sct = sk_SCT_value(scts, i);
4160 int status = SCT_get_validation_status(sct);
4161
4162 if (status == SCT_VALIDATION_STATUS_VALID)
4163 return 1;
4164 }
4165 SSLerr(SSL_F_CT_STRICT, SSL_R_NO_VALID_SCTS);
4166 return 0;
4167}
4168
4169int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
4170 void *arg)
4171{
ed29e82a
RP		 4172 /*
4173 * Since code exists that uses the custom extension handler for CT, look
4174 * for this and throw an error if they have already registered to use CT.
4175 */
4176 if (callback != NULL && SSL_CTX_has_client_custom_ext(s->ctx,
a230b26e
EK		 4177 TLSEXT_TYPE_signed_certificate_timestamp))
4178 {
ed29e82a
RP		 4179 SSLerr(SSL_F_SSL_SET_CT_VALIDATION_CALLBACK,
4180 SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
43341433 4181 return 0;
ed29e82a
RP		 4182 }
4183
ed29e82a 4184 if (callback != NULL) {
a230b26e
EK		 4185 /*
4186 * If we are validating CT, then we MUST accept SCTs served via OCSP
4187 */
ed29e82a 4188 if (!SSL_set_tlsext_status_type(s, TLSEXT_STATUSTYPE_ocsp))
43341433 4189 return 0;
ed29e82a
RP		 4190 }
4191
43341433
VD		 4192 s->ct_validation_callback = callback;
4193 s->ct_validation_callback_arg = arg;
4194
4195 return 1;
ed29e82a
RP		 4196}
4197
43341433 4198int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
a230b26e 4199 ssl_ct_validation_cb callback, void *arg)
ed29e82a 4200{
ed29e82a
RP		 4201 /*
4202 * Since code exists that uses the custom extension handler for CT, look for
4203 * this and throw an error if they have already registered to use CT.
4204 */
4205 if (callback != NULL && SSL_CTX_has_client_custom_ext(ctx,
a230b26e
EK		 4206 TLSEXT_TYPE_signed_certificate_timestamp))
4207 {
ed29e82a
RP		 4208 SSLerr(SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK,
4209 SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
43341433 4210 return 0;
ed29e82a
RP		 4211 }
4212
4213 ctx->ct_validation_callback = callback;
4214 ctx->ct_validation_callback_arg = arg;
43341433 4215 return 1;
ed29e82a
RP		 4216}
4217
43341433 4218int SSL_ct_is_enabled(const SSL *s)
ed29e82a 4219{
43341433 4220 return s->ct_validation_callback != NULL;
ed29e82a
RP		 4221}
4222
43341433 4223int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx)
ed29e82a 4224{
43341433 4225 return ctx->ct_validation_callback != NULL;
ed29e82a
RP		 4226}
4227
4d482ee2 4228int ssl_validate_ct(SSL *s)
ed29e82a
RP		 4229{
4230 int ret = 0;
3f3c7d26 4231 X509 *cert = s->session != NULL ? s->session->peer : NULL;
43341433 4232 X509 *issuer;
b9aec69a 4233 SSL_DANE *dane = &s->dane;
ed29e82a
RP		 4234 CT_POLICY_EVAL_CTX *ctx = NULL;
4235 const STACK_OF(SCT) *scts;
4236
43341433
VD		 4237 /*
4238 * If no callback is set, the peer is anonymous, or its chain is invalid,
4239 * skip SCT validation - just return success. Applications that continue
4240 * handshakes without certificates, with unverified chains, or pinned leaf
4241 * certificates are outside the scope of the WebPKI and CT.
4242 *
4243 * The above exclusions notwithstanding the vast majority of peers will
4244 * have rather ordinary certificate chains validated by typical
4245 * applications that perform certificate verification and therefore will
4246 * process SCTs when enabled.
4247 */
4248 if (s->ct_validation_callback == NULL || cert == NULL ||
4249 s->verify_result != X509_V_OK ||
a230b26e 4250 s->verified_chain == NULL || sk_X509_num(s->verified_chain) <= 1)
ed29e82a
RP		 4251 return 1;
4252
43341433
VD		 4253 /*
4254 * CT not applicable for chains validated via DANE-TA(2) or DANE-EE(3)
4255 * trust-anchors. See https://tools.ietf.org/html/rfc7671#section-4.2
4256 */
4257 if (DANETLS_ENABLED(dane) && dane->mtlsa != NULL) {
4258 switch (dane->mtlsa->usage) {
4259 case DANETLS_USAGE_DANE_TA:
4260 case DANETLS_USAGE_DANE_EE:
4261 return 1;
4262 }
ed29e82a
RP		 4263 }
4264
ed29e82a
RP		 4265 ctx = CT_POLICY_EVAL_CTX_new();
4266 if (ctx == NULL) {
4267 SSLerr(SSL_F_SSL_VALIDATE_CT, ERR_R_MALLOC_FAILURE);
4268 goto end;
4269 }
4270
43341433 4271 issuer = sk_X509_value(s->verified_chain, 1);
a1bb7708
RP		 4272 CT_POLICY_EVAL_CTX_set1_cert(ctx, cert);
4273 CT_POLICY_EVAL_CTX_set1_issuer(ctx, issuer);
4274 CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(ctx, s->ctx->ctlog_store);
1fa9ffd9 4275 CT_POLICY_EVAL_CTX_set_time(ctx, SSL_SESSION_get_time(SSL_get0_session(s)));
ed29e82a
RP		 4276
4277 scts = SSL_get0_peer_scts(s);
4278
43341433
VD		 4279 /*
4280 * This function returns success (> 0) only when all the SCTs are valid, 0
4281 * when some are invalid, and < 0 on various internal errors (out of
4282 * memory, etc.). Having some, or even all, invalid SCTs is not sufficient
4283 * reason to abort the handshake, that decision is up to the callback.
4284 * Therefore, we error out only in the unexpected case that the return
4285 * value is negative.
4286 *
4287 * XXX: One might well argue that the return value of this function is an
f430ba31 4288 * unfortunate design choice. Its job is only to determine the validation
43341433
VD		 4289 * status of each of the provided SCTs. So long as it correctly separates
4290 * the wheat from the chaff it should return success. Failure in this case
4291 * ought to correspond to an inability to carry out its duties.
4292 */
4293 if (SCT_LIST_validate(scts, ctx) < 0) {
ed29e82a
RP		 4294 SSLerr(SSL_F_SSL_VALIDATE_CT, SSL_R_SCT_VERIFICATION_FAILED);
4295 goto end;
4296 }
4297
4298 ret = s->ct_validation_callback(ctx, scts, s->ct_validation_callback_arg);
4299 if (ret < 0)
a230b26e 4300 ret = 0; /* This function returns 0 on failure */
ed29e82a 4301
a230b26e 4302 end:
ed29e82a 4303 CT_POLICY_EVAL_CTX_free(ctx);
f75b34c8
VD		 4304 /*
4305 * With SSL_VERIFY_NONE the session may be cached and re-used despite a
4306 * failure return code here. Also the application may wish the complete
4307 * the handshake, and then disconnect cleanly at a higher layer, after
4308 * checking the verification status of the completed connection.
4309 *
4310 * We therefore force a certificate verification failure which will be
4311 * visible via SSL_get_verify_result() and cached as part of any resumed
4312 * session.
4313 *
4314 * Note: the permissive callback is for information gathering only, always
4315 * returns success, and does not affect verification status. Only the
4316 * strict callback or a custom application-specified callback can trigger
4317 * connection failure or record a verification error.
4318 */
4319 if (ret <= 0)
4320 s->verify_result = X509_V_ERR_NO_VALID_SCTS;
ed29e82a
RP		 4321 return ret;
4322}
4323
43341433
VD		 4324int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode)
4325{
4326 switch (validation_mode) {
4327 default:
4328 SSLerr(SSL_F_SSL_CTX_ENABLE_CT, SSL_R_INVALID_CT_VALIDATION_TYPE);
4329 return 0;
4330 case SSL_CT_VALIDATION_PERMISSIVE:
4331 return SSL_CTX_set_ct_validation_callback(ctx, ct_permissive, NULL);
4332 case SSL_CT_VALIDATION_STRICT:
4333 return SSL_CTX_set_ct_validation_callback(ctx, ct_strict, NULL);
4334 }
4335}
4336
4337int SSL_enable_ct(SSL *s, int validation_mode)
4338{
4339 switch (validation_mode) {
4340 default:
4341 SSLerr(SSL_F_SSL_ENABLE_CT, SSL_R_INVALID_CT_VALIDATION_TYPE);
4342 return 0;
4343 case SSL_CT_VALIDATION_PERMISSIVE:
4344 return SSL_set_ct_validation_callback(s, ct_permissive, NULL);
4345 case SSL_CT_VALIDATION_STRICT:
4346 return SSL_set_ct_validation_callback(s, ct_strict, NULL);
4347 }
4348}
4349
ed29e82a
RP		 4350int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx)
4351{
328f36c5 4352 return CTLOG_STORE_load_default_file(ctx->ctlog_store);
ed29e82a
RP		 4353}
4354
4355int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path)
4356{
4357 return CTLOG_STORE_load_file(ctx->ctlog_store, path);
4358}
4359
a230b26e 4360void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE * logs)
8359b57f
RP		 4361{
4362 CTLOG_STORE_free(ctx->ctlog_store);
4363 ctx->ctlog_store = logs;
4364}
4365
4366const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx)
4367{
4368 return ctx->ctlog_store;
4369}
4370
ed29e82a 4371#endif
2faa1b48
CB		 4372
4373void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb)
4374{
4375 ctx->keylog_callback = cb;
4376}
4377
4378SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx)
4379{
4380 return ctx->keylog_callback;
4381}
4382
4383static int nss_keylog_int(const char *prefix,
4384 SSL *ssl,
4385 const uint8_t *parameter_1,
4386 size_t parameter_1_len,
4387 const uint8_t *parameter_2,
4388 size_t parameter_2_len)
4389{
4390 char *out = NULL;
4391 char *cursor = NULL;
4392 size_t out_len = 0;
4393 size_t i;
4394 size_t prefix_len;
4395
4396 if (ssl->ctx->keylog_callback == NULL) return 1;
4397
4398 /*
4399 * Our output buffer will contain the following strings, rendered with
4400 * space characters in between, terminated by a NULL character: first the
4401 * prefix, then the first parameter, then the second parameter. The
4402 * meaning of each parameter depends on the specific key material being
4403 * logged. Note that the first and second parameters are encoded in
4404 * hexadecimal, so we need a buffer that is twice their lengths.
4405 */
4406 prefix_len = strlen(prefix);
4407 out_len = prefix_len + (2*parameter_1_len) + (2*parameter_2_len) + 3;
4408 if ((out = cursor = OPENSSL_malloc(out_len)) == NULL) {
4409 SSLerr(SSL_F_NSS_KEYLOG_INT, ERR_R_MALLOC_FAILURE);
4410 return 0;
4411 }
4412
4413 strcpy(cursor, prefix);
4414 cursor += prefix_len;
4415 *cursor++ = ' ';
4416
4417 for (i = 0; i < parameter_1_len; i++) {
4418 sprintf(cursor, "%02x", parameter_1[i]);
4419 cursor += 2;
4420 }
4421 *cursor++ = ' ';
4422
4423 for (i = 0; i < parameter_2_len; i++) {
4424 sprintf(cursor, "%02x", parameter_2[i]);
4425 cursor += 2;
4426 }
4427 *cursor = '\0';
4428
4429 ssl->ctx->keylog_callback(ssl, (const char *)out);
4430 OPENSSL_free(out);
4431 return 1;
4432
4433}
4434
4435int ssl_log_rsa_client_key_exchange(SSL *ssl,
4436 const uint8_t *encrypted_premaster,
4437 size_t encrypted_premaster_len,
4438 const uint8_t *premaster,
4439 size_t premaster_len)
4440{
4441 if (encrypted_premaster_len < 8) {
4442 SSLerr(SSL_F_SSL_LOG_RSA_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
4443 return 0;
4444 }
4445
f0deb4d3 4446 /* We only want the first 8 bytes of the encrypted premaster as a tag. */
2faa1b48
CB		 4447 return nss_keylog_int("RSA",
4448 ssl,
4449 encrypted_premaster,
f0deb4d3 4450 8,
2faa1b48
CB		 4451 premaster,
4452 premaster_len);
4453}
4454
2c7bd692
CB		 4455int ssl_log_secret(SSL *ssl,
4456 const char *label,
4457 const uint8_t *secret,
4458 size_t secret_len)
2faa1b48 4459{
2c7bd692 4460 return nss_keylog_int(label,
2faa1b48 4461 ssl,
2c7bd692
CB		 4462 ssl->s3->client_random,
4463 SSL3_RANDOM_SIZE,
4464 secret,
4465 secret_len);
2faa1b48
CB		 4466}
4467
A mirror of the official openssl repository