1 /* $OpenBSD: ssl_lib.c,v 1.255 2021/03/29 16:57:38 jsing Exp $ */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
8 *
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to. The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 *
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 * 1. Redistributions of source code must retain the copyright
27 * notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 * notice, this list of conditions and the following disclaimer in the
30 * documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 * must display the following acknowledgement:
33 * "This product includes cryptographic software written by
34 * Eric Young (eay@cryptsoft.com)"
35 * The word 'cryptographic' can be left out if the rouines from the library
36 * being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 * the apps directory (application code) you must include an acknowledgement:
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 *
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 *
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
57 */
58 /* ====================================================================
59 * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
60 *
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
63 * are met:
64 *
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
67 *
68 * 2. Redistributions in binary form must reproduce the above copyright
69 * notice, this list of conditions and the following disclaimer in
70 * the documentation and/or other materials provided with the
71 * distribution.
72 *
73 * 3. All advertising materials mentioning features or use of this
74 * software must display the following acknowledgment:
75 * "This product includes software developed by the OpenSSL Project
76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77 *
78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 * endorse or promote products derived from this software without
80 * prior written permission. For written permission, please contact
81 * openssl-core@openssl.org.
82 *
83 * 5. Products derived from this software may not be called "OpenSSL"
84 * nor may "OpenSSL" appear in their names without prior written
85 * permission of the OpenSSL Project.
86 *
87 * 6. Redistributions of any form whatsoever must retain the following
88 * acknowledgment:
89 * "This product includes software developed by the OpenSSL Project
90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91 *
92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 * OF THE POSSIBILITY OF SUCH DAMAGE.
104 * ====================================================================
105 *
106 * This product includes cryptographic software written by Eric Young
107 * (eay@cryptsoft.com). This product includes software written by Tim
108 * Hudson (tjh@cryptsoft.com).
109 *
110 */
111 /* ====================================================================
112 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 * ECC cipher suite support in OpenSSL originally developed by
114 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
115 */
116 /* ====================================================================
117 * Copyright 2005 Nokia. All rights reserved.
118 *
119 * The portions of the attached software ("Contribution") is developed by
120 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
121 * license.
122 *
123 * The Contribution, originally written by Mika Kousa and Pasi Eronen of
124 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
125 * support (see RFC 4279) to OpenSSL.
126 *
127 * No patent licenses or other rights except those expressly stated in
128 * the OpenSSL open source license shall be deemed granted or received
129 * expressly, by implication, estoppel, or otherwise.
130 *
131 * No assurances are provided by Nokia that the Contribution does not
132 * infringe the patent or other intellectual property rights of any third
133 * party or that the license provides you with all the necessary rights
134 * to make use of the Contribution.
135 *
136 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
137 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
138 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
139 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
140 * OTHERWISE.
141 */
142
143 #include <arpa/inet.h>
144 #include <sys/socket.h>
145 #include <netinet/in.h>
146
147 #include <stdio.h>
148
149 #include "ssl_locl.h"
150
151 #include <openssl/bn.h>
152 #include <openssl/dh.h>
153 #include <openssl/lhash.h>
154 #include <openssl/objects.h>
155 #include <openssl/ocsp.h>
156 #include <openssl/x509v3.h>
157
158 #ifndef OPENSSL_NO_ENGINE
159 #include <openssl/engine.h>
160 #endif
161
162 #include "bytestring.h"
163 #include "ssl_sigalgs.h"
164
165 const char *SSL_version_str = OPENSSL_VERSION_TEXT;
166
167 int
SSL_clear(SSL * s)168 SSL_clear(SSL *s)
169 {
170 if (s->method == NULL) {
171 SSLerror(s, SSL_R_NO_METHOD_SPECIFIED);
172 return (0);
173 }
174
175 if (ssl_clear_bad_session(s)) {
176 SSL_SESSION_free(s->session);
177 s->session = NULL;
178 }
179
180 s->error = 0;
181 s->internal->hit = 0;
182 s->internal->shutdown = 0;
183
184 if (s->internal->renegotiate) {
185 SSLerror(s, ERR_R_INTERNAL_ERROR);
186 return (0);
187 }
188
189 s->version = s->method->internal->version;
190 s->client_version = s->version;
191 s->internal->rwstate = SSL_NOTHING;
192 s->internal->rstate = SSL_ST_READ_HEADER;
193
194 tls13_ctx_free(s->internal->tls13);
195 s->internal->tls13 = NULL;
196
197 ssl3_release_init_buffer(s);
198
199 ssl_clear_cipher_state(s);
200
201 s->internal->first_packet = 0;
202
203 /*
204 * Check to see if we were changed into a different method, if
205 * so, revert back if we are not doing session-id reuse.
206 */
207 if (!s->internal->in_handshake && (s->session == NULL) &&
208 (s->method != s->ctx->method)) {
209 s->method->internal->ssl_free(s);
210 s->method = s->ctx->method;
211 if (!s->method->internal->ssl_new(s))
212 return (0);
213 } else
214 s->method->internal->ssl_clear(s);
215
216 return (1);
217 }
218
219 /* Used to change an SSL_CTXs default SSL method type */
220 int
SSL_CTX_set_ssl_version(SSL_CTX * ctx,const SSL_METHOD * meth)221 SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
222 {
223 STACK_OF(SSL_CIPHER) *ciphers;
224
225 ctx->method = meth;
226
227 ciphers = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
228 ctx->internal->cipher_list_tls13, SSL_DEFAULT_CIPHER_LIST);
229 if (ciphers == NULL || sk_SSL_CIPHER_num(ciphers) <= 0) {
230 SSLerrorx(SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
231 return (0);
232 }
233 return (1);
234 }
235
236 SSL *
SSL_new(SSL_CTX * ctx)237 SSL_new(SSL_CTX *ctx)
238 {
239 SSL *s;
240
241 if (ctx == NULL) {
242 SSLerrorx(SSL_R_NULL_SSL_CTX);
243 return (NULL);
244 }
245 if (ctx->method == NULL) {
246 SSLerrorx(SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
247 return (NULL);
248 }
249
250 if ((s = calloc(1, sizeof(*s))) == NULL)
251 goto err;
252 if ((s->internal = calloc(1, sizeof(*s->internal))) == NULL)
253 goto err;
254
255 s->internal->min_tls_version = ctx->internal->min_tls_version;
256 s->internal->max_tls_version = ctx->internal->max_tls_version;
257 s->internal->min_proto_version = ctx->internal->min_proto_version;
258 s->internal->max_proto_version = ctx->internal->max_proto_version;
259
260 s->internal->options = ctx->internal->options;
261 s->internal->mode = ctx->internal->mode;
262 s->internal->max_cert_list = ctx->internal->max_cert_list;
263
264 if ((s->cert = ssl_cert_dup(ctx->internal->cert)) == NULL)
265 goto err;
266
267 s->internal->read_ahead = ctx->internal->read_ahead;
268 s->internal->msg_callback = ctx->internal->msg_callback;
269 s->internal->msg_callback_arg = ctx->internal->msg_callback_arg;
270 s->verify_mode = ctx->verify_mode;
271 s->sid_ctx_length = ctx->sid_ctx_length;
272 OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
273 memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
274 s->internal->verify_callback = ctx->internal->default_verify_callback;
275 s->internal->generate_session_id = ctx->internal->generate_session_id;
276
277 s->param = X509_VERIFY_PARAM_new();
278 if (!s->param)
279 goto err;
280 X509_VERIFY_PARAM_inherit(s->param, ctx->param);
281 s->internal->quiet_shutdown = ctx->internal->quiet_shutdown;
282 s->max_send_fragment = ctx->internal->max_send_fragment;
283
284 CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
285 s->ctx = ctx;
286 s->internal->tlsext_debug_cb = 0;
287 s->internal->tlsext_debug_arg = NULL;
288 s->internal->tlsext_ticket_expected = 0;
289 s->tlsext_status_type = -1;
290 s->internal->tlsext_status_expected = 0;
291 s->internal->tlsext_ocsp_ids = NULL;
292 s->internal->tlsext_ocsp_exts = NULL;
293 s->internal->tlsext_ocsp_resp = NULL;
294 s->internal->tlsext_ocsp_resp_len = 0;
295 CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
296 s->initial_ctx = ctx;
297
298 if (ctx->internal->tlsext_ecpointformatlist != NULL) {
299 s->internal->tlsext_ecpointformatlist =
300 calloc(ctx->internal->tlsext_ecpointformatlist_length,
301 sizeof(ctx->internal->tlsext_ecpointformatlist[0]));
302 if (s->internal->tlsext_ecpointformatlist == NULL)
303 goto err;
304 memcpy(s->internal->tlsext_ecpointformatlist,
305 ctx->internal->tlsext_ecpointformatlist,
306 ctx->internal->tlsext_ecpointformatlist_length *
307 sizeof(ctx->internal->tlsext_ecpointformatlist[0]));
308 s->internal->tlsext_ecpointformatlist_length =
309 ctx->internal->tlsext_ecpointformatlist_length;
310 }
311 if (ctx->internal->tlsext_supportedgroups != NULL) {
312 s->internal->tlsext_supportedgroups =
313 calloc(ctx->internal->tlsext_supportedgroups_length,
314 sizeof(ctx->internal->tlsext_supportedgroups[0]));
315 if (s->internal->tlsext_supportedgroups == NULL)
316 goto err;
317 memcpy(s->internal->tlsext_supportedgroups,
318 ctx->internal->tlsext_supportedgroups,
319 ctx->internal->tlsext_supportedgroups_length *
320 sizeof(ctx->internal->tlsext_supportedgroups[0]));
321 s->internal->tlsext_supportedgroups_length =
322 ctx->internal->tlsext_supportedgroups_length;
323 }
324
325 if (s->ctx->internal->alpn_client_proto_list != NULL) {
326 s->internal->alpn_client_proto_list =
327 malloc(s->ctx->internal->alpn_client_proto_list_len);
328 if (s->internal->alpn_client_proto_list == NULL)
329 goto err;
330 memcpy(s->internal->alpn_client_proto_list,
331 s->ctx->internal->alpn_client_proto_list,
332 s->ctx->internal->alpn_client_proto_list_len);
333 s->internal->alpn_client_proto_list_len =
334 s->ctx->internal->alpn_client_proto_list_len;
335 }
336
337 s->verify_result = X509_V_OK;
338
339 s->method = ctx->method;
340
341 if (!s->method->internal->ssl_new(s))
342 goto err;
343
344 if ((s->internal->rl = tls12_record_layer_new()) == NULL)
345 goto err;
346
347 s->references = 1;
348 s->server = ctx->method->internal->server;
349
350 SSL_clear(s);
351
352 CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->internal->ex_data);
353
354 return (s);
355
356 err:
357 SSL_free(s);
358 SSLerrorx(ERR_R_MALLOC_FAILURE);
359 return (NULL);
360 }
361
362 int
SSL_CTX_set_session_id_context(SSL_CTX * ctx,const unsigned char * sid_ctx,unsigned int sid_ctx_len)363 SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
364 unsigned int sid_ctx_len)
365 {
366 if (sid_ctx_len > sizeof ctx->sid_ctx) {
367 SSLerrorx(SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
368 return (0);
369 }
370 ctx->sid_ctx_length = sid_ctx_len;
371 memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
372
373 return (1);
374 }
375
376 int
SSL_set_session_id_context(SSL * ssl,const unsigned char * sid_ctx,unsigned int sid_ctx_len)377 SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
378 unsigned int sid_ctx_len)
379 {
380 if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
381 SSLerror(ssl, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
382 return (0);
383 }
384 ssl->sid_ctx_length = sid_ctx_len;
385 memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
386
387 return (1);
388 }
389
390 int
SSL_CTX_set_generate_session_id(SSL_CTX * ctx,GEN_SESSION_CB cb)391 SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
392 {
393 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
394 ctx->internal->generate_session_id = cb;
395 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
396 return (1);
397 }
398
399 int
SSL_set_generate_session_id(SSL * ssl,GEN_SESSION_CB cb)400 SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
401 {
402 CRYPTO_w_lock(CRYPTO_LOCK_SSL);
403 ssl->internal->generate_session_id = cb;
404 CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
405 return (1);
406 }
407
408 int
SSL_has_matching_session_id(const SSL * ssl,const unsigned char * id,unsigned int id_len)409 SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
410 unsigned int id_len)
411 {
412 /*
413 * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp
414 * shows how we can "construct" a session to give us the desired
415 * check - ie. to find if there's a session in the hash table
416 * that would conflict with any new session built out of this
417 * id/id_len and the ssl_version in use by this SSL.
418 */
419 SSL_SESSION r, *p;
420
421 if (id_len > sizeof r.session_id)
422 return (0);
423
424 r.ssl_version = ssl->version;
425 r.session_id_length = id_len;
426 memcpy(r.session_id, id, id_len);
427
428 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
429 p = lh_SSL_SESSION_retrieve(ssl->ctx->internal->sessions, &r);
430 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
431 return (p != NULL);
432 }
433
434 int
SSL_CTX_set_purpose(SSL_CTX * s,int purpose)435 SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
436 {
437 return (X509_VERIFY_PARAM_set_purpose(s->param, purpose));
438 }
439
440 int
SSL_set_purpose(SSL * s,int purpose)441 SSL_set_purpose(SSL *s, int purpose)
442 {
443 return (X509_VERIFY_PARAM_set_purpose(s->param, purpose));
444 }
445
446 int
SSL_CTX_set_trust(SSL_CTX * s,int trust)447 SSL_CTX_set_trust(SSL_CTX *s, int trust)
448 {
449 return (X509_VERIFY_PARAM_set_trust(s->param, trust));
450 }
451
452 int
SSL_set_trust(SSL * s,int trust)453 SSL_set_trust(SSL *s, int trust)
454 {
455 return (X509_VERIFY_PARAM_set_trust(s->param, trust));
456 }
457
458 int
SSL_set1_host(SSL * s,const char * hostname)459 SSL_set1_host(SSL *s, const char *hostname)
460 {
461 struct in_addr ina;
462 struct in6_addr in6a;
463
464 if (hostname != NULL && *hostname != '\0' &&
465 (inet_pton(AF_INET, hostname, &ina) == 1 ||
466 inet_pton(AF_INET6, hostname, &in6a) == 1))
467 return X509_VERIFY_PARAM_set1_ip_asc(s->param, hostname);
468 else
469 return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0);
470 }
471
472 void
SSL_set_hostflags(SSL * s,unsigned int flags)473 SSL_set_hostflags(SSL *s, unsigned int flags)
474 {
475 X509_VERIFY_PARAM_set_hostflags(s->param, flags);
476 }
477
478 const char *
SSL_get0_peername(SSL * s)479 SSL_get0_peername(SSL *s)
480 {
481 return X509_VERIFY_PARAM_get0_peername(s->param);
482 }
483
484 X509_VERIFY_PARAM *
SSL_CTX_get0_param(SSL_CTX * ctx)485 SSL_CTX_get0_param(SSL_CTX *ctx)
486 {
487 return (ctx->param);
488 }
489
490 int
SSL_CTX_set1_param(SSL_CTX * ctx,X509_VERIFY_PARAM * vpm)491 SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
492 {
493 return (X509_VERIFY_PARAM_set1(ctx->param, vpm));
494 }
495
496 X509_VERIFY_PARAM *
SSL_get0_param(SSL * ssl)497 SSL_get0_param(SSL *ssl)
498 {
499 return (ssl->param);
500 }
501
502 int
SSL_set1_param(SSL * ssl,X509_VERIFY_PARAM * vpm)503 SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
504 {
505 return (X509_VERIFY_PARAM_set1(ssl->param, vpm));
506 }
507
508 void
SSL_free(SSL * s)509 SSL_free(SSL *s)
510 {
511 int i;
512
513 if (s == NULL)
514 return;
515
516 i = CRYPTO_add(&s->references, -1, CRYPTO_LOCK_SSL);
517 if (i > 0)
518 return;
519
520 X509_VERIFY_PARAM_free(s->param);
521
522 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->internal->ex_data);
523
524 if (s->bbio != NULL) {
525 /* If the buffering BIO is in place, pop it off */
526 if (s->bbio == s->wbio) {
527 s->wbio = BIO_pop(s->wbio);
528 }
529 BIO_free(s->bbio);
530 s->bbio = NULL;
531 }
532
533 if (s->rbio != s->wbio)
534 BIO_free_all(s->rbio);
535 BIO_free_all(s->wbio);
536
537 tls13_ctx_free(s->internal->tls13);
538
539 ssl3_release_init_buffer(s);
540
541 sk_SSL_CIPHER_free(s->cipher_list);
542 sk_SSL_CIPHER_free(s->internal->cipher_list_tls13);
543
544 /* Make the next call work :-) */
545 if (s->session != NULL) {
546 ssl_clear_bad_session(s);
547 SSL_SESSION_free(s->session);
548 }
549
550 ssl_clear_cipher_state(s);
551
552 ssl_cert_free(s->cert);
553
554 free(s->tlsext_hostname);
555 SSL_CTX_free(s->initial_ctx);
556
557 free(s->internal->tlsext_ecpointformatlist);
558 free(s->internal->tlsext_supportedgroups);
559
560 sk_X509_EXTENSION_pop_free(s->internal->tlsext_ocsp_exts,
561 X509_EXTENSION_free);
562 sk_OCSP_RESPID_pop_free(s->internal->tlsext_ocsp_ids, OCSP_RESPID_free);
563 free(s->internal->tlsext_ocsp_resp);
564
565 sk_X509_NAME_pop_free(s->internal->client_CA, X509_NAME_free);
566
567 if (s->method != NULL)
568 s->method->internal->ssl_free(s);
569
570 SSL_CTX_free(s->ctx);
571
572 free(s->internal->alpn_client_proto_list);
573
574 #ifndef OPENSSL_NO_SRTP
575 sk_SRTP_PROTECTION_PROFILE_free(s->internal->srtp_profiles);
576 #endif
577
578 tls12_record_layer_free(s->internal->rl);
579
580 free(s->internal);
581 free(s);
582 }
583
584 int
SSL_up_ref(SSL * s)585 SSL_up_ref(SSL *s)
586 {
587 int refs = CRYPTO_add(&s->references, 1, CRYPTO_LOCK_SSL);
588 return (refs > 1) ? 1 : 0;
589 }
590
591 void
SSL_set_bio(SSL * s,BIO * rbio,BIO * wbio)592 SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
593 {
594 /* If the output buffering BIO is still in place, remove it */
595 if (s->bbio != NULL) {
596 if (s->wbio == s->bbio) {
597 s->wbio = s->wbio->next_bio;
598 s->bbio->next_bio = NULL;
599 }
600 }
601
602 if (s->rbio != rbio && s->rbio != s->wbio)
603 BIO_free_all(s->rbio);
604 if (s->wbio != wbio)
605 BIO_free_all(s->wbio);
606 s->rbio = rbio;
607 s->wbio = wbio;
608 }
609
610 BIO *
SSL_get_rbio(const SSL * s)611 SSL_get_rbio(const SSL *s)
612 {
613 return (s->rbio);
614 }
615
616 BIO *
SSL_get_wbio(const SSL * s)617 SSL_get_wbio(const SSL *s)
618 {
619 return (s->wbio);
620 }
621
622 int
SSL_get_fd(const SSL * s)623 SSL_get_fd(const SSL *s)
624 {
625 return (SSL_get_rfd(s));
626 }
627
628 int
SSL_get_rfd(const SSL * s)629 SSL_get_rfd(const SSL *s)
630 {
631 int ret = -1;
632 BIO *b, *r;
633
634 b = SSL_get_rbio(s);
635 r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
636 if (r != NULL)
637 BIO_get_fd(r, &ret);
638 return (ret);
639 }
640
641 int
SSL_get_wfd(const SSL * s)642 SSL_get_wfd(const SSL *s)
643 {
644 int ret = -1;
645 BIO *b, *r;
646
647 b = SSL_get_wbio(s);
648 r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
649 if (r != NULL)
650 BIO_get_fd(r, &ret);
651 return (ret);
652 }
653
654 int
SSL_set_fd(SSL * s,int fd)655 SSL_set_fd(SSL *s, int fd)
656 {
657 int ret = 0;
658 BIO *bio = NULL;
659
660 bio = BIO_new(BIO_s_socket());
661
662 if (bio == NULL) {
663 SSLerror(s, ERR_R_BUF_LIB);
664 goto err;
665 }
666 BIO_set_fd(bio, fd, BIO_NOCLOSE);
667 SSL_set_bio(s, bio, bio);
668 ret = 1;
669 err:
670 return (ret);
671 }
672
673 int
SSL_set_wfd(SSL * s,int fd)674 SSL_set_wfd(SSL *s, int fd)
675 {
676 int ret = 0;
677 BIO *bio = NULL;
678
679 if ((s->rbio == NULL) || (BIO_method_type(s->rbio) != BIO_TYPE_SOCKET)
680 || ((int)BIO_get_fd(s->rbio, NULL) != fd)) {
681 bio = BIO_new(BIO_s_socket());
682
683 if (bio == NULL) {
684 SSLerror(s, ERR_R_BUF_LIB);
685 goto err;
686 }
687 BIO_set_fd(bio, fd, BIO_NOCLOSE);
688 SSL_set_bio(s, SSL_get_rbio(s), bio);
689 } else
690 SSL_set_bio(s, SSL_get_rbio(s), SSL_get_rbio(s));
691 ret = 1;
692 err:
693 return (ret);
694 }
695
696 int
SSL_set_rfd(SSL * s,int fd)697 SSL_set_rfd(SSL *s, int fd)
698 {
699 int ret = 0;
700 BIO *bio = NULL;
701
702 if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
703 || ((int)BIO_get_fd(s->wbio, NULL) != fd)) {
704 bio = BIO_new(BIO_s_socket());
705
706 if (bio == NULL) {
707 SSLerror(s, ERR_R_BUF_LIB);
708 goto err;
709 }
710 BIO_set_fd(bio, fd, BIO_NOCLOSE);
711 SSL_set_bio(s, bio, SSL_get_wbio(s));
712 } else
713 SSL_set_bio(s, SSL_get_wbio(s), SSL_get_wbio(s));
714 ret = 1;
715 err:
716 return (ret);
717 }
718
719
720 /* return length of latest Finished message we sent, copy to 'buf' */
721 size_t
SSL_get_finished(const SSL * s,void * buf,size_t count)722 SSL_get_finished(const SSL *s, void *buf, size_t count)
723 {
724 size_t ret;
725
726 ret = S3I(s)->hs.finished_len;
727 if (count > ret)
728 count = ret;
729 memcpy(buf, S3I(s)->hs.finished, count);
730 return (ret);
731 }
732
733 /* return length of latest Finished message we expected, copy to 'buf' */
734 size_t
SSL_get_peer_finished(const SSL * s,void * buf,size_t count)735 SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
736 {
737 size_t ret;
738
739 ret = S3I(s)->hs.peer_finished_len;
740 if (count > ret)
741 count = ret;
742 memcpy(buf, S3I(s)->hs.peer_finished, count);
743 return (ret);
744 }
745
746
747 int
SSL_get_verify_mode(const SSL * s)748 SSL_get_verify_mode(const SSL *s)
749 {
750 return (s->verify_mode);
751 }
752
753 int
SSL_get_verify_depth(const SSL * s)754 SSL_get_verify_depth(const SSL *s)
755 {
756 return (X509_VERIFY_PARAM_get_depth(s->param));
757 }
758
759 int
SSL_get_verify_callback(const SSL * s)760 (*SSL_get_verify_callback(const SSL *s))(int, X509_STORE_CTX *)
761 {
762 return (s->internal->verify_callback);
763 }
764
765 int
SSL_CTX_get_verify_mode(const SSL_CTX * ctx)766 SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
767 {
768 return (ctx->verify_mode);
769 }
770
771 int
SSL_CTX_get_verify_depth(const SSL_CTX * ctx)772 SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
773 {
774 return (X509_VERIFY_PARAM_get_depth(ctx->param));
775 }
776
777 int
SSL_CTX_get_verify_callback(const SSL_CTX * ctx)778 (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int, X509_STORE_CTX *)
779 {
780 return (ctx->internal->default_verify_callback);
781 }
782
783 void
SSL_set_verify(SSL * s,int mode,int (* callback)(int ok,X509_STORE_CTX * ctx))784 SSL_set_verify(SSL *s, int mode,
785 int (*callback)(int ok, X509_STORE_CTX *ctx))
786 {
787 s->verify_mode = mode;
788 if (callback != NULL)
789 s->internal->verify_callback = callback;
790 }
791
792 void
SSL_set_verify_depth(SSL * s,int depth)793 SSL_set_verify_depth(SSL *s, int depth)
794 {
795 X509_VERIFY_PARAM_set_depth(s->param, depth);
796 }
797
798 void
SSL_set_read_ahead(SSL * s,int yes)799 SSL_set_read_ahead(SSL *s, int yes)
800 {
801 s->internal->read_ahead = yes;
802 }
803
804 int
SSL_get_read_ahead(const SSL * s)805 SSL_get_read_ahead(const SSL *s)
806 {
807 return (s->internal->read_ahead);
808 }
809
810 int
SSL_pending(const SSL * s)811 SSL_pending(const SSL *s)
812 {
813 return (s->method->internal->ssl_pending(s));
814 }
815
816 X509 *
SSL_get_peer_certificate(const SSL * s)817 SSL_get_peer_certificate(const SSL *s)
818 {
819 X509 *r;
820
821 if ((s == NULL) || (s->session == NULL))
822 r = NULL;
823 else
824 r = s->session->peer;
825
826 if (r == NULL)
827 return (r);
828
829 CRYPTO_add(&r->references, 1, CRYPTO_LOCK_X509);
830
831 return (r);
832 }
833
STACK_OF(X509)834 STACK_OF(X509) *
835 SSL_get_peer_cert_chain(const SSL *s)
836 {
837 STACK_OF(X509) *r;
838
839 if ((s == NULL) || (s->session == NULL) ||
840 (SSI(s)->sess_cert == NULL))
841 r = NULL;
842 else
843 r = SSI(s)->sess_cert->cert_chain;
844
845 /*
846 * If we are a client, cert_chain includes the peer's own
847 * certificate;
848 * if we are a server, it does not.
849 */
850 return (r);
851 }
852
853 /*
854 * Now in theory, since the calling process own 't' it should be safe to
855 * modify. We need to be able to read f without being hassled
856 */
857 int
SSL_copy_session_id(SSL * t,const SSL * f)858 SSL_copy_session_id(SSL *t, const SSL *f)
859 {
860 CERT *tmp;
861
862 /* Do we need to do SSL locking? */
863 if (!SSL_set_session(t, SSL_get_session(f)))
864 return 0;
865
866 /* What if we are set up for one protocol but want to talk another? */
867 if (t->method != f->method) {
868 t->method->internal->ssl_free(t);
869 t->method = f->method;
870 if (!t->method->internal->ssl_new(t))
871 return 0;
872 }
873
874 tmp = t->cert;
875 if (f->cert != NULL) {
876 CRYPTO_add(&f->cert->references, 1, CRYPTO_LOCK_SSL_CERT);
877 t->cert = f->cert;
878 } else
879 t->cert = NULL;
880 ssl_cert_free(tmp);
881
882 if (!SSL_set_session_id_context(t, f->sid_ctx, f->sid_ctx_length))
883 return 0;
884
885 return 1;
886 }
887
888 /* Fix this so it checks all the valid key/cert options */
889 int
SSL_CTX_check_private_key(const SSL_CTX * ctx)890 SSL_CTX_check_private_key(const SSL_CTX *ctx)
891 {
892 if ((ctx == NULL) || (ctx->internal->cert == NULL) ||
893 (ctx->internal->cert->key->x509 == NULL)) {
894 SSLerrorx(SSL_R_NO_CERTIFICATE_ASSIGNED);
895 return (0);
896 }
897 if (ctx->internal->cert->key->privatekey == NULL) {
898 SSLerrorx(SSL_R_NO_PRIVATE_KEY_ASSIGNED);
899 return (0);
900 }
901 return (X509_check_private_key(ctx->internal->cert->key->x509,
902 ctx->internal->cert->key->privatekey));
903 }
904
905 /* Fix this function so that it takes an optional type parameter */
906 int
SSL_check_private_key(const SSL * ssl)907 SSL_check_private_key(const SSL *ssl)
908 {
909 if (ssl == NULL) {
910 SSLerrorx(ERR_R_PASSED_NULL_PARAMETER);
911 return (0);
912 }
913 if (ssl->cert == NULL) {
914 SSLerror(ssl, SSL_R_NO_CERTIFICATE_ASSIGNED);
915 return (0);
916 }
917 if (ssl->cert->key->x509 == NULL) {
918 SSLerror(ssl, SSL_R_NO_CERTIFICATE_ASSIGNED);
919 return (0);
920 }
921 if (ssl->cert->key->privatekey == NULL) {
922 SSLerror(ssl, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
923 return (0);
924 }
925 return (X509_check_private_key(ssl->cert->key->x509,
926 ssl->cert->key->privatekey));
927 }
928
929 int
SSL_accept(SSL * s)930 SSL_accept(SSL *s)
931 {
932 if (s->internal->handshake_func == NULL)
933 SSL_set_accept_state(s); /* Not properly initialized yet */
934
935 return (s->method->internal->ssl_accept(s));
936 }
937
938 int
SSL_connect(SSL * s)939 SSL_connect(SSL *s)
940 {
941 if (s->internal->handshake_func == NULL)
942 SSL_set_connect_state(s); /* Not properly initialized yet */
943
944 return (s->method->internal->ssl_connect(s));
945 }
946
947 int
SSL_is_dtls(const SSL * s)948 SSL_is_dtls(const SSL *s)
949 {
950 return s->method->internal->dtls;
951 }
952
953 int
SSL_is_server(const SSL * s)954 SSL_is_server(const SSL *s)
955 {
956 return s->server;
957 }
958
959 static long
ssl_get_default_timeout()960 ssl_get_default_timeout()
961 {
962 /*
963 * 2 hours, the 24 hours mentioned in the TLSv1 spec
964 * is way too long for http, the cache would over fill.
965 */
966 return (2 * 60 * 60);
967 }
968
969 long
SSL_get_default_timeout(const SSL * s)970 SSL_get_default_timeout(const SSL *s)
971 {
972 return (ssl_get_default_timeout());
973 }
974
975 int
SSL_read(SSL * s,void * buf,int num)976 SSL_read(SSL *s, void *buf, int num)
977 {
978 if (s->internal->handshake_func == NULL) {
979 SSLerror(s, SSL_R_UNINITIALIZED);
980 return (-1);
981 }
982
983 if (s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) {
984 s->internal->rwstate = SSL_NOTHING;
985 return (0);
986 }
987 return ssl3_read(s, buf, num);
988 }
989
990 int
SSL_peek(SSL * s,void * buf,int num)991 SSL_peek(SSL *s, void *buf, int num)
992 {
993 if (s->internal->handshake_func == NULL) {
994 SSLerror(s, SSL_R_UNINITIALIZED);
995 return (-1);
996 }
997
998 if (s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) {
999 return (0);
1000 }
1001 return ssl3_peek(s, buf, num);
1002 }
1003
1004 int
SSL_write(SSL * s,const void * buf,int num)1005 SSL_write(SSL *s, const void *buf, int num)
1006 {
1007 if (s->internal->handshake_func == NULL) {
1008 SSLerror(s, SSL_R_UNINITIALIZED);
1009 return (-1);
1010 }
1011
1012 if (s->internal->shutdown & SSL_SENT_SHUTDOWN) {
1013 s->internal->rwstate = SSL_NOTHING;
1014 SSLerror(s, SSL_R_PROTOCOL_IS_SHUTDOWN);
1015 return (-1);
1016 }
1017 return ssl3_write(s, buf, num);
1018 }
1019
1020 uint32_t
SSL_CTX_get_max_early_data(const SSL_CTX * ctx)1021 SSL_CTX_get_max_early_data(const SSL_CTX *ctx)
1022 {
1023 return 0;
1024 }
1025
1026 int
SSL_CTX_set_max_early_data(SSL_CTX * ctx,uint32_t max_early_data)1027 SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data)
1028 {
1029 return 1;
1030 }
1031
1032 uint32_t
SSL_get_max_early_data(const SSL * s)1033 SSL_get_max_early_data(const SSL *s)
1034 {
1035 return 0;
1036 }
1037
1038 int
SSL_set_max_early_data(SSL * s,uint32_t max_early_data)1039 SSL_set_max_early_data(SSL *s, uint32_t max_early_data)
1040 {
1041 return 1;
1042 }
1043
1044 int
SSL_get_early_data_status(const SSL * s)1045 SSL_get_early_data_status(const SSL *s)
1046 {
1047 return SSL_EARLY_DATA_REJECTED;
1048 }
1049
1050 int
SSL_read_early_data(SSL * s,void * buf,size_t num,size_t * readbytes)1051 SSL_read_early_data(SSL *s, void *buf, size_t num, size_t *readbytes)
1052 {
1053 *readbytes = 0;
1054
1055 if (!s->server) {
1056 SSLerror(s, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1057 return SSL_READ_EARLY_DATA_ERROR;
1058 }
1059
1060 return SSL_READ_EARLY_DATA_FINISH;
1061 }
1062
1063 int
SSL_write_early_data(SSL * s,const void * buf,size_t num,size_t * written)1064 SSL_write_early_data(SSL *s, const void *buf, size_t num, size_t *written)
1065 {
1066 *written = 0;
1067 SSLerror(s, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1068 return 0;
1069 }
1070
1071 int
SSL_shutdown(SSL * s)1072 SSL_shutdown(SSL *s)
1073 {
1074 /*
1075 * Note that this function behaves differently from what one might
1076 * expect. Return values are 0 for no success (yet),
1077 * 1 for success; but calling it once is usually not enough,
1078 * even if blocking I/O is used (see ssl3_shutdown).
1079 */
1080
1081 if (s->internal->handshake_func == NULL) {
1082 SSLerror(s, SSL_R_UNINITIALIZED);
1083 return (-1);
1084 }
1085
1086 if (s != NULL && !SSL_in_init(s))
1087 return (s->method->internal->ssl_shutdown(s));
1088
1089 return (1);
1090 }
1091
1092 int
SSL_renegotiate(SSL * s)1093 SSL_renegotiate(SSL *s)
1094 {
1095 if (s->internal->renegotiate == 0)
1096 s->internal->renegotiate = 1;
1097
1098 s->internal->new_session = 1;
1099
1100 return (s->method->internal->ssl_renegotiate(s));
1101 }
1102
1103 int
SSL_renegotiate_abbreviated(SSL * s)1104 SSL_renegotiate_abbreviated(SSL *s)
1105 {
1106 if (s->internal->renegotiate == 0)
1107 s->internal->renegotiate = 1;
1108
1109 s->internal->new_session = 0;
1110
1111 return (s->method->internal->ssl_renegotiate(s));
1112 }
1113
1114 int
SSL_renegotiate_pending(SSL * s)1115 SSL_renegotiate_pending(SSL *s)
1116 {
1117 /*
1118 * Becomes true when negotiation is requested;
1119 * false again once a handshake has finished.
1120 */
1121 return (s->internal->renegotiate != 0);
1122 }
1123
1124 long
SSL_ctrl(SSL * s,int cmd,long larg,void * parg)1125 SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
1126 {
1127 long l;
1128
1129 switch (cmd) {
1130 case SSL_CTRL_GET_READ_AHEAD:
1131 return (s->internal->read_ahead);
1132 case SSL_CTRL_SET_READ_AHEAD:
1133 l = s->internal->read_ahead;
1134 s->internal->read_ahead = larg;
1135 return (l);
1136
1137 case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1138 s->internal->msg_callback_arg = parg;
1139 return (1);
1140
1141 case SSL_CTRL_OPTIONS:
1142 return (s->internal->options|=larg);
1143 case SSL_CTRL_CLEAR_OPTIONS:
1144 return (s->internal->options&=~larg);
1145 case SSL_CTRL_MODE:
1146 return (s->internal->mode|=larg);
1147 case SSL_CTRL_CLEAR_MODE:
1148 return (s->internal->mode &=~larg);
1149 case SSL_CTRL_GET_MAX_CERT_LIST:
1150 return (s->internal->max_cert_list);
1151 case SSL_CTRL_SET_MAX_CERT_LIST:
1152 l = s->internal->max_cert_list;
1153 s->internal->max_cert_list = larg;
1154 return (l);
1155 case SSL_CTRL_SET_MTU:
1156 #ifndef OPENSSL_NO_DTLS1
1157 if (larg < (long)dtls1_min_mtu())
1158 return (0);
1159 #endif
1160 if (SSL_is_dtls(s)) {
1161 D1I(s)->mtu = larg;
1162 return (larg);
1163 }
1164 return (0);
1165 case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1166 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1167 return (0);
1168 s->max_send_fragment = larg;
1169 return (1);
1170 case SSL_CTRL_GET_RI_SUPPORT:
1171 if (s->s3)
1172 return (S3I(s)->send_connection_binding);
1173 else return (0);
1174 default:
1175 if (SSL_is_dtls(s))
1176 return dtls1_ctrl(s, cmd, larg, parg);
1177 return ssl3_ctrl(s, cmd, larg, parg);
1178 }
1179 }
1180
1181 long
SSL_callback_ctrl(SSL * s,int cmd,void (* fp)(void))1182 SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
1183 {
1184 switch (cmd) {
1185 case SSL_CTRL_SET_MSG_CALLBACK:
1186 s->internal->msg_callback = (void (*)(int write_p, int version,
1187 int content_type, const void *buf, size_t len,
1188 SSL *ssl, void *arg))(fp);
1189 return (1);
1190
1191 default:
1192 return (ssl3_callback_ctrl(s, cmd, fp));
1193 }
1194 }
1195
1196 struct lhash_st_SSL_SESSION *
SSL_CTX_sessions(SSL_CTX * ctx)1197 SSL_CTX_sessions(SSL_CTX *ctx)
1198 {
1199 return (ctx->internal->sessions);
1200 }
1201
1202 long
SSL_CTX_ctrl(SSL_CTX * ctx,int cmd,long larg,void * parg)1203 SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
1204 {
1205 long l;
1206
1207 switch (cmd) {
1208 case SSL_CTRL_GET_READ_AHEAD:
1209 return (ctx->internal->read_ahead);
1210 case SSL_CTRL_SET_READ_AHEAD:
1211 l = ctx->internal->read_ahead;
1212 ctx->internal->read_ahead = larg;
1213 return (l);
1214
1215 case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1216 ctx->internal->msg_callback_arg = parg;
1217 return (1);
1218
1219 case SSL_CTRL_GET_MAX_CERT_LIST:
1220 return (ctx->internal->max_cert_list);
1221 case SSL_CTRL_SET_MAX_CERT_LIST:
1222 l = ctx->internal->max_cert_list;
1223 ctx->internal->max_cert_list = larg;
1224 return (l);
1225
1226 case SSL_CTRL_SET_SESS_CACHE_SIZE:
1227 l = ctx->internal->session_cache_size;
1228 ctx->internal->session_cache_size = larg;
1229 return (l);
1230 case SSL_CTRL_GET_SESS_CACHE_SIZE:
1231 return (ctx->internal->session_cache_size);
1232 case SSL_CTRL_SET_SESS_CACHE_MODE:
1233 l = ctx->internal->session_cache_mode;
1234 ctx->internal->session_cache_mode = larg;
1235 return (l);
1236 case SSL_CTRL_GET_SESS_CACHE_MODE:
1237 return (ctx->internal->session_cache_mode);
1238
1239 case SSL_CTRL_SESS_NUMBER:
1240 return (lh_SSL_SESSION_num_items(ctx->internal->sessions));
1241 case SSL_CTRL_SESS_CONNECT:
1242 return (ctx->internal->stats.sess_connect);
1243 case SSL_CTRL_SESS_CONNECT_GOOD:
1244 return (ctx->internal->stats.sess_connect_good);
1245 case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
1246 return (ctx->internal->stats.sess_connect_renegotiate);
1247 case SSL_CTRL_SESS_ACCEPT:
1248 return (ctx->internal->stats.sess_accept);
1249 case SSL_CTRL_SESS_ACCEPT_GOOD:
1250 return (ctx->internal->stats.sess_accept_good);
1251 case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
1252 return (ctx->internal->stats.sess_accept_renegotiate);
1253 case SSL_CTRL_SESS_HIT:
1254 return (ctx->internal->stats.sess_hit);
1255 case SSL_CTRL_SESS_CB_HIT:
1256 return (ctx->internal->stats.sess_cb_hit);
1257 case SSL_CTRL_SESS_MISSES:
1258 return (ctx->internal->stats.sess_miss);
1259 case SSL_CTRL_SESS_TIMEOUTS:
1260 return (ctx->internal->stats.sess_timeout);
1261 case SSL_CTRL_SESS_CACHE_FULL:
1262 return (ctx->internal->stats.sess_cache_full);
1263 case SSL_CTRL_OPTIONS:
1264 return (ctx->internal->options|=larg);
1265 case SSL_CTRL_CLEAR_OPTIONS:
1266 return (ctx->internal->options&=~larg);
1267 case SSL_CTRL_MODE:
1268 return (ctx->internal->mode|=larg);
1269 case SSL_CTRL_CLEAR_MODE:
1270 return (ctx->internal->mode&=~larg);
1271 case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1272 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1273 return (0);
1274 ctx->internal->max_send_fragment = larg;
1275 return (1);
1276 default:
1277 return (ssl3_ctx_ctrl(ctx, cmd, larg, parg));
1278 }
1279 }
1280
1281 long
SSL_CTX_callback_ctrl(SSL_CTX * ctx,int cmd,void (* fp)(void))1282 SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
1283 {
1284 switch (cmd) {
1285 case SSL_CTRL_SET_MSG_CALLBACK:
1286 ctx->internal->msg_callback = (void (*)(int write_p, int version,
1287 int content_type, const void *buf, size_t len, SSL *ssl,
1288 void *arg))(fp);
1289 return (1);
1290
1291 default:
1292 return (ssl3_ctx_callback_ctrl(ctx, cmd, fp));
1293 }
1294 }
1295
1296 int
ssl_cipher_id_cmp(const SSL_CIPHER * a,const SSL_CIPHER * b)1297 ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
1298 {
1299 long l;
1300
1301 l = a->id - b->id;
1302 if (l == 0L)
1303 return (0);
1304 else
1305 return ((l > 0) ? 1:-1);
1306 }
1307
STACK_OF(SSL_CIPHER)1308 STACK_OF(SSL_CIPHER) *
1309 SSL_get_ciphers(const SSL *s)
1310 {
1311 if (s == NULL)
1312 return (NULL);
1313 if (s->cipher_list != NULL)
1314 return (s->cipher_list);
1315
1316 return (s->ctx->cipher_list);
1317 }
1318
STACK_OF(SSL_CIPHER)1319 STACK_OF(SSL_CIPHER) *
1320 SSL_get_client_ciphers(const SSL *s)
1321 {
1322 if (s == NULL || s->session == NULL || !s->server)
1323 return NULL;
1324 return s->session->ciphers;
1325 }
1326
STACK_OF(SSL_CIPHER)1327 STACK_OF(SSL_CIPHER) *
1328 SSL_get1_supported_ciphers(SSL *s)
1329 {
1330 STACK_OF(SSL_CIPHER) *supported_ciphers = NULL, *ciphers;
1331 const SSL_CIPHER *cipher;
1332 uint16_t min_vers, max_vers;
1333 int i;
1334
1335 if (s == NULL)
1336 return NULL;
1337 if (!ssl_supported_tls_version_range(s, &min_vers, &max_vers))
1338 return NULL;
1339 if ((ciphers = SSL_get_ciphers(s)) == NULL)
1340 return NULL;
1341 if ((supported_ciphers = sk_SSL_CIPHER_new_null()) == NULL)
1342 return NULL;
1343
1344 for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1345 if ((cipher = sk_SSL_CIPHER_value(ciphers, i)) == NULL)
1346 goto err;
1347 if (!ssl_cipher_allowed_in_tls_version_range(cipher, min_vers,
1348 max_vers))
1349 continue;
1350 if (!sk_SSL_CIPHER_push(supported_ciphers, cipher))
1351 goto err;
1352 }
1353
1354 if (sk_SSL_CIPHER_num(supported_ciphers) > 0)
1355 return supported_ciphers;
1356
1357 err:
1358 sk_SSL_CIPHER_free(supported_ciphers);
1359 return NULL;
1360 }
1361
1362 /* See if we have any ECC cipher suites. */
1363 int
ssl_has_ecc_ciphers(SSL * s)1364 ssl_has_ecc_ciphers(SSL *s)
1365 {
1366 STACK_OF(SSL_CIPHER) *ciphers;
1367 unsigned long alg_k, alg_a;
1368 SSL_CIPHER *cipher;
1369 int i;
1370
1371 if ((ciphers = SSL_get_ciphers(s)) == NULL)
1372 return 0;
1373
1374 for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1375 cipher = sk_SSL_CIPHER_value(ciphers, i);
1376
1377 alg_k = cipher->algorithm_mkey;
1378 alg_a = cipher->algorithm_auth;
1379
1380 if ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))
1381 return 1;
1382 }
1383
1384 return 0;
1385 }
1386
1387 /* The old interface to get the same thing as SSL_get_ciphers(). */
1388 const char *
SSL_get_cipher_list(const SSL * s,int n)1389 SSL_get_cipher_list(const SSL *s, int n)
1390 {
1391 STACK_OF(SSL_CIPHER) *ciphers;
1392 const SSL_CIPHER *cipher;
1393
1394 if ((ciphers = SSL_get_ciphers(s)) == NULL)
1395 return (NULL);
1396 if ((cipher = sk_SSL_CIPHER_value(ciphers, n)) == NULL)
1397 return (NULL);
1398
1399 return (cipher->name);
1400 }
1401
STACK_OF(SSL_CIPHER)1402 STACK_OF(SSL_CIPHER) *
1403 SSL_CTX_get_ciphers(const SSL_CTX *ctx)
1404 {
1405 if (ctx == NULL)
1406 return NULL;
1407 return ctx->cipher_list;
1408 }
1409
1410 /* Specify the ciphers to be used by default by the SSL_CTX. */
1411 int
SSL_CTX_set_cipher_list(SSL_CTX * ctx,const char * str)1412 SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
1413 {
1414 STACK_OF(SSL_CIPHER) *ciphers;
1415
1416 /*
1417 * ssl_create_cipher_list may return an empty stack if it was unable to
1418 * find a cipher matching the given rule string (for example if the
1419 * rule string specifies a cipher which has been disabled). This is not
1420 * an error as far as ssl_create_cipher_list is concerned, and hence
1421 * ctx->cipher_list has been updated.
1422 */
1423 ciphers = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
1424 ctx->internal->cipher_list_tls13, str);
1425 if (ciphers == NULL) {
1426 return (0);
1427 } else if (sk_SSL_CIPHER_num(ciphers) == 0) {
1428 SSLerrorx(SSL_R_NO_CIPHER_MATCH);
1429 return (0);
1430 }
1431 return (1);
1432 }
1433
1434 int
SSL_CTX_set_ciphersuites(SSL_CTX * ctx,const char * str)1435 SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str)
1436 {
1437 if (!ssl_parse_ciphersuites(&ctx->internal->cipher_list_tls13, str)) {
1438 SSLerrorx(SSL_R_NO_CIPHER_MATCH);
1439 return 0;
1440 }
1441 if (!ssl_merge_cipherlists(ctx->cipher_list,
1442 ctx->internal->cipher_list_tls13, &ctx->cipher_list))
1443 return 0;
1444
1445 return 1;
1446 }
1447
1448 /* Specify the ciphers to be used by the SSL. */
1449 int
SSL_set_cipher_list(SSL * s,const char * str)1450 SSL_set_cipher_list(SSL *s, const char *str)
1451 {
1452 STACK_OF(SSL_CIPHER) *ciphers, *ciphers_tls13;
1453
1454 if ((ciphers_tls13 = s->internal->cipher_list_tls13) == NULL)
1455 ciphers_tls13 = s->ctx->internal->cipher_list_tls13;
1456
1457 /* See comment in SSL_CTX_set_cipher_list. */
1458 ciphers = ssl_create_cipher_list(s->ctx->method, &s->cipher_list,
1459 ciphers_tls13, str);
1460 if (ciphers == NULL) {
1461 return (0);
1462 } else if (sk_SSL_CIPHER_num(ciphers) == 0) {
1463 SSLerror(s, SSL_R_NO_CIPHER_MATCH);
1464 return (0);
1465 }
1466 return (1);
1467 }
1468
1469 int
SSL_set_ciphersuites(SSL * s,const char * str)1470 SSL_set_ciphersuites(SSL *s, const char *str)
1471 {
1472 STACK_OF(SSL_CIPHER) *ciphers;
1473
1474 if ((ciphers = s->cipher_list) == NULL)
1475 ciphers = s->ctx->cipher_list;
1476
1477 if (!ssl_parse_ciphersuites(&s->internal->cipher_list_tls13, str)) {
1478 SSLerrorx(SSL_R_NO_CIPHER_MATCH);
1479 return (0);
1480 }
1481 if (!ssl_merge_cipherlists(ciphers, s->internal->cipher_list_tls13,
1482 &s->cipher_list))
1483 return 0;
1484
1485 return 1;
1486 }
1487
1488 char *
SSL_get_shared_ciphers(const SSL * s,char * buf,int len)1489 SSL_get_shared_ciphers(const SSL *s, char *buf, int len)
1490 {
1491 STACK_OF(SSL_CIPHER) *client_ciphers, *server_ciphers;
1492 const SSL_CIPHER *cipher;
1493 size_t curlen = 0;
1494 char *end;
1495 int i;
1496
1497 if (!s->server || s->session == NULL || len < 2)
1498 return NULL;
1499
1500 if ((client_ciphers = s->session->ciphers) == NULL)
1501 return NULL;
1502 if ((server_ciphers = SSL_get_ciphers(s)) == NULL)
1503 return NULL;
1504 if (sk_SSL_CIPHER_num(client_ciphers) == 0 ||
1505 sk_SSL_CIPHER_num(server_ciphers) == 0)
1506 return NULL;
1507
1508 buf[0] = '\0';
1509 for (i = 0; i < sk_SSL_CIPHER_num(client_ciphers); i++) {
1510 cipher = sk_SSL_CIPHER_value(client_ciphers, i);
1511
1512 if (sk_SSL_CIPHER_find(server_ciphers, cipher) < 0)
1513 continue;
1514
1515 end = buf + curlen;
1516 if (strlcat(buf, cipher->name, len) >= len ||
1517 (curlen = strlcat(buf, ":", len)) >= len) {
1518 /* remove truncated cipher from list */
1519 *end = '\0';
1520 break;
1521 }
1522 }
1523 /* remove trailing colon */
1524 if ((end = strrchr(buf, ':')) != NULL)
1525 *end = '\0';
1526 return buf;
1527 }
1528
1529 /*
1530 * Return a servername extension value if provided in Client Hello, or NULL.
1531 * So far, only host_name types are defined (RFC 3546).
1532 */
1533 const char *
SSL_get_servername(const SSL * s,const int type)1534 SSL_get_servername(const SSL *s, const int type)
1535 {
1536 if (type != TLSEXT_NAMETYPE_host_name)
1537 return (NULL);
1538
1539 return (s->session && !s->tlsext_hostname ?
1540 s->session->tlsext_hostname :
1541 s->tlsext_hostname);
1542 }
1543
1544 int
SSL_get_servername_type(const SSL * s)1545 SSL_get_servername_type(const SSL *s)
1546 {
1547 if (s->session &&
1548 (!s->tlsext_hostname ?
1549 s->session->tlsext_hostname : s->tlsext_hostname))
1550 return (TLSEXT_NAMETYPE_host_name);
1551 return (-1);
1552 }
1553
1554 /*
1555 * SSL_select_next_proto implements standard protocol selection. It is
1556 * expected that this function is called from the callback set by
1557 * SSL_CTX_set_alpn_select_cb.
1558 *
1559 * The protocol data is assumed to be a vector of 8-bit, length prefixed byte
1560 * strings. The length byte itself is not included in the length. A byte
1561 * string of length 0 is invalid. No byte string may be truncated.
1562 *
1563 * It returns either:
1564 * OPENSSL_NPN_NEGOTIATED if a common protocol was found, or
1565 * OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
1566 */
1567 int
SSL_select_next_proto(unsigned char ** out,unsigned char * outlen,const unsigned char * server,unsigned int server_len,const unsigned char * client,unsigned int client_len)1568 SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
1569 const unsigned char *server, unsigned int server_len,
1570 const unsigned char *client, unsigned int client_len)
1571 {
1572 unsigned int i, j;
1573 const unsigned char *result;
1574 int status = OPENSSL_NPN_UNSUPPORTED;
1575
1576 /*
1577 * For each protocol in server preference order,
1578 * see if we support it.
1579 */
1580 for (i = 0; i < server_len; ) {
1581 for (j = 0; j < client_len; ) {
1582 if (server[i] == client[j] &&
1583 memcmp(&server[i + 1],
1584 &client[j + 1], server[i]) == 0) {
1585 /* We found a match */
1586 result = &server[i];
1587 status = OPENSSL_NPN_NEGOTIATED;
1588 goto found;
1589 }
1590 j += client[j];
1591 j++;
1592 }
1593 i += server[i];
1594 i++;
1595 }
1596
1597 /* There's no overlap between our protocols and the server's list. */
1598 result = client;
1599 status = OPENSSL_NPN_NO_OVERLAP;
1600
1601 found:
1602 *out = (unsigned char *) result + 1;
1603 *outlen = result[0];
1604 return (status);
1605 }
1606
1607 /* SSL_get0_next_proto_negotiated is deprecated. */
1608 void
SSL_get0_next_proto_negotiated(const SSL * s,const unsigned char ** data,unsigned int * len)1609 SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
1610 unsigned int *len)
1611 {
1612 *data = NULL;
1613 *len = 0;
1614 }
1615
1616 /* SSL_CTX_set_next_protos_advertised_cb is deprecated. */
1617 void
SSL_CTX_set_next_protos_advertised_cb(SSL_CTX * ctx,int (* cb)(SSL * ssl,const unsigned char ** out,unsigned int * outlen,void * arg),void * arg)1618 SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *ctx, int (*cb) (SSL *ssl,
1619 const unsigned char **out, unsigned int *outlen, void *arg), void *arg)
1620 {
1621 }
1622
1623 /* SSL_CTX_set_next_proto_select_cb is deprecated. */
1624 void
SSL_CTX_set_next_proto_select_cb(SSL_CTX * ctx,int (* cb)(SSL * s,unsigned char ** out,unsigned char * outlen,const unsigned char * in,unsigned int inlen,void * arg),void * arg)1625 SSL_CTX_set_next_proto_select_cb(SSL_CTX *ctx, int (*cb) (SSL *s,
1626 unsigned char **out, unsigned char *outlen, const unsigned char *in,
1627 unsigned int inlen, void *arg), void *arg)
1628 {
1629 }
1630
1631 /*
1632 * SSL_CTX_set_alpn_protos sets the ALPN protocol list to the specified
1633 * protocols, which must be in wire-format (i.e. a series of non-empty,
1634 * 8-bit length-prefixed strings). Returns 0 on success.
1635 */
1636 int
SSL_CTX_set_alpn_protos(SSL_CTX * ctx,const unsigned char * protos,unsigned int protos_len)1637 SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
1638 unsigned int protos_len)
1639 {
1640 int failed = 1;
1641
1642 if (protos == NULL || protos_len == 0)
1643 goto err;
1644
1645 free(ctx->internal->alpn_client_proto_list);
1646 ctx->internal->alpn_client_proto_list = NULL;
1647 ctx->internal->alpn_client_proto_list_len = 0;
1648
1649 if ((ctx->internal->alpn_client_proto_list = malloc(protos_len))
1650 == NULL)
1651 goto err;
1652 ctx->internal->alpn_client_proto_list_len = protos_len;
1653
1654 memcpy(ctx->internal->alpn_client_proto_list, protos, protos_len);
1655
1656 failed = 0;
1657
1658 err:
1659 /* NOTE: Return values are the reverse of what you expect. */
1660 return (failed);
1661 }
1662
1663 /*
1664 * SSL_set_alpn_protos sets the ALPN protocol list to the specified
1665 * protocols, which must be in wire-format (i.e. a series of non-empty,
1666 * 8-bit length-prefixed strings). Returns 0 on success.
1667 */
1668 int
SSL_set_alpn_protos(SSL * ssl,const unsigned char * protos,unsigned int protos_len)1669 SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
1670 unsigned int protos_len)
1671 {
1672 int failed = 1;
1673
1674 if (protos == NULL || protos_len == 0)
1675 goto err;
1676
1677 free(ssl->internal->alpn_client_proto_list);
1678 ssl->internal->alpn_client_proto_list = NULL;
1679 ssl->internal->alpn_client_proto_list_len = 0;
1680
1681 if ((ssl->internal->alpn_client_proto_list = malloc(protos_len))
1682 == NULL)
1683 goto err;
1684 ssl->internal->alpn_client_proto_list_len = protos_len;
1685
1686 memcpy(ssl->internal->alpn_client_proto_list, protos, protos_len);
1687
1688 failed = 0;
1689
1690 err:
1691 /* NOTE: Return values are the reverse of what you expect. */
1692 return (failed);
1693 }
1694
1695 /*
1696 * SSL_CTX_set_alpn_select_cb sets a callback function that is called during
1697 * ClientHello processing in order to select an ALPN protocol from the
1698 * client's list of offered protocols.
1699 */
1700 void
SSL_CTX_set_alpn_select_cb(SSL_CTX * ctx,int (* cb)(SSL * ssl,const unsigned char ** out,unsigned char * outlen,const unsigned char * in,unsigned int inlen,void * arg),void * arg)1701 SSL_CTX_set_alpn_select_cb(SSL_CTX* ctx,
1702 int (*cb) (SSL *ssl, const unsigned char **out, unsigned char *outlen,
1703 const unsigned char *in, unsigned int inlen, void *arg), void *arg)
1704 {
1705 ctx->internal->alpn_select_cb = cb;
1706 ctx->internal->alpn_select_cb_arg = arg;
1707 }
1708
1709 /*
1710 * SSL_get0_alpn_selected gets the selected ALPN protocol (if any). On return
1711 * it sets data to point to len bytes of protocol name (not including the
1712 * leading length-prefix byte). If the server didn't respond with* a negotiated
1713 * protocol then len will be zero.
1714 */
1715 void
SSL_get0_alpn_selected(const SSL * ssl,const unsigned char ** data,unsigned int * len)1716 SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
1717 unsigned int *len)
1718 {
1719 *data = ssl->s3->internal->alpn_selected;
1720 *len = ssl->s3->internal->alpn_selected_len;
1721 }
1722
1723 int
SSL_export_keying_material(SSL * s,unsigned char * out,size_t olen,const char * label,size_t llen,const unsigned char * p,size_t plen,int use_context)1724 SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
1725 const char *label, size_t llen, const unsigned char *p, size_t plen,
1726 int use_context)
1727 {
1728 if (s->internal->tls13 != NULL && s->version == TLS1_3_VERSION) {
1729 if (!use_context) {
1730 p = NULL;
1731 plen = 0;
1732 }
1733 return tls13_exporter(s->internal->tls13, label, llen, p, plen,
1734 out, olen);
1735 }
1736
1737 return (tls1_export_keying_material(s, out, olen, label, llen, p, plen,
1738 use_context));
1739 }
1740
1741 static unsigned long
ssl_session_hash(const SSL_SESSION * a)1742 ssl_session_hash(const SSL_SESSION *a)
1743 {
1744 unsigned long l;
1745
1746 l = (unsigned long)
1747 ((unsigned int) a->session_id[0] )|
1748 ((unsigned int) a->session_id[1]<< 8L)|
1749 ((unsigned long)a->session_id[2]<<16L)|
1750 ((unsigned long)a->session_id[3]<<24L);
1751 return (l);
1752 }
1753
1754 /*
1755 * NB: If this function (or indeed the hash function which uses a sort of
1756 * coarser function than this one) is changed, ensure
1757 * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on being
1758 * able to construct an SSL_SESSION that will collide with any existing session
1759 * with a matching session ID.
1760 */
1761 static int
ssl_session_cmp(const SSL_SESSION * a,const SSL_SESSION * b)1762 ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b)
1763 {
1764 if (a->ssl_version != b->ssl_version)
1765 return (1);
1766 if (a->session_id_length != b->session_id_length)
1767 return (1);
1768 if (timingsafe_memcmp(a->session_id, b->session_id, a->session_id_length) != 0)
1769 return (1);
1770 return (0);
1771 }
1772
1773 /*
1774 * These wrapper functions should remain rather than redeclaring
1775 * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
1776 * variable. The reason is that the functions aren't static, they're exposed via
1777 * ssl.h.
1778 */
1779 static unsigned long
ssl_session_LHASH_HASH(const void * arg)1780 ssl_session_LHASH_HASH(const void *arg)
1781 {
1782 const SSL_SESSION *a = arg;
1783
1784 return ssl_session_hash(a);
1785 }
1786
1787 static int
ssl_session_LHASH_COMP(const void * arg1,const void * arg2)1788 ssl_session_LHASH_COMP(const void *arg1, const void *arg2)
1789 {
1790 const SSL_SESSION *a = arg1;
1791 const SSL_SESSION *b = arg2;
1792
1793 return ssl_session_cmp(a, b);
1794 }
1795
1796 SSL_CTX *
SSL_CTX_new(const SSL_METHOD * meth)1797 SSL_CTX_new(const SSL_METHOD *meth)
1798 {
1799 SSL_CTX *ret;
1800
1801 if (!OPENSSL_init_ssl(0, NULL)) {
1802 SSLerrorx(SSL_R_LIBRARY_BUG);
1803 return (NULL);
1804 }
1805
1806 if (meth == NULL) {
1807 SSLerrorx(SSL_R_NULL_SSL_METHOD_PASSED);
1808 return (NULL);
1809 }
1810
1811 if ((ret = calloc(1, sizeof(*ret))) == NULL) {
1812 SSLerrorx(ERR_R_MALLOC_FAILURE);
1813 return (NULL);
1814 }
1815 if ((ret->internal = calloc(1, sizeof(*ret->internal))) == NULL) {
1816 free(ret);
1817 SSLerrorx(ERR_R_MALLOC_FAILURE);
1818 return (NULL);
1819 }
1820
1821 if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
1822 SSLerrorx(SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
1823 goto err;
1824 }
1825
1826 ret->method = meth;
1827 ret->internal->min_tls_version = meth->internal->min_tls_version;
1828 ret->internal->max_tls_version = meth->internal->max_tls_version;
1829 ret->internal->min_proto_version = 0;
1830 ret->internal->max_proto_version = 0;
1831 ret->internal->mode = SSL_MODE_AUTO_RETRY;
1832
1833 ret->cert_store = NULL;
1834 ret->internal->session_cache_mode = SSL_SESS_CACHE_SERVER;
1835 ret->internal->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
1836 ret->internal->session_cache_head = NULL;
1837 ret->internal->session_cache_tail = NULL;
1838
1839 /* We take the system default */
1840 ret->session_timeout = ssl_get_default_timeout();
1841
1842 ret->internal->new_session_cb = 0;
1843 ret->internal->remove_session_cb = 0;
1844 ret->internal->get_session_cb = 0;
1845 ret->internal->generate_session_id = 0;
1846
1847 memset((char *)&ret->internal->stats, 0, sizeof(ret->internal->stats));
1848
1849 ret->references = 1;
1850 ret->internal->quiet_shutdown = 0;
1851
1852 ret->internal->info_callback = NULL;
1853
1854 ret->internal->app_verify_callback = 0;
1855 ret->internal->app_verify_arg = NULL;
1856
1857 ret->internal->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
1858 ret->internal->read_ahead = 0;
1859 ret->internal->msg_callback = 0;
1860 ret->internal->msg_callback_arg = NULL;
1861 ret->verify_mode = SSL_VERIFY_NONE;
1862 ret->sid_ctx_length = 0;
1863 ret->internal->default_verify_callback = NULL;
1864
1865 if ((ret->internal->cert = ssl_cert_new()) == NULL)
1866 goto err;
1867
1868 ret->default_passwd_callback = 0;
1869 ret->default_passwd_callback_userdata = NULL;
1870 ret->internal->client_cert_cb = 0;
1871 ret->internal->app_gen_cookie_cb = 0;
1872 ret->internal->app_verify_cookie_cb = 0;
1873
1874 ret->internal->sessions = lh_SSL_SESSION_new();
1875 if (ret->internal->sessions == NULL)
1876 goto err;
1877 ret->cert_store = X509_STORE_new();
1878 if (ret->cert_store == NULL)
1879 goto err;
1880
1881 ssl_create_cipher_list(ret->method, &ret->cipher_list,
1882 NULL, SSL_DEFAULT_CIPHER_LIST);
1883 if (ret->cipher_list == NULL ||
1884 sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
1885 SSLerrorx(SSL_R_LIBRARY_HAS_NO_CIPHERS);
1886 goto err2;
1887 }
1888
1889 ret->param = X509_VERIFY_PARAM_new();
1890 if (!ret->param)
1891 goto err;
1892
1893 if ((ret->internal->client_CA = sk_X509_NAME_new_null()) == NULL)
1894 goto err;
1895
1896 CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->internal->ex_data);
1897
1898 ret->extra_certs = NULL;
1899
1900 ret->internal->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
1901
1902 ret->internal->tlsext_servername_callback = 0;
1903 ret->internal->tlsext_servername_arg = NULL;
1904
1905 /* Setup RFC4507 ticket keys */
1906 arc4random_buf(ret->internal->tlsext_tick_key_name, 16);
1907 arc4random_buf(ret->internal->tlsext_tick_hmac_key, 16);
1908 arc4random_buf(ret->internal->tlsext_tick_aes_key, 16);
1909
1910 ret->internal->tlsext_status_cb = 0;
1911 ret->internal->tlsext_status_arg = NULL;
1912
1913 #ifndef OPENSSL_NO_ENGINE
1914 ret->internal->client_cert_engine = NULL;
1915 #ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
1916 #define eng_strx(x) #x
1917 #define eng_str(x) eng_strx(x)
1918 /* Use specific client engine automatically... ignore errors */
1919 {
1920 ENGINE *eng;
1921 eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
1922 if (!eng) {
1923 ERR_clear_error();
1924 ENGINE_load_builtin_engines();
1925 eng = ENGINE_by_id(eng_str(
1926 OPENSSL_SSL_CLIENT_ENGINE_AUTO));
1927 }
1928 if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
1929 ERR_clear_error();
1930 }
1931 #endif
1932 #endif
1933 /*
1934 * Default is to connect to non-RI servers. When RI is more widely
1935 * deployed might change this.
1936 */
1937 ret->internal->options |= SSL_OP_LEGACY_SERVER_CONNECT;
1938
1939 return (ret);
1940 err:
1941 SSLerrorx(ERR_R_MALLOC_FAILURE);
1942 err2:
1943 SSL_CTX_free(ret);
1944 return (NULL);
1945 }
1946
1947 void
SSL_CTX_free(SSL_CTX * ctx)1948 SSL_CTX_free(SSL_CTX *ctx)
1949 {
1950 int i;
1951
1952 if (ctx == NULL)
1953 return;
1954
1955 i = CRYPTO_add(&ctx->references, -1, CRYPTO_LOCK_SSL_CTX);
1956 if (i > 0)
1957 return;
1958
1959 X509_VERIFY_PARAM_free(ctx->param);
1960
1961 /*
1962 * Free internal session cache. However: the remove_cb() may reference
1963 * the ex_data of SSL_CTX, thus the ex_data store can only be removed
1964 * after the sessions were flushed.
1965 * As the ex_data handling routines might also touch the session cache,
1966 * the most secure solution seems to be: empty (flush) the cache, then
1967 * free ex_data, then finally free the cache.
1968 * (See ticket [openssl.org #212].)
1969 */
1970 if (ctx->internal->sessions != NULL)
1971 SSL_CTX_flush_sessions(ctx, 0);
1972
1973 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ctx, &ctx->internal->ex_data);
1974
1975 lh_SSL_SESSION_free(ctx->internal->sessions);
1976
1977 X509_STORE_free(ctx->cert_store);
1978 sk_SSL_CIPHER_free(ctx->cipher_list);
1979 sk_SSL_CIPHER_free(ctx->internal->cipher_list_tls13);
1980 ssl_cert_free(ctx->internal->cert);
1981 sk_X509_NAME_pop_free(ctx->internal->client_CA, X509_NAME_free);
1982 sk_X509_pop_free(ctx->extra_certs, X509_free);
1983
1984 #ifndef OPENSSL_NO_SRTP
1985 if (ctx->internal->srtp_profiles)
1986 sk_SRTP_PROTECTION_PROFILE_free(ctx->internal->srtp_profiles);
1987 #endif
1988
1989 #ifndef OPENSSL_NO_ENGINE
1990 ENGINE_finish(ctx->internal->client_cert_engine);
1991 #endif
1992
1993 free(ctx->internal->tlsext_ecpointformatlist);
1994 free(ctx->internal->tlsext_supportedgroups);
1995
1996 free(ctx->internal->alpn_client_proto_list);
1997
1998 free(ctx->internal);
1999 free(ctx);
2000 }
2001
2002 int
SSL_CTX_up_ref(SSL_CTX * ctx)2003 SSL_CTX_up_ref(SSL_CTX *ctx)
2004 {
2005 int refs = CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
2006 return ((refs > 1) ? 1 : 0);
2007 }
2008
2009 pem_password_cb *
SSL_CTX_get_default_passwd_cb(SSL_CTX * ctx)2010 SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)
2011 {
2012 return (ctx->default_passwd_callback);
2013 }
2014
2015 void
SSL_CTX_set_default_passwd_cb(SSL_CTX * ctx,pem_password_cb * cb)2016 SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
2017 {
2018 ctx->default_passwd_callback = cb;
2019 }
2020
2021 void *
SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX * ctx)2022 SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx)
2023 {
2024 return ctx->default_passwd_callback_userdata;
2025 }
2026
2027 void
SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX * ctx,void * u)2028 SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
2029 {
2030 ctx->default_passwd_callback_userdata = u;
2031 }
2032
2033 void
SSL_CTX_set_cert_verify_callback(SSL_CTX * ctx,int (* cb)(X509_STORE_CTX *,void *),void * arg)2034 SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
2035 int (*cb)(X509_STORE_CTX *, void *), void *arg)
2036 {
2037 ctx->internal->app_verify_callback = cb;
2038 ctx->internal->app_verify_arg = arg;
2039 }
2040
2041 void
SSL_CTX_set_verify(SSL_CTX * ctx,int mode,int (* cb)(int,X509_STORE_CTX *))2042 SSL_CTX_set_verify(SSL_CTX *ctx, int mode, int (*cb)(int, X509_STORE_CTX *))
2043 {
2044 ctx->verify_mode = mode;
2045 ctx->internal->default_verify_callback = cb;
2046 }
2047
2048 void
SSL_CTX_set_verify_depth(SSL_CTX * ctx,int depth)2049 SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
2050 {
2051 X509_VERIFY_PARAM_set_depth(ctx->param, depth);
2052 }
2053
2054 static int
ssl_cert_can_sign(X509 * x)2055 ssl_cert_can_sign(X509 *x)
2056 {
2057 /* This call populates extension flags (ex_flags). */
2058 X509_check_purpose(x, -1, 0);
2059
2060 /* Key usage, if present, must allow signing. */
2061 return ((x->ex_flags & EXFLAG_KUSAGE) == 0 ||
2062 (x->ex_kusage & X509v3_KU_DIGITAL_SIGNATURE));
2063 }
2064
2065 void
ssl_set_cert_masks(CERT * c,const SSL_CIPHER * cipher)2066 ssl_set_cert_masks(CERT *c, const SSL_CIPHER *cipher)
2067 {
2068 unsigned long mask_a, mask_k;
2069 CERT_PKEY *cpk;
2070
2071 if (c == NULL)
2072 return;
2073
2074 mask_a = SSL_aNULL | SSL_aTLS1_3;
2075 mask_k = SSL_kECDHE | SSL_kTLS1_3;
2076
2077 if (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto != 0)
2078 mask_k |= SSL_kDHE;
2079
2080 cpk = &(c->pkeys[SSL_PKEY_ECC]);
2081 if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2082 if (ssl_cert_can_sign(cpk->x509))
2083 mask_a |= SSL_aECDSA;
2084 }
2085
2086 cpk = &(c->pkeys[SSL_PKEY_GOST01]);
2087 if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2088 mask_k |= SSL_kGOST;
2089 mask_a |= SSL_aGOST01;
2090 }
2091
2092 cpk = &(c->pkeys[SSL_PKEY_RSA]);
2093 if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2094 mask_a |= SSL_aRSA;
2095 mask_k |= SSL_kRSA;
2096 }
2097
2098 c->mask_k = mask_k;
2099 c->mask_a = mask_a;
2100 c->valid = 1;
2101 }
2102
2103 /* See if this handshake is using an ECC cipher suite. */
2104 int
ssl_using_ecc_cipher(SSL * s)2105 ssl_using_ecc_cipher(SSL *s)
2106 {
2107 unsigned long alg_a, alg_k;
2108
2109 alg_a = S3I(s)->hs.cipher->algorithm_auth;
2110 alg_k = S3I(s)->hs.cipher->algorithm_mkey;
2111
2112 return SSI(s)->tlsext_ecpointformatlist != NULL &&
2113 SSI(s)->tlsext_ecpointformatlist_length > 0 &&
2114 ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA));
2115 }
2116
2117 int
ssl_check_srvr_ecc_cert_and_alg(X509 * x,SSL * s)2118 ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
2119 {
2120 const SSL_CIPHER *cs = S3I(s)->hs.cipher;
2121 unsigned long alg_a;
2122
2123 alg_a = cs->algorithm_auth;
2124
2125 if (alg_a & SSL_aECDSA) {
2126 /* This call populates extension flags (ex_flags). */
2127 X509_check_purpose(x, -1, 0);
2128
2129 /* Key usage, if present, must allow signing. */
2130 if ((x->ex_flags & EXFLAG_KUSAGE) &&
2131 ((x->ex_kusage & X509v3_KU_DIGITAL_SIGNATURE) == 0)) {
2132 SSLerror(s, SSL_R_ECC_CERT_NOT_FOR_SIGNING);
2133 return (0);
2134 }
2135 }
2136
2137 return (1);
2138 }
2139
2140 CERT_PKEY *
ssl_get_server_send_pkey(const SSL * s)2141 ssl_get_server_send_pkey(const SSL *s)
2142 {
2143 unsigned long alg_a;
2144 CERT *c;
2145 int i;
2146
2147 c = s->cert;
2148 ssl_set_cert_masks(c, S3I(s)->hs.cipher);
2149
2150 alg_a = S3I(s)->hs.cipher->algorithm_auth;
2151
2152 if (alg_a & SSL_aECDSA) {
2153 i = SSL_PKEY_ECC;
2154 } else if (alg_a & SSL_aRSA) {
2155 i = SSL_PKEY_RSA;
2156 } else if (alg_a & SSL_aGOST01) {
2157 i = SSL_PKEY_GOST01;
2158 } else { /* if (alg_a & SSL_aNULL) */
2159 SSLerror(s, ERR_R_INTERNAL_ERROR);
2160 return (NULL);
2161 }
2162
2163 return (c->pkeys + i);
2164 }
2165
2166 EVP_PKEY *
ssl_get_sign_pkey(SSL * s,const SSL_CIPHER * cipher,const EVP_MD ** pmd,const struct ssl_sigalg ** sap)2167 ssl_get_sign_pkey(SSL *s, const SSL_CIPHER *cipher, const EVP_MD **pmd,
2168 const struct ssl_sigalg **sap)
2169 {
2170 const struct ssl_sigalg *sigalg = NULL;
2171 EVP_PKEY *pkey = NULL;
2172 unsigned long alg_a;
2173 CERT *c;
2174 int idx = -1;
2175
2176 alg_a = cipher->algorithm_auth;
2177 c = s->cert;
2178
2179 if (alg_a & SSL_aRSA) {
2180 idx = SSL_PKEY_RSA;
2181 } else if ((alg_a & SSL_aECDSA) &&
2182 (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
2183 idx = SSL_PKEY_ECC;
2184 if (idx == -1) {
2185 SSLerror(s, ERR_R_INTERNAL_ERROR);
2186 return (NULL);
2187 }
2188
2189 pkey = c->pkeys[idx].privatekey;
2190 if ((sigalg = ssl_sigalg_select(s, pkey)) == NULL) {
2191 SSLerror(s, SSL_R_SIGNATURE_ALGORITHMS_ERROR);
2192 return (NULL);
2193 }
2194 *pmd = sigalg->md();
2195 *sap = sigalg;
2196
2197 return (pkey);
2198 }
2199
2200 DH *
ssl_get_auto_dh(SSL * s)2201 ssl_get_auto_dh(SSL *s)
2202 {
2203 CERT_PKEY *cpk;
2204 int keylen;
2205 DH *dhp;
2206
2207 if (s->cert->dh_tmp_auto == 2) {
2208 keylen = 1024;
2209 } else if (S3I(s)->hs.cipher->algorithm_auth & SSL_aNULL) {
2210 keylen = 1024;
2211 if (S3I(s)->hs.cipher->strength_bits == 256)
2212 keylen = 3072;
2213 } else {
2214 if ((cpk = ssl_get_server_send_pkey(s)) == NULL)
2215 return (NULL);
2216 if (cpk->privatekey == NULL || cpk->privatekey->pkey.dh == NULL)
2217 return (NULL);
2218 keylen = EVP_PKEY_bits(cpk->privatekey);
2219 }
2220
2221 if ((dhp = DH_new()) == NULL)
2222 return (NULL);
2223
2224 dhp->g = BN_new();
2225 if (dhp->g != NULL)
2226 BN_set_word(dhp->g, 2);
2227
2228 if (keylen >= 8192)
2229 dhp->p = get_rfc3526_prime_8192(NULL);
2230 else if (keylen >= 4096)
2231 dhp->p = get_rfc3526_prime_4096(NULL);
2232 else if (keylen >= 3072)
2233 dhp->p = get_rfc3526_prime_3072(NULL);
2234 else if (keylen >= 2048)
2235 dhp->p = get_rfc3526_prime_2048(NULL);
2236 else if (keylen >= 1536)
2237 dhp->p = get_rfc3526_prime_1536(NULL);
2238 else
2239 dhp->p = get_rfc2409_prime_1024(NULL);
2240
2241 if (dhp->p == NULL || dhp->g == NULL) {
2242 DH_free(dhp);
2243 return (NULL);
2244 }
2245 return (dhp);
2246 }
2247
2248 void
ssl_update_cache(SSL * s,int mode)2249 ssl_update_cache(SSL *s, int mode)
2250 {
2251 int i;
2252
2253 /*
2254 * If the session_id_length is 0, we are not supposed to cache it,
2255 * and it would be rather hard to do anyway :-)
2256 */
2257 if (s->session->session_id_length == 0)
2258 return;
2259
2260 i = s->session_ctx->internal->session_cache_mode;
2261 if ((i & mode) && (!s->internal->hit) && ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
2262 || SSL_CTX_add_session(s->session_ctx, s->session))
2263 && (s->session_ctx->internal->new_session_cb != NULL)) {
2264 CRYPTO_add(&s->session->references, 1, CRYPTO_LOCK_SSL_SESSION);
2265 if (!s->session_ctx->internal->new_session_cb(s, s->session))
2266 SSL_SESSION_free(s->session);
2267 }
2268
2269 /* auto flush every 255 connections */
2270 if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) &&
2271 ((i & mode) == mode)) {
2272 if ((((mode & SSL_SESS_CACHE_CLIENT) ?
2273 s->session_ctx->internal->stats.sess_connect_good :
2274 s->session_ctx->internal->stats.sess_accept_good) & 0xff) == 0xff) {
2275 SSL_CTX_flush_sessions(s->session_ctx, time(NULL));
2276 }
2277 }
2278 }
2279
2280 const SSL_METHOD *
SSL_get_ssl_method(SSL * s)2281 SSL_get_ssl_method(SSL *s)
2282 {
2283 return (s->method);
2284 }
2285
2286 int
SSL_set_ssl_method(SSL * s,const SSL_METHOD * method)2287 SSL_set_ssl_method(SSL *s, const SSL_METHOD *method)
2288 {
2289 int (*handshake_func)(SSL *) = NULL;
2290 int ret = 1;
2291
2292 if (s->method == method)
2293 return (ret);
2294
2295 if (s->internal->handshake_func == s->method->internal->ssl_connect)
2296 handshake_func = method->internal->ssl_connect;
2297 else if (s->internal->handshake_func == s->method->internal->ssl_accept)
2298 handshake_func = method->internal->ssl_accept;
2299
2300 if (s->method->internal->version == method->internal->version) {
2301 s->method = method;
2302 } else {
2303 s->method->internal->ssl_free(s);
2304 s->method = method;
2305 ret = s->method->internal->ssl_new(s);
2306 }
2307 s->internal->handshake_func = handshake_func;
2308
2309 return (ret);
2310 }
2311
2312 int
SSL_get_error(const SSL * s,int i)2313 SSL_get_error(const SSL *s, int i)
2314 {
2315 int reason;
2316 unsigned long l;
2317 BIO *bio;
2318
2319 if (i > 0)
2320 return (SSL_ERROR_NONE);
2321
2322 /* Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake
2323 * etc, where we do encode the error */
2324 if ((l = ERR_peek_error()) != 0) {
2325 if (ERR_GET_LIB(l) == ERR_LIB_SYS)
2326 return (SSL_ERROR_SYSCALL);
2327 else
2328 return (SSL_ERROR_SSL);
2329 }
2330
2331 if ((i < 0) && SSL_want_read(s)) {
2332 bio = SSL_get_rbio(s);
2333 if (BIO_should_read(bio)) {
2334 return (SSL_ERROR_WANT_READ);
2335 } else if (BIO_should_write(bio)) {
2336 /*
2337 * This one doesn't make too much sense... We never
2338 * try to write to the rbio, and an application
2339 * program where rbio and wbio are separate couldn't
2340 * even know what it should wait for. However if we
2341 * ever set s->internal->rwstate incorrectly (so that we have
2342 * SSL_want_read(s) instead of SSL_want_write(s))
2343 * and rbio and wbio *are* the same, this test works
2344 * around that bug; so it might be safer to keep it.
2345 */
2346 return (SSL_ERROR_WANT_WRITE);
2347 } else if (BIO_should_io_special(bio)) {
2348 reason = BIO_get_retry_reason(bio);
2349 if (reason == BIO_RR_CONNECT)
2350 return (SSL_ERROR_WANT_CONNECT);
2351 else if (reason == BIO_RR_ACCEPT)
2352 return (SSL_ERROR_WANT_ACCEPT);
2353 else
2354 return (SSL_ERROR_SYSCALL); /* unknown */
2355 }
2356 }
2357
2358 if ((i < 0) && SSL_want_write(s)) {
2359 bio = SSL_get_wbio(s);
2360 if (BIO_should_write(bio)) {
2361 return (SSL_ERROR_WANT_WRITE);
2362 } else if (BIO_should_read(bio)) {
2363 /*
2364 * See above (SSL_want_read(s) with
2365 * BIO_should_write(bio))
2366 */
2367 return (SSL_ERROR_WANT_READ);
2368 } else if (BIO_should_io_special(bio)) {
2369 reason = BIO_get_retry_reason(bio);
2370 if (reason == BIO_RR_CONNECT)
2371 return (SSL_ERROR_WANT_CONNECT);
2372 else if (reason == BIO_RR_ACCEPT)
2373 return (SSL_ERROR_WANT_ACCEPT);
2374 else
2375 return (SSL_ERROR_SYSCALL);
2376 }
2377 }
2378 if ((i < 0) && SSL_want_x509_lookup(s)) {
2379 return (SSL_ERROR_WANT_X509_LOOKUP);
2380 }
2381
2382 if (i == 0) {
2383 if ((s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2384 (S3I(s)->warn_alert == SSL_AD_CLOSE_NOTIFY))
2385 return (SSL_ERROR_ZERO_RETURN);
2386 }
2387 return (SSL_ERROR_SYSCALL);
2388 }
2389
2390 int
SSL_do_handshake(SSL * s)2391 SSL_do_handshake(SSL *s)
2392 {
2393 int ret = 1;
2394
2395 if (s->internal->handshake_func == NULL) {
2396 SSLerror(s, SSL_R_CONNECTION_TYPE_NOT_SET);
2397 return (-1);
2398 }
2399
2400 s->method->internal->ssl_renegotiate_check(s);
2401
2402 if (SSL_in_init(s) || SSL_in_before(s)) {
2403 ret = s->internal->handshake_func(s);
2404 }
2405 return (ret);
2406 }
2407
2408 /*
2409 * For the next 2 functions, SSL_clear() sets shutdown and so
2410 * one of these calls will reset it
2411 */
2412 void
SSL_set_accept_state(SSL * s)2413 SSL_set_accept_state(SSL *s)
2414 {
2415 s->server = 1;
2416 s->internal->shutdown = 0;
2417 S3I(s)->hs.state = SSL_ST_ACCEPT|SSL_ST_BEFORE;
2418 s->internal->handshake_func = s->method->internal->ssl_accept;
2419 ssl_clear_cipher_state(s);
2420 }
2421
2422 void
SSL_set_connect_state(SSL * s)2423 SSL_set_connect_state(SSL *s)
2424 {
2425 s->server = 0;
2426 s->internal->shutdown = 0;
2427 S3I(s)->hs.state = SSL_ST_CONNECT|SSL_ST_BEFORE;
2428 s->internal->handshake_func = s->method->internal->ssl_connect;
2429 ssl_clear_cipher_state(s);
2430 }
2431
2432 int
ssl_undefined_function(SSL * s)2433 ssl_undefined_function(SSL *s)
2434 {
2435 SSLerror(s, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2436 return (0);
2437 }
2438
2439 int
ssl_undefined_void_function(void)2440 ssl_undefined_void_function(void)
2441 {
2442 SSLerrorx(ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2443 return (0);
2444 }
2445
2446 int
ssl_undefined_const_function(const SSL * s)2447 ssl_undefined_const_function(const SSL *s)
2448 {
2449 SSLerror(s, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2450 return (0);
2451 }
2452
2453 const char *
ssl_version_string(int ver)2454 ssl_version_string(int ver)
2455 {
2456 switch (ver) {
2457 case TLS1_VERSION:
2458 return (SSL_TXT_TLSV1);
2459 case TLS1_1_VERSION:
2460 return (SSL_TXT_TLSV1_1);
2461 case TLS1_2_VERSION:
2462 return (SSL_TXT_TLSV1_2);
2463 case TLS1_3_VERSION:
2464 return (SSL_TXT_TLSV1_3);
2465 case DTLS1_VERSION:
2466 return (SSL_TXT_DTLS1);
2467 case DTLS1_2_VERSION:
2468 return (SSL_TXT_DTLS1_2);
2469 default:
2470 return ("unknown");
2471 }
2472 }
2473
2474 const char *
SSL_get_version(const SSL * s)2475 SSL_get_version(const SSL *s)
2476 {
2477 return ssl_version_string(s->version);
2478 }
2479
2480 SSL *
SSL_dup(SSL * s)2481 SSL_dup(SSL *s)
2482 {
2483 STACK_OF(X509_NAME) *sk;
2484 X509_NAME *xn;
2485 SSL *ret;
2486 int i;
2487
2488 if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
2489 goto err;
2490
2491 ret->version = s->version;
2492 ret->method = s->method;
2493
2494 if (s->session != NULL) {
2495 if (!SSL_copy_session_id(ret, s))
2496 goto err;
2497 } else {
2498 /*
2499 * No session has been established yet, so we have to expect
2500 * that s->cert or ret->cert will be changed later --
2501 * they should not both point to the same object,
2502 * and thus we can't use SSL_copy_session_id.
2503 */
2504
2505 ret->method->internal->ssl_free(ret);
2506 ret->method = s->method;
2507 ret->method->internal->ssl_new(ret);
2508
2509 ssl_cert_free(ret->cert);
2510 if ((ret->cert = ssl_cert_dup(s->cert)) == NULL)
2511 goto err;
2512
2513 if (!SSL_set_session_id_context(ret, s->sid_ctx,
2514 s->sid_ctx_length))
2515 goto err;
2516 }
2517
2518 ret->internal->options = s->internal->options;
2519 ret->internal->mode = s->internal->mode;
2520 SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
2521 SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
2522 ret->internal->msg_callback = s->internal->msg_callback;
2523 ret->internal->msg_callback_arg = s->internal->msg_callback_arg;
2524 SSL_set_verify(ret, SSL_get_verify_mode(s),
2525 SSL_get_verify_callback(s));
2526 SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
2527 ret->internal->generate_session_id = s->internal->generate_session_id;
2528
2529 SSL_set_info_callback(ret, SSL_get_info_callback(s));
2530
2531 ret->internal->debug = s->internal->debug;
2532
2533 /* copy app data, a little dangerous perhaps */
2534 if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL,
2535 &ret->internal->ex_data, &s->internal->ex_data))
2536 goto err;
2537
2538 /* setup rbio, and wbio */
2539 if (s->rbio != NULL) {
2540 if (!BIO_dup_state(s->rbio,(char *)&ret->rbio))
2541 goto err;
2542 }
2543 if (s->wbio != NULL) {
2544 if (s->wbio != s->rbio) {
2545 if (!BIO_dup_state(s->wbio,(char *)&ret->wbio))
2546 goto err;
2547 } else
2548 ret->wbio = ret->rbio;
2549 }
2550 ret->internal->rwstate = s->internal->rwstate;
2551 ret->internal->in_handshake = s->internal->in_handshake;
2552 ret->internal->handshake_func = s->internal->handshake_func;
2553 ret->server = s->server;
2554 ret->internal->renegotiate = s->internal->renegotiate;
2555 ret->internal->new_session = s->internal->new_session;
2556 ret->internal->quiet_shutdown = s->internal->quiet_shutdown;
2557 ret->internal->shutdown = s->internal->shutdown;
2558 /* SSL_dup does not really work at any state, though */
2559 S3I(ret)->hs.state = S3I(s)->hs.state;
2560 ret->internal->rstate = s->internal->rstate;
2561
2562 /*
2563 * Would have to copy ret->init_buf, ret->init_msg, ret->init_num,
2564 * ret->init_off
2565 */
2566 ret->internal->init_num = 0;
2567
2568 ret->internal->hit = s->internal->hit;
2569
2570 X509_VERIFY_PARAM_inherit(ret->param, s->param);
2571
2572 if (s->cipher_list != NULL) {
2573 if ((ret->cipher_list =
2574 sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
2575 goto err;
2576 }
2577 if (s->internal->cipher_list_tls13 != NULL) {
2578 if ((ret->internal->cipher_list_tls13 =
2579 sk_SSL_CIPHER_dup(s->internal->cipher_list_tls13)) == NULL)
2580 goto err;
2581 }
2582
2583 /* Dup the client_CA list */
2584 if (s->internal->client_CA != NULL) {
2585 if ((sk = sk_X509_NAME_dup(s->internal->client_CA)) == NULL) goto err;
2586 ret->internal->client_CA = sk;
2587 for (i = 0; i < sk_X509_NAME_num(sk); i++) {
2588 xn = sk_X509_NAME_value(sk, i);
2589 if (sk_X509_NAME_set(sk, i,
2590 X509_NAME_dup(xn)) == NULL) {
2591 X509_NAME_free(xn);
2592 goto err;
2593 }
2594 }
2595 }
2596
2597 return ret;
2598 err:
2599 SSL_free(ret);
2600 return NULL;
2601 }
2602
2603 void
ssl_clear_cipher_state(SSL * s)2604 ssl_clear_cipher_state(SSL *s)
2605 {
2606 ssl_clear_cipher_read_state(s);
2607 ssl_clear_cipher_write_state(s);
2608 }
2609
2610 void
ssl_clear_cipher_read_state(SSL * s)2611 ssl_clear_cipher_read_state(SSL *s)
2612 {
2613 tls12_record_layer_clear_read_state(s->internal->rl);
2614 tls12_record_layer_read_cipher_hash(s->internal->rl,
2615 &s->enc_read_ctx, &s->read_hash);
2616 }
2617
2618 void
ssl_clear_cipher_write_state(SSL * s)2619 ssl_clear_cipher_write_state(SSL *s)
2620 {
2621 tls12_record_layer_clear_write_state(s->internal->rl);
2622 }
2623
2624 /* Fix this function so that it takes an optional type parameter */
2625 X509 *
SSL_get_certificate(const SSL * s)2626 SSL_get_certificate(const SSL *s)
2627 {
2628 return (s->cert->key->x509);
2629 }
2630
2631 /* Fix this function so that it takes an optional type parameter */
2632 EVP_PKEY *
SSL_get_privatekey(const SSL * s)2633 SSL_get_privatekey(const SSL *s)
2634 {
2635 return (s->cert->key->privatekey);
2636 }
2637
2638 const SSL_CIPHER *
SSL_get_current_cipher(const SSL * s)2639 SSL_get_current_cipher(const SSL *s)
2640 {
2641 if ((s->session != NULL) && (s->session->cipher != NULL))
2642 return (s->session->cipher);
2643 return (NULL);
2644 }
2645 const void *
SSL_get_current_compression(SSL * s)2646 SSL_get_current_compression(SSL *s)
2647 {
2648 return (NULL);
2649 }
2650
2651 const void *
SSL_get_current_expansion(SSL * s)2652 SSL_get_current_expansion(SSL *s)
2653 {
2654 return (NULL);
2655 }
2656
2657 size_t
SSL_get_client_random(const SSL * s,unsigned char * out,size_t max_out)2658 SSL_get_client_random(const SSL *s, unsigned char *out, size_t max_out)
2659 {
2660 size_t len = sizeof(s->s3->client_random);
2661
2662 if (out == NULL)
2663 return len;
2664
2665 if (len > max_out)
2666 len = max_out;
2667
2668 memcpy(out, s->s3->client_random, len);
2669
2670 return len;
2671 }
2672
2673 size_t
SSL_get_server_random(const SSL * s,unsigned char * out,size_t max_out)2674 SSL_get_server_random(const SSL *s, unsigned char *out, size_t max_out)
2675 {
2676 size_t len = sizeof(s->s3->server_random);
2677
2678 if (out == NULL)
2679 return len;
2680
2681 if (len > max_out)
2682 len = max_out;
2683
2684 memcpy(out, s->s3->server_random, len);
2685
2686 return len;
2687 }
2688
2689 int
ssl_init_wbio_buffer(SSL * s,int push)2690 ssl_init_wbio_buffer(SSL *s, int push)
2691 {
2692 BIO *bbio;
2693
2694 if (s->bbio == NULL) {
2695 bbio = BIO_new(BIO_f_buffer());
2696 if (bbio == NULL)
2697 return (0);
2698 s->bbio = bbio;
2699 } else {
2700 bbio = s->bbio;
2701 if (s->bbio == s->wbio)
2702 s->wbio = BIO_pop(s->wbio);
2703 }
2704 (void)BIO_reset(bbio);
2705 /* if (!BIO_set_write_buffer_size(bbio,16*1024)) */
2706 if (!BIO_set_read_buffer_size(bbio, 1)) {
2707 SSLerror(s, ERR_R_BUF_LIB);
2708 return (0);
2709 }
2710 if (push) {
2711 if (s->wbio != bbio)
2712 s->wbio = BIO_push(bbio, s->wbio);
2713 } else {
2714 if (s->wbio == bbio)
2715 s->wbio = BIO_pop(bbio);
2716 }
2717 return (1);
2718 }
2719
2720 void
ssl_free_wbio_buffer(SSL * s)2721 ssl_free_wbio_buffer(SSL *s)
2722 {
2723 if (s == NULL)
2724 return;
2725
2726 if (s->bbio == NULL)
2727 return;
2728
2729 if (s->bbio == s->wbio) {
2730 /* remove buffering */
2731 s->wbio = BIO_pop(s->wbio);
2732 }
2733 BIO_free(s->bbio);
2734 s->bbio = NULL;
2735 }
2736
2737 void
SSL_CTX_set_quiet_shutdown(SSL_CTX * ctx,int mode)2738 SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
2739 {
2740 ctx->internal->quiet_shutdown = mode;
2741 }
2742
2743 int
SSL_CTX_get_quiet_shutdown(const SSL_CTX * ctx)2744 SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
2745 {
2746 return (ctx->internal->quiet_shutdown);
2747 }
2748
2749 void
SSL_set_quiet_shutdown(SSL * s,int mode)2750 SSL_set_quiet_shutdown(SSL *s, int mode)
2751 {
2752 s->internal->quiet_shutdown = mode;
2753 }
2754
2755 int
SSL_get_quiet_shutdown(const SSL * s)2756 SSL_get_quiet_shutdown(const SSL *s)
2757 {
2758 return (s->internal->quiet_shutdown);
2759 }
2760
2761 void
SSL_set_shutdown(SSL * s,int mode)2762 SSL_set_shutdown(SSL *s, int mode)
2763 {
2764 s->internal->shutdown = mode;
2765 }
2766
2767 int
SSL_get_shutdown(const SSL * s)2768 SSL_get_shutdown(const SSL *s)
2769 {
2770 return (s->internal->shutdown);
2771 }
2772
2773 int
SSL_version(const SSL * s)2774 SSL_version(const SSL *s)
2775 {
2776 return (s->version);
2777 }
2778
2779 SSL_CTX *
SSL_get_SSL_CTX(const SSL * ssl)2780 SSL_get_SSL_CTX(const SSL *ssl)
2781 {
2782 return (ssl->ctx);
2783 }
2784
2785 SSL_CTX *
SSL_set_SSL_CTX(SSL * ssl,SSL_CTX * ctx)2786 SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx)
2787 {
2788 CERT *new_cert;
2789
2790 if (ctx == NULL)
2791 ctx = ssl->initial_ctx;
2792 if (ssl->ctx == ctx)
2793 return (ssl->ctx);
2794
2795 if ((new_cert = ssl_cert_dup(ctx->internal->cert)) == NULL)
2796 return NULL;
2797 ssl_cert_free(ssl->cert);
2798 ssl->cert = new_cert;
2799
2800 SSL_CTX_up_ref(ctx);
2801 SSL_CTX_free(ssl->ctx); /* decrement reference count */
2802 ssl->ctx = ctx;
2803
2804 return (ssl->ctx);
2805 }
2806
2807 int
SSL_CTX_set_default_verify_paths(SSL_CTX * ctx)2808 SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
2809 {
2810 return (X509_STORE_set_default_paths(ctx->cert_store));
2811 }
2812
2813 int
SSL_CTX_load_verify_locations(SSL_CTX * ctx,const char * CAfile,const char * CApath)2814 SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
2815 const char *CApath)
2816 {
2817 return (X509_STORE_load_locations(ctx->cert_store, CAfile, CApath));
2818 }
2819
2820 int
SSL_CTX_load_verify_mem(SSL_CTX * ctx,void * buf,int len)2821 SSL_CTX_load_verify_mem(SSL_CTX *ctx, void *buf, int len)
2822 {
2823 return (X509_STORE_load_mem(ctx->cert_store, buf, len));
2824 }
2825
2826 void
SSL_set_info_callback(SSL * ssl,void (* cb)(const SSL * ssl,int type,int val))2827 SSL_set_info_callback(SSL *ssl, void (*cb)(const SSL *ssl, int type, int val))
2828 {
2829 ssl->internal->info_callback = cb;
2830 }
2831
SSL_get_info_callback(const SSL * ssl)2832 void (*SSL_get_info_callback(const SSL *ssl))(const SSL *ssl, int type, int val)
2833 {
2834 return (ssl->internal->info_callback);
2835 }
2836
2837 int
SSL_state(const SSL * ssl)2838 SSL_state(const SSL *ssl)
2839 {
2840 return (S3I(ssl)->hs.state);
2841 }
2842
2843 void
SSL_set_state(SSL * ssl,int state)2844 SSL_set_state(SSL *ssl, int state)
2845 {
2846 S3I(ssl)->hs.state = state;
2847 }
2848
2849 void
SSL_set_verify_result(SSL * ssl,long arg)2850 SSL_set_verify_result(SSL *ssl, long arg)
2851 {
2852 ssl->verify_result = arg;
2853 }
2854
2855 long
SSL_get_verify_result(const SSL * ssl)2856 SSL_get_verify_result(const SSL *ssl)
2857 {
2858 return (ssl->verify_result);
2859 }
2860
2861 int
SSL_get_ex_new_index(long argl,void * argp,CRYPTO_EX_new * new_func,CRYPTO_EX_dup * dup_func,CRYPTO_EX_free * free_func)2862 SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
2863 CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
2864 {
2865 return (CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp,
2866 new_func, dup_func, free_func));
2867 }
2868
2869 int
SSL_set_ex_data(SSL * s,int idx,void * arg)2870 SSL_set_ex_data(SSL *s, int idx, void *arg)
2871 {
2872 return (CRYPTO_set_ex_data(&s->internal->ex_data, idx, arg));
2873 }
2874
2875 void *
SSL_get_ex_data(const SSL * s,int idx)2876 SSL_get_ex_data(const SSL *s, int idx)
2877 {
2878 return (CRYPTO_get_ex_data(&s->internal->ex_data, idx));
2879 }
2880
2881 int
SSL_CTX_get_ex_new_index(long argl,void * argp,CRYPTO_EX_new * new_func,CRYPTO_EX_dup * dup_func,CRYPTO_EX_free * free_func)2882 SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
2883 CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
2884 {
2885 return (CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp,
2886 new_func, dup_func, free_func));
2887 }
2888
2889 int
SSL_CTX_set_ex_data(SSL_CTX * s,int idx,void * arg)2890 SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
2891 {
2892 return (CRYPTO_set_ex_data(&s->internal->ex_data, idx, arg));
2893 }
2894
2895 void *
SSL_CTX_get_ex_data(const SSL_CTX * s,int idx)2896 SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
2897 {
2898 return (CRYPTO_get_ex_data(&s->internal->ex_data, idx));
2899 }
2900
2901 int
ssl_ok(SSL * s)2902 ssl_ok(SSL *s)
2903 {
2904 return (1);
2905 }
2906
2907 X509_STORE *
SSL_CTX_get_cert_store(const SSL_CTX * ctx)2908 SSL_CTX_get_cert_store(const SSL_CTX *ctx)
2909 {
2910 return (ctx->cert_store);
2911 }
2912
2913 void
SSL_CTX_set_cert_store(SSL_CTX * ctx,X509_STORE * store)2914 SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
2915 {
2916 X509_STORE_free(ctx->cert_store);
2917 ctx->cert_store = store;
2918 }
2919
2920 X509 *
SSL_CTX_get0_certificate(const SSL_CTX * ctx)2921 SSL_CTX_get0_certificate(const SSL_CTX *ctx)
2922 {
2923 if (ctx->internal->cert == NULL)
2924 return NULL;
2925
2926 return ctx->internal->cert->key->x509;
2927 }
2928
2929 int
SSL_want(const SSL * s)2930 SSL_want(const SSL *s)
2931 {
2932 return (s->internal->rwstate);
2933 }
2934
2935 void
SSL_CTX_set_tmp_rsa_callback(SSL_CTX * ctx,RSA * (* cb)(SSL * ssl,int is_export,int keylength))2936 SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, RSA *(*cb)(SSL *ssl, int is_export,
2937 int keylength))
2938 {
2939 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
2940 }
2941
2942 void
SSL_set_tmp_rsa_callback(SSL * ssl,RSA * (* cb)(SSL * ssl,int is_export,int keylength))2943 SSL_set_tmp_rsa_callback(SSL *ssl, RSA *(*cb)(SSL *ssl, int is_export,
2944 int keylength))
2945 {
2946 SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
2947 }
2948
2949 void
SSL_CTX_set_tmp_dh_callback(SSL_CTX * ctx,DH * (* dh)(SSL * ssl,int is_export,int keylength))2950 SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx, DH *(*dh)(SSL *ssl, int is_export,
2951 int keylength))
2952 {
2953 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
2954 }
2955
2956 void
SSL_set_tmp_dh_callback(SSL * ssl,DH * (* dh)(SSL * ssl,int is_export,int keylength))2957 SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh)(SSL *ssl, int is_export,
2958 int keylength))
2959 {
2960 SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
2961 }
2962
2963 void
SSL_CTX_set_tmp_ecdh_callback(SSL_CTX * ctx,EC_KEY * (* ecdh)(SSL * ssl,int is_export,int keylength))2964 SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx, EC_KEY *(*ecdh)(SSL *ssl,
2965 int is_export, int keylength))
2966 {
2967 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_ECDH_CB,
2968 (void (*)(void))ecdh);
2969 }
2970
2971 void
SSL_set_tmp_ecdh_callback(SSL * ssl,EC_KEY * (* ecdh)(SSL * ssl,int is_export,int keylength))2972 SSL_set_tmp_ecdh_callback(SSL *ssl, EC_KEY *(*ecdh)(SSL *ssl, int is_export,
2973 int keylength))
2974 {
2975 SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
2976 }
2977
2978
2979 void
SSL_CTX_set_msg_callback(SSL_CTX * ctx,void (* cb)(int write_p,int version,int content_type,const void * buf,size_t len,SSL * ssl,void * arg))2980 SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb)(int write_p, int version,
2981 int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
2982 {
2983 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK,
2984 (void (*)(void))cb);
2985 }
2986
2987 void
SSL_set_msg_callback(SSL * ssl,void (* cb)(int write_p,int version,int content_type,const void * buf,size_t len,SSL * ssl,void * arg))2988 SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version,
2989 int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
2990 {
2991 SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
2992 }
2993
2994 void
SSL_set_debug(SSL * s,int debug)2995 SSL_set_debug(SSL *s, int debug)
2996 {
2997 s->internal->debug = debug;
2998 }
2999
3000 int
SSL_cache_hit(SSL * s)3001 SSL_cache_hit(SSL *s)
3002 {
3003 return (s->internal->hit);
3004 }
3005
3006 int
SSL_CTX_get_min_proto_version(SSL_CTX * ctx)3007 SSL_CTX_get_min_proto_version(SSL_CTX *ctx)
3008 {
3009 return ctx->internal->min_proto_version;
3010 }
3011
3012 int
SSL_CTX_set_min_proto_version(SSL_CTX * ctx,uint16_t version)3013 SSL_CTX_set_min_proto_version(SSL_CTX *ctx, uint16_t version)
3014 {
3015 return ssl_version_set_min(ctx->method, version,
3016 ctx->internal->max_tls_version, &ctx->internal->min_tls_version,
3017 &ctx->internal->min_proto_version);
3018 }
3019
3020 int
SSL_CTX_get_max_proto_version(SSL_CTX * ctx)3021 SSL_CTX_get_max_proto_version(SSL_CTX *ctx)
3022 {
3023 return ctx->internal->max_proto_version;
3024 }
3025
3026 int
SSL_CTX_set_max_proto_version(SSL_CTX * ctx,uint16_t version)3027 SSL_CTX_set_max_proto_version(SSL_CTX *ctx, uint16_t version)
3028 {
3029 return ssl_version_set_max(ctx->method, version,
3030 ctx->internal->min_tls_version, &ctx->internal->max_tls_version,
3031 &ctx->internal->max_proto_version);
3032 }
3033
3034 int
SSL_get_min_proto_version(SSL * ssl)3035 SSL_get_min_proto_version(SSL *ssl)
3036 {
3037 return ssl->internal->min_proto_version;
3038 }
3039
3040 int
SSL_set_min_proto_version(SSL * ssl,uint16_t version)3041 SSL_set_min_proto_version(SSL *ssl, uint16_t version)
3042 {
3043 return ssl_version_set_min(ssl->method, version,
3044 ssl->internal->max_tls_version, &ssl->internal->min_tls_version,
3045 &ssl->internal->min_proto_version);
3046 }
3047 int
SSL_get_max_proto_version(SSL * ssl)3048 SSL_get_max_proto_version(SSL *ssl)
3049 {
3050 return ssl->internal->max_proto_version;
3051 }
3052
3053 int
SSL_set_max_proto_version(SSL * ssl,uint16_t version)3054 SSL_set_max_proto_version(SSL *ssl, uint16_t version)
3055 {
3056 return ssl_version_set_max(ssl->method, version,
3057 ssl->internal->min_tls_version, &ssl->internal->max_tls_version,
3058 &ssl->internal->max_proto_version);
3059 }
3060
3061 static int
ssl_cipher_id_cmp_BSEARCH_CMP_FN(const void * a_,const void * b_)3062 ssl_cipher_id_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)
3063 {
3064 SSL_CIPHER const *a = a_;
3065 SSL_CIPHER const *b = b_;
3066 return ssl_cipher_id_cmp(a, b);
3067 }
3068
3069 SSL_CIPHER *
OBJ_bsearch_ssl_cipher_id(SSL_CIPHER * key,SSL_CIPHER const * base,int num)3070 OBJ_bsearch_ssl_cipher_id(SSL_CIPHER *key, SSL_CIPHER const *base, int num)
3071 {
3072 return (SSL_CIPHER *)OBJ_bsearch_(key, base, num, sizeof(SSL_CIPHER),
3073 ssl_cipher_id_cmp_BSEARCH_CMP_FN);
3074 }
3075