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