Branch data Line data Source code
1 : : /*! \file ssl/ssl_lib.c
2 : : * \brief Version independent SSL functions.
3 : : */
4 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
5 : : * All rights reserved.
6 : : *
7 : : * This package is an SSL implementation written
8 : : * by Eric Young (eay@cryptsoft.com).
9 : : * The implementation was written so as to conform with Netscapes SSL.
10 : : *
11 : : * This library is free for commercial and non-commercial use as long as
12 : : * the following conditions are aheared to. The following conditions
13 : : * apply to all code found in this distribution, be it the RC4, RSA,
14 : : * lhash, DES, etc., code; not just the SSL code. The SSL documentation
15 : : * included with this distribution is covered by the same copyright terms
16 : : * except that the holder is Tim Hudson (tjh@cryptsoft.com).
17 : : *
18 : : * Copyright remains Eric Young's, and as such any Copyright notices in
19 : : * the code are not to be removed.
20 : : * If this package is used in a product, Eric Young should be given attribution
21 : : * as the author of the parts of the library used.
22 : : * This can be in the form of a textual message at program startup or
23 : : * in documentation (online or textual) provided with the package.
24 : : *
25 : : * Redistribution and use in source and binary forms, with or without
26 : : * modification, are permitted provided that the following conditions
27 : : * are met:
28 : : * 1. Redistributions of source code must retain the copyright
29 : : * notice, this list of conditions and the following disclaimer.
30 : : * 2. Redistributions in binary form must reproduce the above copyright
31 : : * notice, this list of conditions and the following disclaimer in the
32 : : * documentation and/or other materials provided with the distribution.
33 : : * 3. All advertising materials mentioning features or use of this software
34 : : * must display the following acknowledgement:
35 : : * "This product includes cryptographic software written by
36 : : * Eric Young (eay@cryptsoft.com)"
37 : : * The word 'cryptographic' can be left out if the rouines from the library
38 : : * being used are not cryptographic related :-).
39 : : * 4. If you include any Windows specific code (or a derivative thereof) from
40 : : * the apps directory (application code) you must include an acknowledgement:
41 : : * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
42 : : *
43 : : * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
44 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
47 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53 : : * SUCH DAMAGE.
54 : : *
55 : : * The licence and distribution terms for any publically available version or
56 : : * derivative of this code cannot be changed. i.e. this code cannot simply be
57 : : * copied and put under another distribution licence
58 : : * [including the GNU Public Licence.]
59 : : */
60 : : /* ====================================================================
61 : : * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
62 : : *
63 : : * Redistribution and use in source and binary forms, with or without
64 : : * modification, are permitted provided that the following conditions
65 : : * are met:
66 : : *
67 : : * 1. Redistributions of source code must retain the above copyright
68 : : * notice, this list of conditions and the following disclaimer.
69 : : *
70 : : * 2. Redistributions in binary form must reproduce the above copyright
71 : : * notice, this list of conditions and the following disclaimer in
72 : : * the documentation and/or other materials provided with the
73 : : * distribution.
74 : : *
75 : : * 3. All advertising materials mentioning features or use of this
76 : : * software must display the following acknowledgment:
77 : : * "This product includes software developed by the OpenSSL Project
78 : : * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
79 : : *
80 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
81 : : * endorse or promote products derived from this software without
82 : : * prior written permission. For written permission, please contact
83 : : * openssl-core@openssl.org.
84 : : *
85 : : * 5. Products derived from this software may not be called "OpenSSL"
86 : : * nor may "OpenSSL" appear in their names without prior written
87 : : * permission of the OpenSSL Project.
88 : : *
89 : : * 6. Redistributions of any form whatsoever must retain the following
90 : : * acknowledgment:
91 : : * "This product includes software developed by the OpenSSL Project
92 : : * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
93 : : *
94 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
95 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
96 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
97 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
98 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
99 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
100 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
101 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
102 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
103 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
104 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
105 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
106 : : * ====================================================================
107 : : *
108 : : * This product includes cryptographic software written by Eric Young
109 : : * (eay@cryptsoft.com). This product includes software written by Tim
110 : : * Hudson (tjh@cryptsoft.com).
111 : : *
112 : : */
113 : : /* ====================================================================
114 : : * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
115 : : * ECC cipher suite support in OpenSSL originally developed by
116 : : * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
117 : : */
118 : : /* ====================================================================
119 : : * Copyright 2005 Nokia. All rights reserved.
120 : : *
121 : : * The portions of the attached software ("Contribution") is developed by
122 : : * Nokia Corporation and is licensed pursuant to the OpenSSL open source
123 : : * license.
124 : : *
125 : : * The Contribution, originally written by Mika Kousa and Pasi Eronen of
126 : : * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
127 : : * support (see RFC 4279) to OpenSSL.
128 : : *
129 : : * No patent licenses or other rights except those expressly stated in
130 : : * the OpenSSL open source license shall be deemed granted or received
131 : : * expressly, by implication, estoppel, or otherwise.
132 : : *
133 : : * No assurances are provided by Nokia that the Contribution does not
134 : : * infringe the patent or other intellectual property rights of any third
135 : : * party or that the license provides you with all the necessary rights
136 : : * to make use of the Contribution.
137 : : *
138 : : * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
139 : : * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
140 : : * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
141 : : * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
142 : : * OTHERWISE.
143 : : */
144 : :
145 : : #ifdef REF_CHECK
146 : : # include <assert.h>
147 : : #endif
148 : : #include <stdio.h>
149 : : #include "ssl_locl.h"
150 : : #include "kssl_lcl.h"
151 : : #include <openssl/objects.h>
152 : : #include <openssl/lhash.h>
153 : : #include <openssl/x509v3.h>
154 : : #include <openssl/rand.h>
155 : : #include <openssl/ocsp.h>
156 : : #ifndef OPENSSL_NO_DH
157 : : #include <openssl/dh.h>
158 : : #endif
159 : : #ifndef OPENSSL_NO_ENGINE
160 : : #include <openssl/engine.h>
161 : : #endif
162 : :
163 : : const char *SSL_version_str=OPENSSL_VERSION_TEXT;
164 : :
165 : : SSL3_ENC_METHOD ssl3_undef_enc_method={
166 : : /* evil casts, but these functions are only called if there's a library bug */
167 : : (int (*)(SSL *,int))ssl_undefined_function,
168 : : (int (*)(SSL *, unsigned char *, int))ssl_undefined_function,
169 : : ssl_undefined_function,
170 : : (int (*)(SSL *, unsigned char *, unsigned char *, int))ssl_undefined_function,
171 : : (int (*)(SSL*, int))ssl_undefined_function,
172 : : (int (*)(SSL *, const char*, int, unsigned char *))ssl_undefined_function,
173 : : 0, /* finish_mac_length */
174 : : (int (*)(SSL *, int, unsigned char *))ssl_undefined_function,
175 : : NULL, /* client_finished_label */
176 : : 0, /* client_finished_label_len */
177 : : NULL, /* server_finished_label */
178 : : 0, /* server_finished_label_len */
179 : : (int (*)(int))ssl_undefined_function,
180 : : (int (*)(SSL *, unsigned char *, size_t, const char *,
181 : : size_t, const unsigned char *, size_t,
182 : : int use_context)) ssl_undefined_function,
183 : : };
184 : :
185 : 4232 : int SSL_clear(SSL *s)
186 : : {
187 : :
188 [ - + ]: 4232 : if (s->method == NULL)
189 : : {
190 : 0 : SSLerr(SSL_F_SSL_CLEAR,SSL_R_NO_METHOD_SPECIFIED);
191 : 0 : return(0);
192 : : }
193 : :
194 [ - + ]: 4232 : if (ssl_clear_bad_session(s))
195 : : {
196 : 0 : SSL_SESSION_free(s->session);
197 : 0 : s->session=NULL;
198 : : }
199 : :
200 : 4232 : s->error=0;
201 : 4232 : s->hit=0;
202 : 4232 : s->shutdown=0;
203 : :
204 : : #if 0 /* Disabled since version 1.10 of this file (early return not
205 : : * needed because SSL_clear is not called when doing renegotiation) */
206 : : /* This is set if we are doing dynamic renegotiation so keep
207 : : * the old cipher. It is sort of a SSL_clear_lite :-) */
208 : : if (s->renegotiate) return(1);
209 : : #else
210 [ - + ]: 4232 : if (s->renegotiate)
211 : : {
212 : 0 : SSLerr(SSL_F_SSL_CLEAR,ERR_R_INTERNAL_ERROR);
213 : 0 : return 0;
214 : : }
215 : : #endif
216 : :
217 : 4232 : s->type=0;
218 : :
219 [ + + ]: 4232 : s->state=SSL_ST_BEFORE|((s->server)?SSL_ST_ACCEPT:SSL_ST_CONNECT);
220 : :
221 : 4232 : s->version=s->method->version;
222 : 4232 : s->client_version=s->version;
223 : 4232 : s->rwstate=SSL_NOTHING;
224 : 4232 : s->rstate=SSL_ST_READ_HEADER;
225 : : #if 0
226 : : s->read_ahead=s->ctx->read_ahead;
227 : : #endif
228 : :
229 [ - + ]: 4232 : if (s->init_buf != NULL)
230 : : {
231 : 0 : BUF_MEM_free(s->init_buf);
232 : 0 : s->init_buf=NULL;
233 : : }
234 : :
235 : 4232 : ssl_clear_cipher_ctx(s);
236 : 4232 : ssl_clear_hash_ctx(&s->read_hash);
237 : 4232 : ssl_clear_hash_ctx(&s->write_hash);
238 : :
239 : 4232 : s->first_packet=0;
240 : :
241 : : #if 1
242 : : /* Check to see if we were changed into a different method, if
243 : : * so, revert back if we are not doing session-id reuse. */
244 [ + + ][ + - ]: 4232 : if (!s->in_handshake && (s->session == NULL) && (s->method != s->ctx->method))
[ - + ]
245 : : {
246 : 0 : s->method->ssl_free(s);
247 : 0 : s->method=s->ctx->method;
248 [ # # ]: 0 : if (!s->method->ssl_new(s))
249 : : return(0);
250 : : }
251 : : else
252 : : #endif
253 : 4232 : s->method->ssl_clear(s);
254 : : return(1);
255 : : }
256 : :
257 : : /** Used to change an SSL_CTXs default SSL method type */
258 : 0 : int SSL_CTX_set_ssl_version(SSL_CTX *ctx,const SSL_METHOD *meth)
259 : : {
260 : : STACK_OF(SSL_CIPHER) *sk;
261 : :
262 : 0 : ctx->method=meth;
263 : :
264 [ # # ]: 0 : sk=ssl_create_cipher_list(ctx->method,&(ctx->cipher_list),
265 : : &(ctx->cipher_list_by_id),
266 : 0 : meth->version == SSL2_VERSION ? "SSLv2" : SSL_DEFAULT_CIPHER_LIST, ctx->cert);
267 [ # # ][ # # ]: 0 : if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0))
268 : : {
269 : 0 : SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
270 : 0 : return(0);
271 : : }
272 : : return(1);
273 : : }
274 : :
275 : 1808 : SSL *SSL_new(SSL_CTX *ctx)
276 : : {
277 : : SSL *s;
278 : :
279 [ - + ]: 1808 : if (ctx == NULL)
280 : : {
281 : 0 : SSLerr(SSL_F_SSL_NEW,SSL_R_NULL_SSL_CTX);
282 : 0 : return(NULL);
283 : : }
284 [ - + ]: 1808 : if (ctx->method == NULL)
285 : : {
286 : 0 : SSLerr(SSL_F_SSL_NEW,SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
287 : 0 : return(NULL);
288 : : }
289 : :
290 : 1808 : s=(SSL *)OPENSSL_malloc(sizeof(SSL));
291 [ + - ]: 1808 : if (s == NULL) goto err;
292 : : memset(s,0,sizeof(SSL));
293 : :
294 : : #ifndef OPENSSL_NO_KRB5
295 : : s->kssl_ctx = kssl_ctx_new();
296 : : #endif /* OPENSSL_NO_KRB5 */
297 : :
298 : 1808 : s->options=ctx->options;
299 : 1808 : s->mode=ctx->mode;
300 : 1808 : s->max_cert_list=ctx->max_cert_list;
301 : :
302 [ + - ]: 1808 : if (ctx->cert != NULL)
303 : : {
304 : : /* Earlier library versions used to copy the pointer to
305 : : * the CERT, not its contents; only when setting new
306 : : * parameters for the per-SSL copy, ssl_cert_new would be
307 : : * called (and the direct reference to the per-SSL_CTX
308 : : * settings would be lost, but those still were indirectly
309 : : * accessed for various purposes, and for that reason they
310 : : * used to be known as s->ctx->default_cert).
311 : : * Now we don't look at the SSL_CTX's CERT after having
312 : : * duplicated it once. */
313 : :
314 : 1808 : s->cert = ssl_cert_dup(ctx->cert);
315 [ + - ]: 1808 : if (s->cert == NULL)
316 : : goto err;
317 : : }
318 : : else
319 : 0 : s->cert=NULL; /* Cannot really happen (see SSL_CTX_new) */
320 : :
321 : 1808 : s->read_ahead=ctx->read_ahead;
322 : 1808 : s->msg_callback=ctx->msg_callback;
323 : 1808 : s->msg_callback_arg=ctx->msg_callback_arg;
324 : 1808 : s->verify_mode=ctx->verify_mode;
325 : 1808 : s->not_resumable_session_cb=ctx->not_resumable_session_cb;
326 : : #if 0
327 : : s->verify_depth=ctx->verify_depth;
328 : : #endif
329 : 1808 : s->sid_ctx_length=ctx->sid_ctx_length;
330 [ - + ]: 1808 : OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
331 : 1808 : memcpy(&s->sid_ctx,&ctx->sid_ctx,sizeof(s->sid_ctx));
332 : 1808 : s->verify_callback=ctx->default_verify_callback;
333 : 1808 : s->generate_session_id=ctx->generate_session_id;
334 : :
335 : 1808 : s->param = X509_VERIFY_PARAM_new();
336 [ + - ]: 1808 : if (!s->param)
337 : : goto err;
338 : 1808 : X509_VERIFY_PARAM_inherit(s->param, ctx->param);
339 : : #if 0
340 : : s->purpose = ctx->purpose;
341 : : s->trust = ctx->trust;
342 : : #endif
343 : 1808 : s->quiet_shutdown=ctx->quiet_shutdown;
344 : 1808 : s->max_send_fragment = ctx->max_send_fragment;
345 : :
346 : 1808 : CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
347 : 1808 : s->ctx=ctx;
348 : : #ifndef OPENSSL_NO_TLSEXT
349 : 1808 : s->tlsext_debug_cb = 0;
350 : 1808 : s->tlsext_debug_arg = NULL;
351 : 1808 : s->tlsext_ticket_expected = 0;
352 : 1808 : s->tlsext_status_type = -1;
353 : 1808 : s->tlsext_status_expected = 0;
354 : 1808 : s->tlsext_ocsp_ids = NULL;
355 : 1808 : s->tlsext_ocsp_exts = NULL;
356 : 1808 : s->tlsext_ocsp_resp = NULL;
357 : 1808 : s->tlsext_ocsp_resplen = -1;
358 : 1808 : CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
359 : 1808 : s->initial_ctx=ctx;
360 : : #ifndef OPENSSL_NO_EC
361 [ - + ]: 1808 : if (ctx->tlsext_ecpointformatlist)
362 : : {
363 : 0 : s->tlsext_ecpointformatlist =
364 : 0 : BUF_memdup(ctx->tlsext_ecpointformatlist,
365 : : ctx->tlsext_ecpointformatlist_length);
366 [ # # ]: 0 : if (!s->tlsext_ecpointformatlist)
367 : : goto err;
368 : 0 : s->tlsext_ecpointformatlist_length =
369 : 0 : ctx->tlsext_ecpointformatlist_length;
370 : : }
371 [ - + ]: 1808 : if (ctx->tlsext_ellipticcurvelist)
372 : : {
373 : 0 : s->tlsext_ellipticcurvelist =
374 : 0 : BUF_memdup(ctx->tlsext_ellipticcurvelist,
375 : : ctx->tlsext_ellipticcurvelist_length);
376 [ # # ]: 0 : if (!s->tlsext_ellipticcurvelist)
377 : : goto err;
378 : 0 : s->tlsext_ellipticcurvelist_length =
379 : 0 : ctx->tlsext_ellipticcurvelist_length;
380 : : }
381 : : #endif
382 : : # ifndef OPENSSL_NO_NEXTPROTONEG
383 : 1808 : s->next_proto_negotiated = NULL;
384 : : # endif
385 : :
386 [ + + ]: 1808 : if (s->ctx->alpn_client_proto_list)
387 : : {
388 : 88 : s->alpn_client_proto_list =
389 : 88 : OPENSSL_malloc(s->ctx->alpn_client_proto_list_len);
390 [ + - ]: 88 : if (s->alpn_client_proto_list == NULL)
391 : : goto err;
392 : 88 : memcpy(s->alpn_client_proto_list, s->ctx->alpn_client_proto_list,
393 : 88 : s->ctx->alpn_client_proto_list_len);
394 : 88 : s->alpn_client_proto_list_len = s->ctx->alpn_client_proto_list_len;
395 : : }
396 : : #endif
397 : :
398 : 1808 : s->verify_result=X509_V_OK;
399 : :
400 : 1808 : s->method=ctx->method;
401 : :
402 [ + - ]: 1808 : if (!s->method->ssl_new(s))
403 : : goto err;
404 : :
405 : 1808 : s->references=1;
406 : 1808 : s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
407 : :
408 : 1808 : SSL_clear(s);
409 : :
410 : 1808 : CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
411 : :
412 : : #ifndef OPENSSL_NO_PSK
413 : 1808 : s->psk_client_callback=ctx->psk_client_callback;
414 : 1808 : s->psk_server_callback=ctx->psk_server_callback;
415 : : #endif
416 : :
417 : 1808 : return(s);
418 : : err:
419 [ # # ]: 0 : if (s != NULL)
420 : : {
421 [ # # ]: 0 : if (s->cert != NULL)
422 : 0 : ssl_cert_free(s->cert);
423 [ # # ]: 0 : if (s->ctx != NULL)
424 : 0 : SSL_CTX_free(s->ctx); /* decrement reference count */
425 : 0 : OPENSSL_free(s);
426 : : }
427 : 0 : SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
428 : 0 : return(NULL);
429 : : }
430 : :
431 : 893 : int SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx,
432 : : unsigned int sid_ctx_len)
433 : : {
434 [ - + ]: 893 : if(sid_ctx_len > sizeof ctx->sid_ctx)
435 : : {
436 : 0 : SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
437 : 0 : return 0;
438 : : }
439 : 893 : ctx->sid_ctx_length=sid_ctx_len;
440 : 893 : memcpy(ctx->sid_ctx,sid_ctx,sid_ctx_len);
441 : :
442 : 893 : return 1;
443 : : }
444 : :
445 : 0 : int SSL_set_session_id_context(SSL *ssl,const unsigned char *sid_ctx,
446 : : unsigned int sid_ctx_len)
447 : : {
448 [ # # ]: 0 : if(sid_ctx_len > SSL_MAX_SID_CTX_LENGTH)
449 : : {
450 : 0 : SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
451 : 0 : return 0;
452 : : }
453 : 0 : ssl->sid_ctx_length=sid_ctx_len;
454 : 0 : memcpy(ssl->sid_ctx,sid_ctx,sid_ctx_len);
455 : :
456 : 0 : return 1;
457 : : }
458 : :
459 : 0 : int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
460 : : {
461 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
462 : 0 : ctx->generate_session_id = cb;
463 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
464 : 0 : return 1;
465 : : }
466 : :
467 : 0 : int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
468 : : {
469 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_SSL);
470 : 0 : ssl->generate_session_id = cb;
471 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
472 : 0 : return 1;
473 : : }
474 : :
475 : 770 : int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
476 : : unsigned int id_len)
477 : : {
478 : : /* A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
479 : : * we can "construct" a session to give us the desired check - ie. to
480 : : * find if there's a session in the hash table that would conflict with
481 : : * any new session built out of this id/id_len and the ssl_version in
482 : : * use by this SSL. */
483 : : SSL_SESSION r, *p;
484 : :
485 [ + - ]: 770 : if(id_len > sizeof r.session_id)
486 : : return 0;
487 : :
488 : 770 : r.ssl_version = ssl->version;
489 : 770 : r.session_id_length = id_len;
490 : 770 : memcpy(r.session_id, id, id_len);
491 : : /* NB: SSLv2 always uses a fixed 16-byte session ID, so even if a
492 : : * callback is calling us to check the uniqueness of a shorter ID, it
493 : : * must be compared as a padded-out ID because that is what it will be
494 : : * converted to when the callback has finished choosing it. */
495 [ + + ][ - + ]: 770 : if((r.ssl_version == SSL2_VERSION) &&
496 : : (id_len < SSL2_SSL_SESSION_ID_LENGTH))
497 : : {
498 : 0 : memset(r.session_id + id_len, 0,
499 : 0 : SSL2_SSL_SESSION_ID_LENGTH - id_len);
500 : 0 : r.session_id_length = SSL2_SSL_SESSION_ID_LENGTH;
501 : : }
502 : :
503 : 770 : CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
504 : 770 : p = lh_SSL_SESSION_retrieve(ssl->ctx->sessions, &r);
505 : 770 : CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
506 : 770 : return (p != NULL);
507 : : }
508 : :
509 : 0 : int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
510 : : {
511 : 0 : return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
512 : : }
513 : :
514 : 0 : int SSL_set_purpose(SSL *s, int purpose)
515 : : {
516 : 0 : return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
517 : : }
518 : :
519 : 0 : int SSL_CTX_set_trust(SSL_CTX *s, int trust)
520 : : {
521 : 0 : return X509_VERIFY_PARAM_set_trust(s->param, trust);
522 : : }
523 : :
524 : 0 : int SSL_set_trust(SSL *s, int trust)
525 : : {
526 : 0 : return X509_VERIFY_PARAM_set_trust(s->param, trust);
527 : : }
528 : :
529 : 0 : int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
530 : : {
531 : 0 : return X509_VERIFY_PARAM_set1(ctx->param, vpm);
532 : : }
533 : :
534 : 0 : int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
535 : : {
536 : 0 : return X509_VERIFY_PARAM_set1(ssl->param, vpm);
537 : : }
538 : :
539 : 0 : X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
540 : : {
541 : 0 : return ctx->param;
542 : : }
543 : :
544 : 0 : X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
545 : : {
546 : 0 : return ssl->param;
547 : : }
548 : :
549 : 0 : void SSL_certs_clear(SSL *s)
550 : : {
551 : 0 : ssl_cert_clear_certs(s->cert);
552 : 0 : }
553 : :
554 : 1808 : void SSL_free(SSL *s)
555 : : {
556 : : int i;
557 : :
558 [ + - ]: 1808 : if(s == NULL)
559 : : return;
560 : :
561 : 1808 : i=CRYPTO_add(&s->references,-1,CRYPTO_LOCK_SSL);
562 : : #ifdef REF_PRINT
563 : : REF_PRINT("SSL",s);
564 : : #endif
565 [ + - ]: 1808 : if (i > 0) return;
566 : : #ifdef REF_CHECK
567 : : if (i < 0)
568 : : {
569 : : fprintf(stderr,"SSL_free, bad reference count\n");
570 : : abort(); /* ok */
571 : : }
572 : : #endif
573 : :
574 [ + - ]: 1808 : if (s->param)
575 : 1808 : X509_VERIFY_PARAM_free(s->param);
576 : :
577 : 1808 : CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
578 : :
579 [ - + ]: 1808 : if (s->bbio != NULL)
580 : : {
581 : : /* If the buffering BIO is in place, pop it off */
582 [ # # ]: 0 : if (s->bbio == s->wbio)
583 : : {
584 : 0 : s->wbio=BIO_pop(s->wbio);
585 : : }
586 : 0 : BIO_free(s->bbio);
587 : 0 : s->bbio=NULL;
588 : : }
589 [ + + ]: 1808 : if (s->rbio != NULL)
590 : 880 : BIO_free_all(s->rbio);
591 [ + + ][ - + ]: 1808 : if ((s->wbio != NULL) && (s->wbio != s->rbio))
592 : 0 : BIO_free_all(s->wbio);
593 : :
594 [ + + ]: 1808 : if (s->init_buf != NULL) BUF_MEM_free(s->init_buf);
595 : :
596 : : /* add extra stuff */
597 [ - + ]: 1808 : if (s->cipher_list != NULL) sk_SSL_CIPHER_free(s->cipher_list);
598 [ - + ]: 1808 : if (s->cipher_list_by_id != NULL) sk_SSL_CIPHER_free(s->cipher_list_by_id);
599 : :
600 : : /* Make the next call work :-) */
601 [ + + ]: 1808 : if (s->session != NULL)
602 : : {
603 : 1786 : ssl_clear_bad_session(s);
604 : 1786 : SSL_SESSION_free(s->session);
605 : : }
606 : :
607 : 1808 : ssl_clear_cipher_ctx(s);
608 : 1808 : ssl_clear_hash_ctx(&s->read_hash);
609 : 1808 : ssl_clear_hash_ctx(&s->write_hash);
610 : :
611 [ + - ]: 1808 : if (s->cert != NULL) ssl_cert_free(s->cert);
612 : : /* Free up if allocated */
613 : :
614 : : #ifndef OPENSSL_NO_TLSEXT
615 [ - + ]: 1808 : if (s->tlsext_hostname)
616 : 0 : OPENSSL_free(s->tlsext_hostname);
617 [ + - ]: 1808 : if (s->initial_ctx) SSL_CTX_free(s->initial_ctx);
618 : : #ifndef OPENSSL_NO_EC
619 [ - + ]: 1808 : if (s->tlsext_ecpointformatlist) OPENSSL_free(s->tlsext_ecpointformatlist);
620 [ - + ]: 1808 : if (s->tlsext_ellipticcurvelist) OPENSSL_free(s->tlsext_ellipticcurvelist);
621 : : #endif /* OPENSSL_NO_EC */
622 [ - + ]: 1808 : if (s->tlsext_opaque_prf_input) OPENSSL_free(s->tlsext_opaque_prf_input);
623 [ - + ]: 1808 : if (s->tlsext_ocsp_exts)
624 : 0 : sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
625 : : X509_EXTENSION_free);
626 [ - + ]: 1808 : if (s->tlsext_ocsp_ids)
627 : 0 : sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
628 [ - + ]: 1808 : if (s->tlsext_ocsp_resp)
629 : 0 : OPENSSL_free(s->tlsext_ocsp_resp);
630 [ + + ]: 1808 : if (s->alpn_client_proto_list)
631 : 88 : OPENSSL_free(s->alpn_client_proto_list);
632 : : #endif
633 : :
634 [ - + ]: 1808 : if (s->client_CA != NULL)
635 : 0 : sk_X509_NAME_pop_free(s->client_CA,X509_NAME_free);
636 : :
637 [ + - ]: 1808 : if (s->method != NULL) s->method->ssl_free(s);
638 : :
639 [ + - ]: 1808 : if (s->ctx) SSL_CTX_free(s->ctx);
640 : :
641 : : #ifndef OPENSSL_NO_KRB5
642 : : if (s->kssl_ctx != NULL)
643 : : kssl_ctx_free(s->kssl_ctx);
644 : : #endif /* OPENSSL_NO_KRB5 */
645 : :
646 : : #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
647 [ + + ]: 1808 : if (s->next_proto_negotiated)
648 : 66 : OPENSSL_free(s->next_proto_negotiated);
649 : : #endif
650 : :
651 [ - + ]: 1808 : if (s->srtp_profiles)
652 : 0 : sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
653 : :
654 : 1808 : OPENSSL_free(s);
655 : : }
656 : :
657 : 2424 : void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
658 : : {
659 : : /* If the output buffering BIO is still in place, remove it
660 : : */
661 [ - + ]: 2424 : if (s->bbio != NULL)
662 : : {
663 [ # # ]: 0 : if (s->wbio == s->bbio)
664 : : {
665 : 0 : s->wbio=s->wbio->next_bio;
666 : 0 : s->bbio->next_bio=NULL;
667 : : }
668 : : }
669 [ + + ][ + - ]: 2424 : if ((s->rbio != NULL) && (s->rbio != rbio))
670 : 638 : BIO_free_all(s->rbio);
671 [ + + ][ + - ]: 2424 : if ((s->wbio != NULL) && (s->wbio != wbio) && (s->rbio != s->wbio))
[ - + ]
672 : 0 : BIO_free_all(s->wbio);
673 : 2424 : s->rbio=rbio;
674 : 2424 : s->wbio=wbio;
675 : 2424 : }
676 : :
677 : 70813 : BIO *SSL_get_rbio(const SSL *s)
678 : 70813 : { return(s->rbio); }
679 : :
680 : 18472 : BIO *SSL_get_wbio(const SSL *s)
681 : 18472 : { return(s->wbio); }
682 : :
683 : 0 : int SSL_get_fd(const SSL *s)
684 : : {
685 : 0 : return(SSL_get_rfd(s));
686 : : }
687 : :
688 : 0 : int SSL_get_rfd(const SSL *s)
689 : : {
690 : 0 : int ret= -1;
691 : : BIO *b,*r;
692 : :
693 : 0 : b=SSL_get_rbio(s);
694 : 0 : r=BIO_find_type(b,BIO_TYPE_DESCRIPTOR);
695 [ # # ]: 0 : if (r != NULL)
696 : 0 : BIO_get_fd(r,&ret);
697 : 0 : return(ret);
698 : : }
699 : :
700 : 0 : int SSL_get_wfd(const SSL *s)
701 : : {
702 : 0 : int ret= -1;
703 : : BIO *b,*r;
704 : :
705 : 0 : b=SSL_get_wbio(s);
706 : 0 : r=BIO_find_type(b,BIO_TYPE_DESCRIPTOR);
707 [ # # ]: 0 : if (r != NULL)
708 : 0 : BIO_get_fd(r,&ret);
709 : 0 : return(ret);
710 : : }
711 : :
712 : : #ifndef OPENSSL_NO_SOCK
713 : 0 : int SSL_set_fd(SSL *s,int fd)
714 : : {
715 : 0 : int ret=0;
716 : 0 : BIO *bio=NULL;
717 : :
718 : 0 : bio=BIO_new(BIO_s_socket());
719 : :
720 [ # # ]: 0 : if (bio == NULL)
721 : : {
722 : 0 : SSLerr(SSL_F_SSL_SET_FD,ERR_R_BUF_LIB);
723 : 0 : goto err;
724 : : }
725 : 0 : BIO_set_fd(bio,fd,BIO_NOCLOSE);
726 : 0 : SSL_set_bio(s,bio,bio);
727 : 0 : ret=1;
728 : : err:
729 : 0 : return(ret);
730 : : }
731 : :
732 : 0 : int SSL_set_wfd(SSL *s,int fd)
733 : : {
734 : 0 : int ret=0;
735 : 0 : BIO *bio=NULL;
736 : :
737 [ # # ][ # # ]: 0 : if ((s->rbio == NULL) || (BIO_method_type(s->rbio) != BIO_TYPE_SOCKET)
738 [ # # ]: 0 : || ((int)BIO_get_fd(s->rbio,NULL) != fd))
739 : : {
740 : 0 : bio=BIO_new(BIO_s_socket());
741 : :
742 [ # # ]: 0 : if (bio == NULL)
743 : 0 : { SSLerr(SSL_F_SSL_SET_WFD,ERR_R_BUF_LIB); goto err; }
744 : 0 : BIO_set_fd(bio,fd,BIO_NOCLOSE);
745 : 0 : SSL_set_bio(s,SSL_get_rbio(s),bio);
746 : : }
747 : : else
748 : 0 : SSL_set_bio(s,SSL_get_rbio(s),SSL_get_rbio(s));
749 : : ret=1;
750 : : err:
751 : 0 : return(ret);
752 : : }
753 : :
754 : 0 : int SSL_set_rfd(SSL *s,int fd)
755 : : {
756 : 0 : int ret=0;
757 : 0 : BIO *bio=NULL;
758 : :
759 [ # # ][ # # ]: 0 : if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
760 [ # # ]: 0 : || ((int)BIO_get_fd(s->wbio,NULL) != fd))
761 : : {
762 : 0 : bio=BIO_new(BIO_s_socket());
763 : :
764 [ # # ]: 0 : if (bio == NULL)
765 : : {
766 : 0 : SSLerr(SSL_F_SSL_SET_RFD,ERR_R_BUF_LIB);
767 : 0 : goto err;
768 : : }
769 : 0 : BIO_set_fd(bio,fd,BIO_NOCLOSE);
770 : 0 : SSL_set_bio(s,bio,SSL_get_wbio(s));
771 : : }
772 : : else
773 : 0 : SSL_set_bio(s,SSL_get_wbio(s),SSL_get_wbio(s));
774 : : ret=1;
775 : : err:
776 : 0 : return(ret);
777 : : }
778 : : #endif
779 : :
780 : :
781 : : /* return length of latest Finished message we sent, copy to 'buf' */
782 : 0 : size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
783 : : {
784 : 0 : size_t ret = 0;
785 : :
786 [ # # ]: 0 : if (s->s3 != NULL)
787 : : {
788 : 0 : ret = s->s3->tmp.finish_md_len;
789 [ # # ]: 0 : if (count > ret)
790 : 0 : count = ret;
791 : 0 : memcpy(buf, s->s3->tmp.finish_md, count);
792 : : }
793 : 0 : return ret;
794 : : }
795 : :
796 : : /* return length of latest Finished message we expected, copy to 'buf' */
797 : 0 : size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
798 : : {
799 : 0 : size_t ret = 0;
800 : :
801 [ # # ]: 0 : if (s->s3 != NULL)
802 : : {
803 : 0 : ret = s->s3->tmp.peer_finish_md_len;
804 [ # # ]: 0 : if (count > ret)
805 : 0 : count = ret;
806 : 0 : memcpy(buf, s->s3->tmp.peer_finish_md, count);
807 : : }
808 : 0 : return ret;
809 : : }
810 : :
811 : :
812 : 0 : int SSL_get_verify_mode(const SSL *s)
813 : : {
814 : 0 : return(s->verify_mode);
815 : : }
816 : :
817 : 0 : int SSL_get_verify_depth(const SSL *s)
818 : : {
819 : 0 : return X509_VERIFY_PARAM_get_depth(s->param);
820 : : }
821 : :
822 : 0 : int (*SSL_get_verify_callback(const SSL *s))(int,X509_STORE_CTX *)
823 : : {
824 : 0 : return(s->verify_callback);
825 : : }
826 : :
827 : 0 : int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
828 : : {
829 : 0 : return(ctx->verify_mode);
830 : : }
831 : :
832 : 0 : int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
833 : : {
834 : 0 : return X509_VERIFY_PARAM_get_depth(ctx->param);
835 : : }
836 : :
837 : 0 : int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int,X509_STORE_CTX *)
838 : : {
839 : 0 : return(ctx->default_verify_callback);
840 : : }
841 : :
842 : 0 : void SSL_set_verify(SSL *s,int mode,
843 : : int (*callback)(int ok,X509_STORE_CTX *ctx))
844 : : {
845 : 0 : s->verify_mode=mode;
846 [ # # ]: 0 : if (callback != NULL)
847 : 0 : s->verify_callback=callback;
848 : 0 : }
849 : :
850 : 0 : void SSL_set_verify_depth(SSL *s,int depth)
851 : : {
852 : 0 : X509_VERIFY_PARAM_set_depth(s->param, depth);
853 : 0 : }
854 : :
855 : 0 : void SSL_set_read_ahead(SSL *s,int yes)
856 : : {
857 : 0 : s->read_ahead=yes;
858 : 0 : }
859 : :
860 : 0 : int SSL_get_read_ahead(const SSL *s)
861 : : {
862 : 0 : return(s->read_ahead);
863 : : }
864 : :
865 : 24692 : int SSL_pending(const SSL *s)
866 : : {
867 : : /* SSL_pending cannot work properly if read-ahead is enabled
868 : : * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)),
869 : : * and it is impossible to fix since SSL_pending cannot report
870 : : * errors that may be observed while scanning the new data.
871 : : * (Note that SSL_pending() is often used as a boolean value,
872 : : * so we'd better not return -1.)
873 : : */
874 : 24692 : return(s->method->ssl_pending(s));
875 : : }
876 : :
877 : 1190 : X509 *SSL_get_peer_certificate(const SSL *s)
878 : : {
879 : : X509 *r;
880 : :
881 [ + - ][ + - ]: 1190 : if ((s == NULL) || (s->session == NULL))
882 : : r=NULL;
883 : : else
884 : 1190 : r=s->session->peer;
885 : :
886 [ + + ]: 1190 : if (r == NULL) return(r);
887 : :
888 : 1036 : CRYPTO_add(&r->references,1,CRYPTO_LOCK_X509);
889 : :
890 : 1036 : return(r);
891 : : }
892 : :
893 : 0 : STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
894 : : {
895 : : STACK_OF(X509) *r;
896 : :
897 [ # # ][ # # ]: 0 : if ((s == NULL) || (s->session == NULL) || (s->session->sess_cert == NULL))
[ # # ]
898 : : r=NULL;
899 : : else
900 : 0 : r=s->session->sess_cert->cert_chain;
901 : :
902 : : /* If we are a client, cert_chain includes the peer's own
903 : : * certificate; if we are a server, it does not. */
904 : :
905 : 0 : return(r);
906 : : }
907 : :
908 : : /* Now in theory, since the calling process own 't' it should be safe to
909 : : * modify. We need to be able to read f without being hassled */
910 : 0 : void SSL_copy_session_id(SSL *t,const SSL *f)
911 : : {
912 : : CERT *tmp;
913 : :
914 : : /* Do we need to to SSL locking? */
915 : 0 : SSL_set_session(t,SSL_get_session(f));
916 : :
917 : : /* what if we are setup as SSLv2 but want to talk SSLv3 or
918 : : * vice-versa */
919 [ # # ]: 0 : if (t->method != f->method)
920 : : {
921 : 0 : t->method->ssl_free(t); /* cleanup current */
922 : 0 : t->method=f->method; /* change method */
923 : 0 : t->method->ssl_new(t); /* setup new */
924 : : }
925 : :
926 : 0 : tmp=t->cert;
927 [ # # ]: 0 : if (f->cert != NULL)
928 : : {
929 : 0 : CRYPTO_add(&f->cert->references,1,CRYPTO_LOCK_SSL_CERT);
930 : 0 : t->cert=f->cert;
931 : : }
932 : : else
933 : 0 : t->cert=NULL;
934 [ # # ]: 0 : if (tmp != NULL) ssl_cert_free(tmp);
935 : 0 : SSL_set_session_id_context(t,f->sid_ctx,f->sid_ctx_length);
936 : 0 : }
937 : :
938 : : /* Fix this so it checks all the valid key/cert options */
939 : 0 : int SSL_CTX_check_private_key(const SSL_CTX *ctx)
940 : : {
941 [ # # ][ # # ]: 0 : if ( (ctx == NULL) ||
942 [ # # ]: 0 : (ctx->cert == NULL) ||
943 : 0 : (ctx->cert->key->x509 == NULL))
944 : : {
945 : 0 : SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
946 : 0 : return(0);
947 : : }
948 [ # # ]: 0 : if (ctx->cert->key->privatekey == NULL)
949 : : {
950 : 0 : SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
951 : 0 : return(0);
952 : : }
953 : 0 : return(X509_check_private_key(ctx->cert->key->x509, ctx->cert->key->privatekey));
954 : : }
955 : :
956 : : /* Fix this function so that it takes an optional type parameter */
957 : 0 : int SSL_check_private_key(const SSL *ssl)
958 : : {
959 [ # # ]: 0 : if (ssl == NULL)
960 : : {
961 : 0 : SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,ERR_R_PASSED_NULL_PARAMETER);
962 : 0 : return(0);
963 : : }
964 [ # # ]: 0 : if (ssl->cert == NULL)
965 : : {
966 : 0 : SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
967 : 0 : return 0;
968 : : }
969 [ # # ]: 0 : if (ssl->cert->key->x509 == NULL)
970 : : {
971 : 0 : SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
972 : 0 : return(0);
973 : : }
974 [ # # ]: 0 : if (ssl->cert->key->privatekey == NULL)
975 : : {
976 : 0 : SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
977 : 0 : return(0);
978 : : }
979 : 0 : return(X509_check_private_key(ssl->cert->key->x509,
980 : : ssl->cert->key->privatekey));
981 : : }
982 : :
983 : 200 : int SSL_accept(SSL *s)
984 : : {
985 [ - + ]: 200 : if (s->handshake_func == 0)
986 : : /* Not properly initialized yet */
987 : 0 : SSL_set_accept_state(s);
988 : :
989 : 200 : return(s->method->ssl_accept(s));
990 : : }
991 : :
992 : 200 : int SSL_connect(SSL *s)
993 : : {
994 [ - + ]: 200 : if (s->handshake_func == 0)
995 : : /* Not properly initialized yet */
996 : 0 : SSL_set_connect_state(s);
997 : :
998 : 200 : return(s->method->ssl_connect(s));
999 : : }
1000 : :
1001 : 0 : long SSL_get_default_timeout(const SSL *s)
1002 : : {
1003 : 0 : return(s->method->get_timeout());
1004 : : }
1005 : :
1006 : 55738 : int SSL_read(SSL *s,void *buf,int num)
1007 : : {
1008 [ - + ]: 55738 : if (s->handshake_func == 0)
1009 : : {
1010 : 0 : SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
1011 : 0 : return -1;
1012 : : }
1013 : :
1014 [ - + ]: 55738 : if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
1015 : : {
1016 : 0 : s->rwstate=SSL_NOTHING;
1017 : 0 : return(0);
1018 : : }
1019 : 55738 : return(s->method->ssl_read(s,buf,num));
1020 : : }
1021 : :
1022 : 0 : int SSL_peek(SSL *s,void *buf,int num)
1023 : : {
1024 [ # # ]: 0 : if (s->handshake_func == 0)
1025 : : {
1026 : 0 : SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
1027 : 0 : return -1;
1028 : : }
1029 : :
1030 [ # # ]: 0 : if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
1031 : : {
1032 : : return(0);
1033 : : }
1034 : 0 : return(s->method->ssl_peek(s,buf,num));
1035 : : }
1036 : :
1037 : 45509 : int SSL_write(SSL *s,const void *buf,int num)
1038 : : {
1039 [ - + ]: 45509 : if (s->handshake_func == 0)
1040 : : {
1041 : 0 : SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
1042 : 0 : return -1;
1043 : : }
1044 : :
1045 [ - + ]: 45509 : if (s->shutdown & SSL_SENT_SHUTDOWN)
1046 : : {
1047 : 0 : s->rwstate=SSL_NOTHING;
1048 : 0 : SSLerr(SSL_F_SSL_WRITE,SSL_R_PROTOCOL_IS_SHUTDOWN);
1049 : 0 : return(-1);
1050 : : }
1051 : 45509 : return(s->method->ssl_write(s,buf,num));
1052 : : }
1053 : :
1054 : 2424 : int SSL_shutdown(SSL *s)
1055 : : {
1056 : : /* Note that this function behaves differently from what one might
1057 : : * expect. Return values are 0 for no success (yet),
1058 : : * 1 for success; but calling it once is usually not enough,
1059 : : * even if blocking I/O is used (see ssl3_shutdown).
1060 : : */
1061 : :
1062 [ - + ]: 2424 : if (s->handshake_func == 0)
1063 : : {
1064 : 0 : SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
1065 : 0 : return -1;
1066 : : }
1067 : :
1068 [ + - ][ + + ]: 2424 : if ((s != NULL) && !SSL_in_init(s))
1069 : 2380 : return(s->method->ssl_shutdown(s));
1070 : : else
1071 : : return(1);
1072 : : }
1073 : :
1074 : 0 : int SSL_renegotiate(SSL *s)
1075 : : {
1076 [ # # ]: 0 : if (s->renegotiate == 0)
1077 : 0 : s->renegotiate=1;
1078 : :
1079 : 0 : s->new_session=1;
1080 : :
1081 : 0 : return(s->method->ssl_renegotiate(s));
1082 : : }
1083 : :
1084 : 0 : int SSL_renegotiate_abbreviated(SSL *s)
1085 : : {
1086 [ # # ]: 0 : if (s->renegotiate == 0)
1087 : 0 : s->renegotiate=1;
1088 : :
1089 : 0 : s->new_session=0;
1090 : :
1091 : 0 : return(s->method->ssl_renegotiate(s));
1092 : : }
1093 : :
1094 : 0 : int SSL_renegotiate_pending(SSL *s)
1095 : : {
1096 : : /* becomes true when negotiation is requested;
1097 : : * false again once a handshake has finished */
1098 : 0 : return (s->renegotiate != 0);
1099 : : }
1100 : :
1101 : 3664 : long SSL_ctrl(SSL *s,int cmd,long larg,void *parg)
1102 : : {
1103 : : long l;
1104 : :
1105 [ - - - + : 3664 : switch (cmd)
- - - - -
- + - - -
- - ]
1106 : : {
1107 : : case SSL_CTRL_GET_READ_AHEAD:
1108 : 0 : return(s->read_ahead);
1109 : : case SSL_CTRL_SET_READ_AHEAD:
1110 : 0 : l=s->read_ahead;
1111 : 0 : s->read_ahead=larg;
1112 : 0 : return(l);
1113 : :
1114 : : case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1115 : 0 : s->msg_callback_arg = parg;
1116 : 0 : return 1;
1117 : :
1118 : : case SSL_CTRL_OPTIONS:
1119 : 1080 : return(s->options|=larg);
1120 : : case SSL_CTRL_CLEAR_OPTIONS:
1121 : 0 : return(s->options&=~larg);
1122 : : case SSL_CTRL_MODE:
1123 : 0 : return(s->mode|=larg);
1124 : : case SSL_CTRL_CLEAR_MODE:
1125 : 0 : return(s->mode &=~larg);
1126 : : case SSL_CTRL_GET_MAX_CERT_LIST:
1127 : 0 : return(s->max_cert_list);
1128 : : case SSL_CTRL_SET_MAX_CERT_LIST:
1129 : 0 : l=s->max_cert_list;
1130 : 0 : s->max_cert_list=larg;
1131 : 0 : return(l);
1132 : : case SSL_CTRL_SET_MTU:
1133 : : #ifndef OPENSSL_NO_DTLS1
1134 [ # # ]: 0 : if (larg < (long)dtls1_min_mtu())
1135 : : return 0;
1136 : : #endif
1137 : :
1138 [ # # ]: 0 : if (SSL_IS_DTLS(s))
1139 : : {
1140 : 0 : s->d1->mtu = larg;
1141 : 0 : return larg;
1142 : : }
1143 : : return 0;
1144 : : case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1145 [ + - ]: 2584 : if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1146 : : return 0;
1147 : 2584 : s->max_send_fragment = larg;
1148 : 2584 : return 1;
1149 : : case SSL_CTRL_GET_RI_SUPPORT:
1150 [ # # ]: 0 : if (s->s3)
1151 : 0 : return s->s3->send_connection_binding;
1152 : : else return 0;
1153 : : case SSL_CTRL_CERT_FLAGS:
1154 : 0 : return(s->cert->cert_flags|=larg);
1155 : : case SSL_CTRL_CLEAR_CERT_FLAGS:
1156 : 0 : return(s->cert->cert_flags &=~larg);
1157 : :
1158 : : case SSL_CTRL_GET_RAW_CIPHERLIST:
1159 [ # # ]: 0 : if (parg)
1160 : : {
1161 [ # # ]: 0 : if (s->cert->ciphers_raw == NULL)
1162 : : return 0;
1163 : 0 : *(unsigned char **)parg = s->cert->ciphers_raw;
1164 : 0 : return (int)s->cert->ciphers_rawlen;
1165 : : }
1166 : : else
1167 : 0 : return ssl_put_cipher_by_char(s,NULL,NULL);
1168 : : default:
1169 : 0 : return(s->method->ssl_ctrl(s,cmd,larg,parg));
1170 : : }
1171 : : }
1172 : :
1173 : 0 : long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
1174 : : {
1175 [ # # ]: 0 : switch(cmd)
1176 : : {
1177 : : case SSL_CTRL_SET_MSG_CALLBACK:
1178 : 0 : s->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
1179 : 0 : return 1;
1180 : :
1181 : : default:
1182 : 0 : return(s->method->ssl_callback_ctrl(s,cmd,fp));
1183 : : }
1184 : : }
1185 : :
1186 : 0 : LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
1187 : : {
1188 : 0 : return ctx->sessions;
1189 : : }
1190 : :
1191 : 3735 : long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,void *parg)
1192 : : {
1193 : : long l;
1194 : : /* For some cases with ctx == NULL perform syntax checks */
1195 [ - + ]: 3735 : if (ctx == NULL)
1196 : : {
1197 [ # # # ]: 0 : switch (cmd)
1198 : : {
1199 : : #ifndef OPENSSL_NO_EC
1200 : : case SSL_CTRL_SET_CURVES_LIST:
1201 : 0 : return tls1_set_curves_list(NULL, NULL, parg);
1202 : : #endif
1203 : : case SSL_CTRL_SET_SIGALGS_LIST:
1204 : : case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
1205 : 0 : return tls1_set_sigalgs_list(NULL, parg, 0);
1206 : : default:
1207 : : return 0;
1208 : : }
1209 : : }
1210 : :
1211 [ - - - - : 3735 : switch (cmd)
- - + - -
+ - - - -
- - - - -
- - + - -
- - - -
+ ]
1212 : : {
1213 : : case SSL_CTRL_GET_READ_AHEAD:
1214 : 0 : return(ctx->read_ahead);
1215 : : case SSL_CTRL_SET_READ_AHEAD:
1216 : 0 : l=ctx->read_ahead;
1217 : 0 : ctx->read_ahead=larg;
1218 : 0 : return(l);
1219 : :
1220 : : case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1221 : 0 : ctx->msg_callback_arg = parg;
1222 : 0 : return 1;
1223 : :
1224 : : case SSL_CTRL_GET_MAX_CERT_LIST:
1225 : 0 : return(ctx->max_cert_list);
1226 : : case SSL_CTRL_SET_MAX_CERT_LIST:
1227 : 0 : l=ctx->max_cert_list;
1228 : 0 : ctx->max_cert_list=larg;
1229 : 0 : return(l);
1230 : :
1231 : : case SSL_CTRL_SET_SESS_CACHE_SIZE:
1232 : 0 : l=ctx->session_cache_size;
1233 : 0 : ctx->session_cache_size=larg;
1234 : 0 : return(l);
1235 : : case SSL_CTRL_GET_SESS_CACHE_SIZE:
1236 : 726 : return(ctx->session_cache_size);
1237 : : case SSL_CTRL_SET_SESS_CACHE_MODE:
1238 : 0 : l=ctx->session_cache_mode;
1239 : 0 : ctx->session_cache_mode=larg;
1240 : 0 : return(l);
1241 : : case SSL_CTRL_GET_SESS_CACHE_MODE:
1242 : 0 : return(ctx->session_cache_mode);
1243 : :
1244 : : case SSL_CTRL_SESS_NUMBER:
1245 : 363 : return(lh_SSL_SESSION_num_items(ctx->sessions));
1246 : : case SSL_CTRL_SESS_CONNECT:
1247 : 0 : return(ctx->stats.sess_connect);
1248 : : case SSL_CTRL_SESS_CONNECT_GOOD:
1249 : 0 : return(ctx->stats.sess_connect_good);
1250 : : case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
1251 : 0 : return(ctx->stats.sess_connect_renegotiate);
1252 : : case SSL_CTRL_SESS_ACCEPT:
1253 : 0 : return(ctx->stats.sess_accept);
1254 : : case SSL_CTRL_SESS_ACCEPT_GOOD:
1255 : 0 : return(ctx->stats.sess_accept_good);
1256 : : case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
1257 : 0 : return(ctx->stats.sess_accept_renegotiate);
1258 : : case SSL_CTRL_SESS_HIT:
1259 : 0 : return(ctx->stats.sess_hit);
1260 : : case SSL_CTRL_SESS_CB_HIT:
1261 : 0 : return(ctx->stats.sess_cb_hit);
1262 : : case SSL_CTRL_SESS_MISSES:
1263 : 0 : return(ctx->stats.sess_miss);
1264 : : case SSL_CTRL_SESS_TIMEOUTS:
1265 : 0 : return(ctx->stats.sess_timeout);
1266 : : case SSL_CTRL_SESS_CACHE_FULL:
1267 : 0 : return(ctx->stats.sess_cache_full);
1268 : : case SSL_CTRL_OPTIONS:
1269 : 904 : return(ctx->options|=larg);
1270 : : case SSL_CTRL_CLEAR_OPTIONS:
1271 : 0 : return(ctx->options&=~larg);
1272 : : case SSL_CTRL_MODE:
1273 : 0 : return(ctx->mode|=larg);
1274 : : case SSL_CTRL_CLEAR_MODE:
1275 : 0 : return(ctx->mode&=~larg);
1276 : : case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1277 [ # # ]: 0 : if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1278 : : return 0;
1279 : 0 : ctx->max_send_fragment = larg;
1280 : 0 : return 1;
1281 : : case SSL_CTRL_CERT_FLAGS:
1282 : 0 : return(ctx->cert->cert_flags|=larg);
1283 : : case SSL_CTRL_CLEAR_CERT_FLAGS:
1284 : 0 : return(ctx->cert->cert_flags &=~larg);
1285 : : default:
1286 : 1742 : return(ctx->method->ssl_ctx_ctrl(ctx,cmd,larg,parg));
1287 : : }
1288 : : }
1289 : :
1290 : 893 : long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
1291 : : {
1292 [ - + ]: 893 : switch(cmd)
1293 : : {
1294 : : case SSL_CTRL_SET_MSG_CALLBACK:
1295 : 0 : ctx->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
1296 : 0 : return 1;
1297 : :
1298 : : default:
1299 : 893 : return(ctx->method->ssl_ctx_callback_ctrl(ctx,cmd,fp));
1300 : : }
1301 : : }
1302 : :
1303 : 358175 : int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
1304 : : {
1305 : : long l;
1306 : :
1307 : 358175 : l=a->id-b->id;
1308 [ + + ]: 358175 : if (l == 0L)
1309 : : return(0);
1310 : : else
1311 [ + + ]: 300344 : return((l > 0)?1:-1);
1312 : : }
1313 : :
1314 : 1006713 : int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
1315 : : const SSL_CIPHER * const *bp)
1316 : : {
1317 : : long l;
1318 : :
1319 : 1006713 : l=(*ap)->id-(*bp)->id;
1320 [ + + ]: 1006713 : if (l == 0L)
1321 : : return(0);
1322 : : else
1323 [ + + ]: 1005523 : return((l > 0)?1:-1);
1324 : : }
1325 : :
1326 : : /** return a STACK of the ciphers available for the SSL and in order of
1327 : : * preference */
1328 : 3968 : STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
1329 : : {
1330 [ + - ]: 3968 : if (s != NULL)
1331 : : {
1332 [ + - ]: 3968 : if (s->cipher_list != NULL)
1333 : : {
1334 : : return(s->cipher_list);
1335 : : }
1336 [ + - ][ + - ]: 3968 : else if ((s->ctx != NULL) &&
1337 : 3968 : (s->ctx->cipher_list != NULL))
1338 : : {
1339 : 3968 : return(s->ctx->cipher_list);
1340 : : }
1341 : : }
1342 : : return(NULL);
1343 : : }
1344 : :
1345 : 0 : STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
1346 : : {
1347 : 0 : STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
1348 : : int i;
1349 : 0 : ciphers = SSL_get_ciphers(s);
1350 [ # # ]: 0 : if (!ciphers)
1351 : : return NULL;
1352 : 0 : ssl_set_client_disabled(s);
1353 [ # # ]: 0 : for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++)
1354 : : {
1355 : 0 : const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
1356 [ # # ]: 0 : if (!ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED))
1357 : : {
1358 [ # # ]: 0 : if (!sk)
1359 : 0 : sk = sk_SSL_CIPHER_new_null();
1360 [ # # ]: 0 : if (!sk)
1361 : : return NULL;
1362 [ # # ]: 0 : if (!sk_SSL_CIPHER_push(sk, c))
1363 : : {
1364 : 0 : sk_SSL_CIPHER_free(sk);
1365 : 0 : return NULL;
1366 : : }
1367 : : }
1368 : : }
1369 : : return sk;
1370 : : }
1371 : :
1372 : : /** return a STACK of the ciphers available for the SSL and in order of
1373 : : * algorithm id */
1374 : 1080 : STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
1375 : : {
1376 [ + - ]: 1080 : if (s != NULL)
1377 : : {
1378 [ + - ]: 1080 : if (s->cipher_list_by_id != NULL)
1379 : : {
1380 : : return(s->cipher_list_by_id);
1381 : : }
1382 [ + - ][ + - ]: 1080 : else if ((s->ctx != NULL) &&
1383 : 1080 : (s->ctx->cipher_list_by_id != NULL))
1384 : : {
1385 : 1080 : return(s->ctx->cipher_list_by_id);
1386 : : }
1387 : : }
1388 : : return(NULL);
1389 : : }
1390 : :
1391 : : /** The old interface to get the same thing as SSL_get_ciphers() */
1392 : 0 : const char *SSL_get_cipher_list(const SSL *s,int n)
1393 : : {
1394 : : SSL_CIPHER *c;
1395 : : STACK_OF(SSL_CIPHER) *sk;
1396 : :
1397 [ # # ]: 0 : if (s == NULL) return(NULL);
1398 : 0 : sk=SSL_get_ciphers(s);
1399 [ # # ][ # # ]: 0 : if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
1400 : : return(NULL);
1401 : 0 : c=sk_SSL_CIPHER_value(sk,n);
1402 [ # # ]: 0 : if (c == NULL) return(NULL);
1403 : 0 : return(c->name);
1404 : : }
1405 : :
1406 : : /** specify the ciphers to be used by default by the SSL_CTX */
1407 : 620 : int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
1408 : : {
1409 : : STACK_OF(SSL_CIPHER) *sk;
1410 : :
1411 : 620 : sk=ssl_create_cipher_list(ctx->method,&ctx->cipher_list,
1412 : 620 : &ctx->cipher_list_by_id,str, ctx->cert);
1413 : : /* ssl_create_cipher_list may return an empty stack if it
1414 : : * was unable to find a cipher matching the given rule string
1415 : : * (for example if the rule string specifies a cipher which
1416 : : * has been disabled). This is not an error as far as
1417 : : * ssl_create_cipher_list is concerned, and hence
1418 : : * ctx->cipher_list and ctx->cipher_list_by_id has been
1419 : : * updated. */
1420 [ + - ]: 620 : if (sk == NULL)
1421 : : return 0;
1422 [ - + ]: 620 : else if (sk_SSL_CIPHER_num(sk) == 0)
1423 : : {
1424 : 0 : SSLerr(SSL_F_SSL_CTX_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
1425 : 0 : return 0;
1426 : : }
1427 : : return 1;
1428 : : }
1429 : :
1430 : : /** specify the ciphers to be used by the SSL */
1431 : 0 : int SSL_set_cipher_list(SSL *s,const char *str)
1432 : : {
1433 : : STACK_OF(SSL_CIPHER) *sk;
1434 : :
1435 : 0 : sk=ssl_create_cipher_list(s->ctx->method,&s->cipher_list,
1436 : 0 : &s->cipher_list_by_id,str, s->cert);
1437 : : /* see comment in SSL_CTX_set_cipher_list */
1438 [ # # ]: 0 : if (sk == NULL)
1439 : : return 0;
1440 [ # # ]: 0 : else if (sk_SSL_CIPHER_num(sk) == 0)
1441 : : {
1442 : 0 : SSLerr(SSL_F_SSL_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
1443 : 0 : return 0;
1444 : : }
1445 : : return 1;
1446 : : }
1447 : :
1448 : : /* works well for SSLv2, not so good for SSLv3 */
1449 : 0 : char *SSL_get_shared_ciphers(const SSL *s,char *buf,int len)
1450 : : {
1451 : : char *p;
1452 : : STACK_OF(SSL_CIPHER) *sk;
1453 : : SSL_CIPHER *c;
1454 : : int i;
1455 : :
1456 [ # # ][ # # ]: 0 : if ((s->session == NULL) || (s->session->ciphers == NULL) ||
[ # # ]
1457 : : (len < 2))
1458 : : return(NULL);
1459 : :
1460 : 0 : p=buf;
1461 : 0 : sk=s->session->ciphers;
1462 : :
1463 [ # # ]: 0 : if (sk_SSL_CIPHER_num(sk) == 0)
1464 : : return NULL;
1465 : :
1466 [ # # ]: 0 : for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1467 : : {
1468 : : int n;
1469 : :
1470 : 0 : c=sk_SSL_CIPHER_value(sk,i);
1471 : 0 : n=strlen(c->name);
1472 [ # # ]: 0 : if (n+1 > len)
1473 : : {
1474 [ # # ]: 0 : if (p != buf)
1475 : 0 : --p;
1476 : 0 : *p='\0';
1477 : 0 : return buf;
1478 : : }
1479 : 0 : strcpy(p,c->name);
1480 : 0 : p+=n;
1481 : 0 : *(p++)=':';
1482 : 0 : len-=n+1;
1483 : : }
1484 : 0 : p[-1]='\0';
1485 : 0 : return(buf);
1486 : : }
1487 : :
1488 : 1344 : int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p,
1489 : : int (*put_cb)(const SSL_CIPHER *, unsigned char *))
1490 : : {
1491 : 1344 : int i,j=0;
1492 : : SSL_CIPHER *c;
1493 : : unsigned char *q;
1494 : 1344 : int no_scsv = s->renegotiate;
1495 : : /* Set disabled masks for this session */
1496 : 1344 : ssl_set_client_disabled(s);
1497 : :
1498 [ + - ]: 1344 : if (sk == NULL) return(0);
1499 : : q=p;
1500 : :
1501 [ + + ]: 87322 : for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1502 : : {
1503 : 85978 : c=sk_SSL_CIPHER_value(sk,i);
1504 : : /* Skip disabled ciphers */
1505 [ + + ]: 85978 : if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED))
1506 : 29194 : continue;
1507 : : #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
1508 : : if (c->id == SSL3_CK_SCSV)
1509 : : {
1510 : : if (no_scsv)
1511 : : continue;
1512 : : else
1513 : : no_scsv = 1;
1514 : : }
1515 : : #endif
1516 [ + + ]: 56784 : j = put_cb ? put_cb(c,p) : ssl_put_cipher_by_char(s,c,p);
1517 : 56784 : p+=j;
1518 : : }
1519 : : /* If p == q, no ciphers and caller indicates an error. Otherwise
1520 : : * add SCSV if not renegotiating.
1521 : : */
1522 [ + - ]: 1344 : if (p != q && !no_scsv)
1523 : : {
1524 : : static SSL_CIPHER scsv =
1525 : : {
1526 : : 0, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
1527 : : };
1528 [ + + ]: 1344 : j = put_cb ? put_cb(&scsv,p) : ssl_put_cipher_by_char(s,&scsv,p);
1529 : 1344 : p+=j;
1530 : : #ifdef OPENSSL_RI_DEBUG
1531 : : fprintf(stderr, "SCSV sent by client\n");
1532 : : #endif
1533 : : }
1534 : :
1535 : 1344 : return(p-q);
1536 : : }
1537 : :
1538 : 1322 : STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
1539 : : STACK_OF(SSL_CIPHER) **skp)
1540 : : {
1541 : : const SSL_CIPHER *c;
1542 : : STACK_OF(SSL_CIPHER) *sk;
1543 : : int i,n;
1544 [ + + ]: 1322 : if (s->s3)
1545 : 1080 : s->s3->send_connection_binding = 0;
1546 : :
1547 : 1322 : n=ssl_put_cipher_by_char(s,NULL,NULL);
1548 [ - + ]: 1322 : if ((num%n) != 0)
1549 : : {
1550 : 0 : SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
1551 : 0 : return(NULL);
1552 : : }
1553 [ + - ][ + - ]: 1322 : if ((skp == NULL) || (*skp == NULL))
1554 : 1322 : sk=sk_SSL_CIPHER_new_null(); /* change perhaps later */
1555 : : else
1556 : : {
1557 : 0 : sk= *skp;
1558 : 0 : sk_SSL_CIPHER_zero(sk);
1559 : : }
1560 : :
1561 [ + + ]: 1322 : if (s->cert->ciphers_raw)
1562 : 319 : OPENSSL_free(s->cert->ciphers_raw);
1563 : 1322 : s->cert->ciphers_raw = BUF_memdup(p, num);
1564 [ - + ]: 1322 : if (s->cert->ciphers_raw == NULL)
1565 : : {
1566 : 0 : SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
1567 : 0 : goto err;
1568 : : }
1569 : 1322 : s->cert->ciphers_rawlen = (size_t)num;
1570 : :
1571 [ + + ]: 59032 : for (i=0; i<num; i+=n)
1572 : : {
1573 : : /* Check for SCSV */
1574 [ + + ][ - + ]: 57710 : if (s->s3 && (n != 3 || !p[0]) &&
[ # # ][ + + ]
1575 [ + + ]: 36832 : (p[n-2] == ((SSL3_CK_SCSV >> 8) & 0xff)) &&
1576 : 36832 : (p[n-1] == (SSL3_CK_SCSV & 0xff)))
1577 : : {
1578 : : /* SCSV fatal if renegotiating */
1579 [ - + ]: 1080 : if (s->renegotiate)
1580 : : {
1581 : 0 : SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
1582 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_HANDSHAKE_FAILURE);
1583 : 0 : goto err;
1584 : : }
1585 : 1080 : s->s3->send_connection_binding = 1;
1586 : 1080 : p += n;
1587 : : #ifdef OPENSSL_RI_DEBUG
1588 : : fprintf(stderr, "SCSV received by server\n");
1589 : : #endif
1590 : 1080 : continue;
1591 : : }
1592 : :
1593 : 56630 : c=ssl_get_cipher_by_char(s,p);
1594 : 56630 : p+=n;
1595 [ + - ]: 56630 : if (c != NULL)
1596 : : {
1597 [ - + ]: 56630 : if (!sk_SSL_CIPHER_push(sk,c))
1598 : : {
1599 : 0 : SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
1600 : 0 : goto err;
1601 : : }
1602 : : }
1603 : : }
1604 : :
1605 [ + - ]: 1322 : if (skp != NULL)
1606 : 1322 : *skp=sk;
1607 : 1322 : return(sk);
1608 : : err:
1609 [ # # ][ # # ]: 0 : if ((skp == NULL) || (*skp == NULL))
1610 : 0 : sk_SSL_CIPHER_free(sk);
1611 : : return(NULL);
1612 : : }
1613 : :
1614 : :
1615 : : #ifndef OPENSSL_NO_TLSEXT
1616 : : /** return a servername extension value if provided in Client Hello, or NULL.
1617 : : * So far, only host_name types are defined (RFC 3546).
1618 : : */
1619 : :
1620 : 0 : const char *SSL_get_servername(const SSL *s, const int type)
1621 : : {
1622 [ # # ]: 0 : if (type != TLSEXT_NAMETYPE_host_name)
1623 : : return NULL;
1624 : :
1625 [ # # ]: 0 : return s->session && !s->tlsext_hostname ?
1626 [ # # ]: 0 : s->session->tlsext_hostname :
1627 : : s->tlsext_hostname;
1628 : : }
1629 : :
1630 : 0 : int SSL_get_servername_type(const SSL *s)
1631 : : {
1632 [ # # ][ # # ]: 0 : if (s->session && (!s->tlsext_hostname ? s->session->tlsext_hostname : s->tlsext_hostname))
[ # # ]
1633 : : return TLSEXT_NAMETYPE_host_name;
1634 : 0 : return -1;
1635 : : }
1636 : :
1637 : : /* SSL_select_next_proto implements the standard protocol selection. It is
1638 : : * expected that this function is called from the callback set by
1639 : : * SSL_CTX_set_next_proto_select_cb.
1640 : : *
1641 : : * The protocol data is assumed to be a vector of 8-bit, length prefixed byte
1642 : : * strings. The length byte itself is not included in the length. A byte
1643 : : * string of length 0 is invalid. No byte string may be truncated.
1644 : : *
1645 : : * The current, but experimental algorithm for selecting the protocol is:
1646 : : *
1647 : : * 1) If the server doesn't support NPN then this is indicated to the
1648 : : * callback. In this case, the client application has to abort the connection
1649 : : * or have a default application level protocol.
1650 : : *
1651 : : * 2) If the server supports NPN, but advertises an empty list then the
1652 : : * client selects the first protcol in its list, but indicates via the
1653 : : * API that this fallback case was enacted.
1654 : : *
1655 : : * 3) Otherwise, the client finds the first protocol in the server's list
1656 : : * that it supports and selects this protocol. This is because it's
1657 : : * assumed that the server has better information about which protocol
1658 : : * a client should use.
1659 : : *
1660 : : * 4) If the client doesn't support any of the server's advertised
1661 : : * protocols, then this is treated the same as case 2.
1662 : : *
1663 : : * It returns either
1664 : : * OPENSSL_NPN_NEGOTIATED if a common protocol was found, or
1665 : : * OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
1666 : : */
1667 : 88 : 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)
1668 : : {
1669 : : unsigned int i, j;
1670 : : const unsigned char *result;
1671 : 88 : int status = OPENSSL_NPN_UNSUPPORTED;
1672 : :
1673 : : /* For each protocol in server preference order, see if we support it. */
1674 [ + + ]: 121 : for (i = 0; i < server_len; )
1675 : : {
1676 [ + + ]: 165 : for (j = 0; j < client_len; )
1677 : : {
1678 [ + - ][ + + ]: 132 : if (server[i] == client[j] &&
1679 : 132 : memcmp(&server[i+1], &client[j+1], server[i]) == 0)
1680 : : {
1681 : : /* We found a match */
1682 : : result = &server[i];
1683 : : status = OPENSSL_NPN_NEGOTIATED;
1684 : : goto found;
1685 : : }
1686 : 66 : j += client[j];
1687 : 66 : j++;
1688 : : }
1689 : 33 : i += server[i];
1690 : 33 : i++;
1691 : : }
1692 : :
1693 : : /* There's no overlap between our protocols and the server's list. */
1694 : : result = client;
1695 : : status = OPENSSL_NPN_NO_OVERLAP;
1696 : :
1697 : : found:
1698 : 88 : *out = (unsigned char *) result + 1;
1699 : 88 : *outlen = result[0];
1700 : 88 : return status;
1701 : : }
1702 : :
1703 : : # ifndef OPENSSL_NO_NEXTPROTONEG
1704 : : /* SSL_get0_next_proto_negotiated sets *data and *len to point to the client's
1705 : : * requested protocol for this connection and returns 0. If the client didn't
1706 : : * request any protocol, then *data is set to NULL.
1707 : : *
1708 : : * Note that the client can request any protocol it chooses. The value returned
1709 : : * from this function need not be a member of the list of supported protocols
1710 : : * provided by the callback.
1711 : : */
1712 : 2380 : void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data, unsigned *len)
1713 : : {
1714 : 2380 : *data = s->next_proto_negotiated;
1715 [ + + ]: 2380 : if (!*data) {
1716 : 2270 : *len = 0;
1717 : : } else {
1718 : 110 : *len = s->next_proto_negotiated_len;
1719 : : }
1720 : 2380 : }
1721 : :
1722 : : /* SSL_CTX_set_next_protos_advertised_cb sets a callback that is called when a
1723 : : * TLS server needs a list of supported protocols for Next Protocol
1724 : : * Negotiation. The returned list must be in wire format. The list is returned
1725 : : * by setting |out| to point to it and |outlen| to its length. This memory will
1726 : : * not be modified, but one should assume that the SSL* keeps a reference to
1727 : : * it.
1728 : : *
1729 : : * The callback should return SSL_TLSEXT_ERR_OK if it wishes to advertise. Otherwise, no
1730 : : * such extension will be included in the ServerHello. */
1731 : 66 : 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)
1732 : : {
1733 : 66 : ctx->next_protos_advertised_cb = cb;
1734 : 66 : ctx->next_protos_advertised_cb_arg = arg;
1735 : 66 : }
1736 : :
1737 : : /* SSL_CTX_set_next_proto_select_cb sets a callback that is called when a
1738 : : * client needs to select a protocol from the server's provided list. |out|
1739 : : * must be set to point to the selected protocol (which may be within |in|).
1740 : : * The length of the protocol name must be written into |outlen|. The server's
1741 : : * advertised protocols are provided in |in| and |inlen|. The callback can
1742 : : * assume that |in| is syntactically valid.
1743 : : *
1744 : : * The client must select a protocol. It is fatal to the connection if this
1745 : : * callback returns a value other than SSL_TLSEXT_ERR_OK.
1746 : : */
1747 : 55 : 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)
1748 : : {
1749 : 55 : ctx->next_proto_select_cb = cb;
1750 : 55 : ctx->next_proto_select_cb_arg = arg;
1751 : 55 : }
1752 : : # endif
1753 : :
1754 : 154 : int SSL_CTX_set_custom_cli_ext(SSL_CTX *ctx, unsigned short ext_type,
1755 : : custom_cli_ext_first_cb_fn fn1,
1756 : : custom_cli_ext_second_cb_fn fn2, void* arg)
1757 : : {
1758 : : size_t i;
1759 : : custom_cli_ext_record* record;
1760 : :
1761 : : /* Check for duplicates */
1762 [ + + ]: 396 : for (i=0; i < ctx->custom_cli_ext_records_count; i++)
1763 [ + - ]: 242 : if (ext_type == ctx->custom_cli_ext_records[i].ext_type)
1764 : : return 0;
1765 : :
1766 : 154 : ctx->custom_cli_ext_records = OPENSSL_realloc(ctx->custom_cli_ext_records,
1767 : : (ctx->custom_cli_ext_records_count + 1) *
1768 : : sizeof(custom_cli_ext_record));
1769 [ - + ]: 154 : if (!ctx->custom_cli_ext_records) {
1770 : 0 : ctx->custom_cli_ext_records_count = 0;
1771 : 0 : return 0;
1772 : : }
1773 : 154 : ctx->custom_cli_ext_records_count++;
1774 : 154 : record = &ctx->custom_cli_ext_records[ctx->custom_cli_ext_records_count - 1];
1775 : 154 : record->ext_type = ext_type;
1776 : 154 : record->fn1 = fn1;
1777 : 154 : record->fn2 = fn2;
1778 : 154 : record->arg = arg;
1779 : 154 : return 1;
1780 : : }
1781 : :
1782 : 198 : int SSL_CTX_set_custom_srv_ext(SSL_CTX *ctx, unsigned short ext_type,
1783 : : custom_srv_ext_first_cb_fn fn1,
1784 : : custom_srv_ext_second_cb_fn fn2, void* arg)
1785 : : {
1786 : : size_t i;
1787 : : custom_srv_ext_record* record;
1788 : :
1789 : : /* Check for duplicates */
1790 [ + + ]: 473 : for (i=0; i < ctx->custom_srv_ext_records_count; i++)
1791 [ + - ]: 275 : if (ext_type == ctx->custom_srv_ext_records[i].ext_type)
1792 : : return 0;
1793 : :
1794 : 198 : ctx->custom_srv_ext_records = OPENSSL_realloc(ctx->custom_srv_ext_records,
1795 : : (ctx->custom_srv_ext_records_count + 1) *
1796 : : sizeof(custom_srv_ext_record));
1797 [ - + ]: 198 : if (!ctx->custom_srv_ext_records) {
1798 : 0 : ctx->custom_srv_ext_records_count = 0;
1799 : 0 : return 0;
1800 : : }
1801 : 198 : ctx->custom_srv_ext_records_count++;
1802 : 198 : record = &ctx->custom_srv_ext_records[ctx->custom_srv_ext_records_count - 1];
1803 : 198 : record->ext_type = ext_type;
1804 : 198 : record->fn1 = fn1;
1805 : 198 : record->fn2 = fn2;
1806 : 198 : record->arg = arg;
1807 : 198 : return 1;
1808 : : }
1809 : :
1810 : : /* SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|.
1811 : : * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
1812 : : * length-prefixed strings).
1813 : : *
1814 : : * Returns 0 on success. */
1815 : 88 : int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char* protos,
1816 : : unsigned protos_len)
1817 : : {
1818 [ - + ]: 88 : if (ctx->alpn_client_proto_list)
1819 : 0 : OPENSSL_free(ctx->alpn_client_proto_list);
1820 : :
1821 : 88 : ctx->alpn_client_proto_list = OPENSSL_malloc(protos_len);
1822 [ + - ]: 88 : if (!ctx->alpn_client_proto_list)
1823 : : return 1;
1824 : 88 : memcpy(ctx->alpn_client_proto_list, protos, protos_len);
1825 : 88 : ctx->alpn_client_proto_list_len = protos_len;
1826 : :
1827 : 88 : return 0;
1828 : : }
1829 : :
1830 : : /* SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|.
1831 : : * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
1832 : : * length-prefixed strings).
1833 : : *
1834 : : * Returns 0 on success. */
1835 : 0 : int SSL_set_alpn_protos(SSL *ssl, const unsigned char* protos,
1836 : : unsigned protos_len)
1837 : : {
1838 [ # # ]: 0 : if (ssl->alpn_client_proto_list)
1839 : 0 : OPENSSL_free(ssl->alpn_client_proto_list);
1840 : :
1841 : 0 : ssl->alpn_client_proto_list = OPENSSL_malloc(protos_len);
1842 [ # # ]: 0 : if (!ssl->alpn_client_proto_list)
1843 : : return 1;
1844 : 0 : memcpy(ssl->alpn_client_proto_list, protos, protos_len);
1845 : 0 : ssl->alpn_client_proto_list_len = protos_len;
1846 : :
1847 : 0 : return 0;
1848 : : }
1849 : :
1850 : : /* SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is called
1851 : : * during ClientHello processing in order to select an ALPN protocol from the
1852 : : * client's list of offered protocols. */
1853 : 88 : void SSL_CTX_set_alpn_select_cb(SSL_CTX* ctx,
1854 : : int (*cb) (SSL *ssl,
1855 : : const unsigned char **out,
1856 : : unsigned char *outlen,
1857 : : const unsigned char *in,
1858 : : unsigned int inlen,
1859 : : void *arg),
1860 : : void *arg)
1861 : : {
1862 : 88 : ctx->alpn_select_cb = cb;
1863 : 88 : ctx->alpn_select_cb_arg = arg;
1864 : 88 : }
1865 : :
1866 : : /* SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from |ssl|.
1867 : : * On return it sets |*data| to point to |*len| bytes of protocol name (not
1868 : : * including the leading length-prefix byte). If the server didn't respond with
1869 : : * a negotiated protocol then |*len| will be zero. */
1870 : 1518 : void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
1871 : : unsigned *len)
1872 : : {
1873 : 1518 : *data = NULL;
1874 [ + + ]: 1518 : if (ssl->s3)
1875 : 1430 : *data = ssl->s3->alpn_selected;
1876 [ + + ]: 1518 : if (*data == NULL)
1877 : 1386 : *len = 0;
1878 : : else
1879 : 132 : *len = ssl->s3->alpn_selected_len;
1880 : 1518 : }
1881 : :
1882 : : #endif /* !OPENSSL_NO_TLSEXT */
1883 : :
1884 : 0 : int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
1885 : : const char *label, size_t llen, const unsigned char *p, size_t plen,
1886 : : int use_context)
1887 : : {
1888 [ # # ]: 0 : if (s->version < TLS1_VERSION)
1889 : : return -1;
1890 : :
1891 : 0 : return s->method->ssl3_enc->export_keying_material(s, out, olen, label,
1892 : : llen, p, plen,
1893 : : use_context);
1894 : : }
1895 : :
1896 : 2992 : static unsigned long ssl_session_hash(const SSL_SESSION *a)
1897 : : {
1898 : : unsigned long l;
1899 : :
1900 : 2992 : l=(unsigned long)
1901 : 2992 : ((unsigned int) a->session_id[0] )|
1902 : 2992 : ((unsigned int) a->session_id[1]<< 8L)|
1903 : 1496 : ((unsigned long)a->session_id[2]<<16L)|
1904 : 1496 : ((unsigned long)a->session_id[3]<<24L);
1905 : 1496 : return(l);
1906 : : }
1907 : :
1908 : : /* NB: If this function (or indeed the hash function which uses a sort of
1909 : : * coarser function than this one) is changed, ensure
1910 : : * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on being
1911 : : * able to construct an SSL_SESSION that will collide with any existing session
1912 : : * with a matching session ID. */
1913 : 363 : static int ssl_session_cmp(const SSL_SESSION *a,const SSL_SESSION *b)
1914 : : {
1915 [ + - ]: 363 : if (a->ssl_version != b->ssl_version)
1916 : : return(1);
1917 [ + - ]: 363 : if (a->session_id_length != b->session_id_length)
1918 : : return(1);
1919 : 363 : return(memcmp(a->session_id,b->session_id,a->session_id_length));
1920 : : }
1921 : :
1922 : : /* These wrapper functions should remain rather than redeclaring
1923 : : * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
1924 : : * variable. The reason is that the functions aren't static, they're exposed via
1925 : : * ssl.h. */
1926 : 2992 : static IMPLEMENT_LHASH_HASH_FN(ssl_session, SSL_SESSION)
1927 : 726 : static IMPLEMENT_LHASH_COMP_FN(ssl_session, SSL_SESSION)
1928 : :
1929 : 1808 : SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
1930 : : {
1931 : 1808 : SSL_CTX *ret=NULL;
1932 : :
1933 [ - + ]: 1808 : if (meth == NULL)
1934 : : {
1935 : 0 : SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_NULL_SSL_METHOD_PASSED);
1936 : 0 : return(NULL);
1937 : : }
1938 : :
1939 : : #ifdef OPENSSL_FIPS
1940 : : if (FIPS_mode() && (meth->version < TLS1_VERSION))
1941 : : {
1942 : : SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
1943 : : return NULL;
1944 : : }
1945 : : #endif
1946 : :
1947 [ - + ]: 1808 : if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0)
1948 : : {
1949 : 0 : SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
1950 : 0 : goto err;
1951 : : }
1952 : 1808 : ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
1953 [ + - ]: 1808 : if (ret == NULL)
1954 : : goto err;
1955 : :
1956 : : memset(ret,0,sizeof(SSL_CTX));
1957 : :
1958 : 1808 : ret->method=meth;
1959 : :
1960 : 1808 : ret->cert_store=NULL;
1961 : 1808 : ret->session_cache_mode=SSL_SESS_CACHE_SERVER;
1962 : 1808 : ret->session_cache_size=SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
1963 : 1808 : ret->session_cache_head=NULL;
1964 : 1808 : ret->session_cache_tail=NULL;
1965 : :
1966 : : /* We take the system default */
1967 : 1808 : ret->session_timeout=meth->get_timeout();
1968 : :
1969 : 1808 : ret->new_session_cb=0;
1970 : 1808 : ret->remove_session_cb=0;
1971 : 1808 : ret->get_session_cb=0;
1972 : 1808 : ret->generate_session_id=0;
1973 : :
1974 : 1808 : memset((char *)&ret->stats,0,sizeof(ret->stats));
1975 : :
1976 : 1808 : ret->references=1;
1977 : 1808 : ret->quiet_shutdown=0;
1978 : :
1979 : : /* ret->cipher=NULL;*/
1980 : : /* ret->s2->challenge=NULL;
1981 : : ret->master_key=NULL;
1982 : : ret->key_arg=NULL;
1983 : : ret->s2->conn_id=NULL; */
1984 : :
1985 : 1808 : ret->info_callback=NULL;
1986 : :
1987 : 1808 : ret->app_verify_callback=0;
1988 : 1808 : ret->app_verify_arg=NULL;
1989 : :
1990 : 1808 : ret->max_cert_list=SSL_MAX_CERT_LIST_DEFAULT;
1991 : 1808 : ret->read_ahead=0;
1992 : 1808 : ret->msg_callback=0;
1993 : 1808 : ret->msg_callback_arg=NULL;
1994 : 1808 : ret->verify_mode=SSL_VERIFY_NONE;
1995 : : #if 0
1996 : : ret->verify_depth=-1; /* Don't impose a limit (but x509_lu.c does) */
1997 : : #endif
1998 : 1808 : ret->sid_ctx_length=0;
1999 : 1808 : ret->default_verify_callback=NULL;
2000 [ + - ]: 1808 : if ((ret->cert=ssl_cert_new()) == NULL)
2001 : : goto err;
2002 : :
2003 : 1808 : ret->default_passwd_callback=0;
2004 : 1808 : ret->default_passwd_callback_userdata=NULL;
2005 : 1808 : ret->client_cert_cb=0;
2006 : 1808 : ret->app_gen_cookie_cb=0;
2007 : 1808 : ret->app_verify_cookie_cb=0;
2008 : :
2009 : 1808 : ret->sessions=lh_SSL_SESSION_new();
2010 [ + - ]: 1808 : if (ret->sessions == NULL) goto err;
2011 : 1808 : ret->cert_store=X509_STORE_new();
2012 [ + - ]: 1808 : if (ret->cert_store == NULL) goto err;
2013 : :
2014 [ + + ]: 1808 : ssl_create_cipher_list(ret->method,
2015 : : &ret->cipher_list,&ret->cipher_list_by_id,
2016 : 1808 : meth->version == SSL2_VERSION ? "SSLv2" : SSL_DEFAULT_CIPHER_LIST, ret->cert);
2017 [ + - ]: 1808 : if (ret->cipher_list == NULL
2018 [ - + ]: 1808 : || sk_SSL_CIPHER_num(ret->cipher_list) <= 0)
2019 : : {
2020 : 0 : SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_LIBRARY_HAS_NO_CIPHERS);
2021 : 0 : goto err2;
2022 : : }
2023 : :
2024 : 1808 : ret->param = X509_VERIFY_PARAM_new();
2025 [ + - ]: 1808 : if (!ret->param)
2026 : : goto err;
2027 : :
2028 [ - + ]: 1808 : if ((ret->rsa_md5=EVP_get_digestbyname("ssl2-md5")) == NULL)
2029 : : {
2030 : 0 : SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES);
2031 : 0 : goto err2;
2032 : : }
2033 [ - + ]: 1808 : if ((ret->md5=EVP_get_digestbyname("ssl3-md5")) == NULL)
2034 : : {
2035 : 0 : SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
2036 : 0 : goto err2;
2037 : : }
2038 [ - + ]: 1808 : if ((ret->sha1=EVP_get_digestbyname("ssl3-sha1")) == NULL)
2039 : : {
2040 : 0 : SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
2041 : 0 : goto err2;
2042 : : }
2043 : :
2044 [ + - ]: 1808 : if ((ret->client_CA=sk_X509_NAME_new_null()) == NULL)
2045 : : goto err;
2046 : :
2047 : 1808 : CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
2048 : :
2049 : 1808 : ret->extra_certs=NULL;
2050 : : /* No compression for DTLS */
2051 [ + - ]: 1808 : if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
2052 : 1808 : ret->comp_methods=SSL_COMP_get_compression_methods();
2053 : :
2054 : 1808 : ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
2055 : :
2056 : : #ifndef OPENSSL_NO_TLSEXT
2057 : 1808 : ret->tlsext_servername_callback = 0;
2058 : 1808 : ret->tlsext_servername_arg = NULL;
2059 : : /* Setup RFC4507 ticket keys */
2060 [ + - ]: 1808 : if ((RAND_pseudo_bytes(ret->tlsext_tick_key_name, 16) <= 0)
2061 [ + - ]: 1808 : || (RAND_bytes(ret->tlsext_tick_hmac_key, 16) <= 0)
2062 [ - + ]: 1808 : || (RAND_bytes(ret->tlsext_tick_aes_key, 16) <= 0))
2063 : 0 : ret->options |= SSL_OP_NO_TICKET;
2064 : :
2065 : 1808 : ret->tlsext_status_cb = 0;
2066 : 1808 : ret->tlsext_status_arg = NULL;
2067 : :
2068 : : # ifndef OPENSSL_NO_NEXTPROTONEG
2069 : 1808 : ret->next_protos_advertised_cb = 0;
2070 : 1808 : ret->next_proto_select_cb = 0;
2071 : : # endif
2072 : : #endif
2073 : : #ifndef OPENSSL_NO_PSK
2074 : 1808 : ret->psk_identity_hint=NULL;
2075 : 1808 : ret->psk_client_callback=NULL;
2076 : 1808 : ret->psk_server_callback=NULL;
2077 : : #endif
2078 : : #ifndef OPENSSL_NO_SRP
2079 : 1808 : SSL_CTX_SRP_CTX_init(ret);
2080 : : #endif
2081 : 1808 : ret->custom_cli_ext_records = NULL;
2082 : 1808 : ret->custom_cli_ext_records_count = 0;
2083 : 1808 : ret->custom_srv_ext_records = NULL;
2084 : 1808 : ret->custom_srv_ext_records_count = 0;
2085 : : #ifndef OPENSSL_NO_BUF_FREELISTS
2086 : 1808 : ret->freelist_max_len = SSL_MAX_BUF_FREELIST_LEN_DEFAULT;
2087 : 1808 : ret->rbuf_freelist = OPENSSL_malloc(sizeof(SSL3_BUF_FREELIST));
2088 [ + - ]: 1808 : if (!ret->rbuf_freelist)
2089 : : goto err;
2090 : 1808 : ret->rbuf_freelist->chunklen = 0;
2091 : 1808 : ret->rbuf_freelist->len = 0;
2092 : 1808 : ret->rbuf_freelist->head = NULL;
2093 : 1808 : ret->wbuf_freelist = OPENSSL_malloc(sizeof(SSL3_BUF_FREELIST));
2094 [ - + ]: 1808 : if (!ret->wbuf_freelist)
2095 : : {
2096 : 0 : OPENSSL_free(ret->rbuf_freelist);
2097 : 0 : goto err;
2098 : : }
2099 : 1808 : ret->wbuf_freelist->chunklen = 0;
2100 : 1808 : ret->wbuf_freelist->len = 0;
2101 : 1808 : ret->wbuf_freelist->head = NULL;
2102 : : #endif
2103 : : #ifndef OPENSSL_NO_ENGINE
2104 : 1808 : ret->client_cert_engine = NULL;
2105 : : #ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
2106 : : #define eng_strx(x) #x
2107 : : #define eng_str(x) eng_strx(x)
2108 : : /* Use specific client engine automatically... ignore errors */
2109 : : {
2110 : : ENGINE *eng;
2111 : : eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
2112 : : if (!eng)
2113 : : {
2114 : : ERR_clear_error();
2115 : : ENGINE_load_builtin_engines();
2116 : : eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
2117 : : }
2118 : : if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
2119 : : ERR_clear_error();
2120 : : }
2121 : : #endif
2122 : : #endif
2123 : : /* Default is to connect to non-RI servers. When RI is more widely
2124 : : * deployed might change this.
2125 : : */
2126 : 1808 : ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
2127 : :
2128 : 1808 : return(ret);
2129 : : err:
2130 : 0 : SSLerr(SSL_F_SSL_CTX_NEW,ERR_R_MALLOC_FAILURE);
2131 : : err2:
2132 [ # # ]: 0 : if (ret != NULL) SSL_CTX_free(ret);
2133 : : return(NULL);
2134 : : }
2135 : :
2136 : : #if 0
2137 : : static void SSL_COMP_free(SSL_COMP *comp)
2138 : : { OPENSSL_free(comp); }
2139 : : #endif
2140 : :
2141 : : #ifndef OPENSSL_NO_BUF_FREELISTS
2142 : : static void
2143 : 3616 : ssl_buf_freelist_free(SSL3_BUF_FREELIST *list)
2144 : : {
2145 : : SSL3_BUF_FREELIST_ENTRY *ent, *next;
2146 [ + + ]: 6660 : for (ent = list->head; ent; ent = next)
2147 : : {
2148 : 3044 : next = ent->next;
2149 : 3044 : OPENSSL_free(ent);
2150 : : }
2151 : 3616 : OPENSSL_free(list);
2152 : 3616 : }
2153 : : #endif
2154 : :
2155 : 5424 : void SSL_CTX_free(SSL_CTX *a)
2156 : : {
2157 : : int i;
2158 : :
2159 [ + - ]: 5424 : if (a == NULL) return;
2160 : :
2161 : 5424 : i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_SSL_CTX);
2162 : : #ifdef REF_PRINT
2163 : : REF_PRINT("SSL_CTX",a);
2164 : : #endif
2165 [ + + ]: 5424 : if (i > 0) return;
2166 : : #ifdef REF_CHECK
2167 : : if (i < 0)
2168 : : {
2169 : : fprintf(stderr,"SSL_CTX_free, bad reference count\n");
2170 : : abort(); /* ok */
2171 : : }
2172 : : #endif
2173 : :
2174 [ + - ]: 1808 : if (a->param)
2175 : 1808 : X509_VERIFY_PARAM_free(a->param);
2176 : :
2177 : : /*
2178 : : * Free internal session cache. However: the remove_cb() may reference
2179 : : * the ex_data of SSL_CTX, thus the ex_data store can only be removed
2180 : : * after the sessions were flushed.
2181 : : * As the ex_data handling routines might also touch the session cache,
2182 : : * the most secure solution seems to be: empty (flush) the cache, then
2183 : : * free ex_data, then finally free the cache.
2184 : : * (See ticket [openssl.org #212].)
2185 : : */
2186 [ + - ]: 1808 : if (a->sessions != NULL)
2187 : 1808 : SSL_CTX_flush_sessions(a,0);
2188 : :
2189 : 1808 : CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
2190 : :
2191 [ + - ]: 1808 : if (a->sessions != NULL)
2192 : 1808 : lh_SSL_SESSION_free(a->sessions);
2193 : :
2194 [ + - ]: 1808 : if (a->cert_store != NULL)
2195 : 1808 : X509_STORE_free(a->cert_store);
2196 [ + - ]: 1808 : if (a->cipher_list != NULL)
2197 : 1808 : sk_SSL_CIPHER_free(a->cipher_list);
2198 [ + - ]: 1808 : if (a->cipher_list_by_id != NULL)
2199 : 1808 : sk_SSL_CIPHER_free(a->cipher_list_by_id);
2200 [ + - ]: 1808 : if (a->cert != NULL)
2201 : 1808 : ssl_cert_free(a->cert);
2202 [ + - ]: 1808 : if (a->client_CA != NULL)
2203 : 1808 : sk_X509_NAME_pop_free(a->client_CA,X509_NAME_free);
2204 [ - + ]: 1808 : if (a->extra_certs != NULL)
2205 : 0 : sk_X509_pop_free(a->extra_certs,X509_free);
2206 : : #if 0 /* This should never be done, since it removes a global database */
2207 : : if (a->comp_methods != NULL)
2208 : : sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
2209 : : #else
2210 : 1808 : a->comp_methods = NULL;
2211 : : #endif
2212 : :
2213 [ - + ]: 1808 : if (a->srtp_profiles)
2214 : 0 : sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles);
2215 : :
2216 : : #ifndef OPENSSL_NO_PSK
2217 [ + + ]: 1808 : if (a->psk_identity_hint)
2218 : 44 : OPENSSL_free(a->psk_identity_hint);
2219 : : #endif
2220 : : #ifndef OPENSSL_NO_SRP
2221 : 1808 : SSL_CTX_SRP_CTX_free(a);
2222 : : #endif
2223 : : #ifndef OPENSSL_NO_TLSEXT
2224 : 1808 : OPENSSL_free(a->custom_cli_ext_records);
2225 : 1808 : OPENSSL_free(a->custom_srv_ext_records);
2226 : : #endif
2227 : : #ifndef OPENSSL_NO_ENGINE
2228 [ - + ]: 1808 : if (a->client_cert_engine)
2229 : 0 : ENGINE_finish(a->client_cert_engine);
2230 : : #endif
2231 : :
2232 : : #ifndef OPENSSL_NO_BUF_FREELISTS
2233 [ + - ]: 1808 : if (a->wbuf_freelist)
2234 : 1808 : ssl_buf_freelist_free(a->wbuf_freelist);
2235 [ + - ]: 1808 : if (a->rbuf_freelist)
2236 : 1808 : ssl_buf_freelist_free(a->rbuf_freelist);
2237 : : #endif
2238 : : #ifndef OPENSSL_NO_TLSEXT
2239 : : # ifndef OPENSSL_NO_EC
2240 [ - + ]: 1808 : if (a->tlsext_ecpointformatlist)
2241 : 0 : OPENSSL_free(a->tlsext_ecpointformatlist);
2242 [ - + ]: 1808 : if (a->tlsext_ellipticcurvelist)
2243 : 0 : OPENSSL_free(a->tlsext_ellipticcurvelist);
2244 : : # endif /* OPENSSL_NO_EC */
2245 [ + + ]: 1808 : if (a->alpn_client_proto_list != NULL)
2246 : 88 : OPENSSL_free(a->alpn_client_proto_list);
2247 : : #endif
2248 : :
2249 : 1808 : OPENSSL_free(a);
2250 : : }
2251 : :
2252 : 0 : void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
2253 : : {
2254 : 0 : ctx->default_passwd_callback=cb;
2255 : 0 : }
2256 : :
2257 : 0 : void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx,void *u)
2258 : : {
2259 : 0 : ctx->default_passwd_callback_userdata=u;
2260 : 0 : }
2261 : :
2262 : 308 : void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, int (*cb)(X509_STORE_CTX *,void *), void *arg)
2263 : : {
2264 : 308 : ctx->app_verify_callback=cb;
2265 : 308 : ctx->app_verify_arg=arg;
2266 : 308 : }
2267 : :
2268 : 330 : void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*cb)(int, X509_STORE_CTX *))
2269 : : {
2270 : 330 : ctx->verify_mode=mode;
2271 : 330 : ctx->default_verify_callback=cb;
2272 : 330 : }
2273 : :
2274 : 0 : void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth)
2275 : : {
2276 : 0 : X509_VERIFY_PARAM_set_depth(ctx->param, depth);
2277 : 0 : }
2278 : :
2279 : 0 : void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb)(SSL *ssl, void *arg), void *arg)
2280 : : {
2281 : 0 : ssl_cert_set_cert_cb(c->cert, cb, arg);
2282 : 0 : }
2283 : :
2284 : 0 : void SSL_set_cert_cb(SSL *s, int (*cb)(SSL *ssl, void *arg), void *arg)
2285 : : {
2286 : 0 : ssl_cert_set_cert_cb(s->cert, cb, arg);
2287 : 0 : }
2288 : :
2289 : 4503 : void ssl_set_cert_masks(CERT *c, const SSL_CIPHER *cipher)
2290 : : {
2291 : : CERT_PKEY *cpk;
2292 : : int rsa_enc,rsa_tmp,rsa_sign,dh_tmp,dh_rsa,dh_dsa,dsa_sign;
2293 : : int rsa_enc_export,dh_rsa_export,dh_dsa_export;
2294 : : int rsa_tmp_export,dh_tmp_export,kl;
2295 : : unsigned long mask_k,mask_a,emask_k,emask_a;
2296 : : #ifndef OPENSSL_NO_ECDSA
2297 : : int have_ecc_cert, ecdsa_ok, ecc_pkey_size;
2298 : : #endif
2299 : : #ifndef OPENSSL_NO_ECDH
2300 : : int have_ecdh_tmp, ecdh_ok;
2301 : : #endif
2302 : : #ifndef OPENSSL_NO_EC
2303 : 4503 : X509 *x = NULL;
2304 : 4503 : EVP_PKEY *ecc_pkey = NULL;
2305 : 4503 : int signature_nid = 0, pk_nid = 0, md_nid = 0;
2306 : : #endif
2307 [ + - ]: 4503 : if (c == NULL) return;
2308 : :
2309 [ + + ]: 4503 : kl=SSL_C_EXPORT_PKEYLENGTH(cipher);
2310 : :
2311 : : #ifndef OPENSSL_NO_RSA
2312 [ + - ][ - + ]: 4503 : rsa_tmp=(c->rsa_tmp != NULL || c->rsa_tmp_cb != NULL);
2313 [ - + ][ # # ]: 4503 : rsa_tmp_export=(c->rsa_tmp_cb != NULL ||
2314 [ # # ]: 0 : (rsa_tmp && RSA_size(c->rsa_tmp)*8 <= kl));
2315 : : #else
2316 : : rsa_tmp=rsa_tmp_export=0;
2317 : : #endif
2318 : : #ifndef OPENSSL_NO_DH
2319 [ + + ][ + - ]: 4503 : dh_tmp=(c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto);
[ + - ]
2320 [ + - ][ + - ]: 4503 : dh_tmp_export= !c->dh_tmp_auto && (c->dh_tmp_cb != NULL ||
[ + + ]
2321 [ + - ]: 2226 : (dh_tmp && DH_size(c->dh_tmp)*8 <= kl));
2322 : : #else
2323 : : dh_tmp=dh_tmp_export=0;
2324 : : #endif
2325 : :
2326 : : #ifndef OPENSSL_NO_ECDH
2327 [ + + ][ + - ]: 4503 : have_ecdh_tmp=(c->ecdh_tmp || c->ecdh_tmp_cb || c->ecdh_tmp_auto);
[ + - ]
2328 : : #endif
2329 : 4503 : cpk= &(c->pkeys[SSL_PKEY_RSA_ENC]);
2330 : 4503 : rsa_enc= cpk->valid_flags & CERT_PKEY_VALID;
2331 [ + - ][ + + ]: 4503 : rsa_enc_export=(rsa_enc && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
2332 : 4503 : cpk= &(c->pkeys[SSL_PKEY_RSA_SIGN]);
2333 : 4503 : rsa_sign= cpk->valid_flags & CERT_PKEY_SIGN;
2334 : 4503 : cpk= &(c->pkeys[SSL_PKEY_DSA_SIGN]);
2335 : 4503 : dsa_sign= cpk->valid_flags & CERT_PKEY_SIGN;
2336 : 4503 : cpk= &(c->pkeys[SSL_PKEY_DH_RSA]);
2337 : 4503 : dh_rsa= cpk->valid_flags & CERT_PKEY_VALID;
2338 [ - + ][ # # ]: 4503 : dh_rsa_export=(dh_rsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
2339 : 4503 : cpk= &(c->pkeys[SSL_PKEY_DH_DSA]);
2340 : : /* FIX THIS EAY EAY EAY */
2341 : 4503 : dh_dsa= cpk->valid_flags & CERT_PKEY_VALID;
2342 [ - + ][ # # ]: 4503 : dh_dsa_export=(dh_dsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
2343 : 4503 : cpk= &(c->pkeys[SSL_PKEY_ECC]);
2344 : : #ifndef OPENSSL_NO_EC
2345 : 4503 : have_ecc_cert= cpk->valid_flags & CERT_PKEY_VALID;
2346 : : #endif
2347 : 4503 : mask_k=0;
2348 : 4503 : mask_a=0;
2349 : 4503 : emask_k=0;
2350 : 4503 : emask_a=0;
2351 : :
2352 : :
2353 : :
2354 : : #ifdef CIPHER_DEBUG
2355 : : printf("rt=%d rte=%d dht=%d ecdht=%d re=%d ree=%d rs=%d ds=%d dhr=%d dhd=%d\n",
2356 : : rsa_tmp,rsa_tmp_export,dh_tmp,have_ecdh_tmp,
2357 : : rsa_enc,rsa_enc_export,rsa_sign,dsa_sign,dh_rsa,dh_dsa);
2358 : : #endif
2359 : :
2360 : 4503 : cpk = &(c->pkeys[SSL_PKEY_GOST01]);
2361 [ - + ][ # # ]: 4503 : if (cpk->x509 != NULL && cpk->privatekey !=NULL) {
2362 : 0 : mask_k |= SSL_kGOST;
2363 : 0 : mask_a |= SSL_aGOST01;
2364 : : }
2365 : 4503 : cpk = &(c->pkeys[SSL_PKEY_GOST94]);
2366 [ - + ][ # # ]: 4503 : if (cpk->x509 != NULL && cpk->privatekey !=NULL) {
2367 : 0 : mask_k |= SSL_kGOST;
2368 : 0 : mask_a |= SSL_aGOST94;
2369 : : }
2370 : :
2371 [ - + ][ # # ]: 4503 : if (rsa_enc || (rsa_tmp && rsa_sign))
2372 : 4503 : mask_k|=SSL_kRSA;
2373 [ + + ][ + - ]: 4503 : if (rsa_enc_export || (rsa_tmp_export && (rsa_sign || rsa_enc)))
[ + - ]
2374 : 4503 : emask_k|=SSL_kRSA;
2375 : :
2376 : : #if 0
2377 : : /* The match needs to be both kDHE and aRSA or aDSA, so don't worry */
2378 : : if ( (dh_tmp || dh_rsa || dh_dsa) &&
2379 : : (rsa_enc || rsa_sign || dsa_sign))
2380 : : mask_k|=SSL_kDHE;
2381 : : if ((dh_tmp_export || dh_rsa_export || dh_dsa_export) &&
2382 : : (rsa_enc || rsa_sign || dsa_sign))
2383 : : emask_k|=SSL_kDHE;
2384 : : #endif
2385 : :
2386 [ + + ]: 4503 : if (dh_tmp_export)
2387 : 2226 : emask_k|=SSL_kDHE;
2388 : :
2389 [ + + ]: 4503 : if (dh_tmp)
2390 : 2226 : mask_k|=SSL_kDHE;
2391 : :
2392 [ - + ]: 4503 : if (dh_rsa) mask_k|=SSL_kDHr;
2393 [ - + ]: 4503 : if (dh_rsa_export) emask_k|=SSL_kDHr;
2394 : :
2395 [ - + ]: 4503 : if (dh_dsa) mask_k|=SSL_kDHd;
2396 [ - + ]: 4503 : if (dh_dsa_export) emask_k|=SSL_kDHd;
2397 : :
2398 [ - + ]: 4503 : if (emask_k & (SSL_kDHr|SSL_kDHd))
2399 : 0 : mask_a |= SSL_aDH;
2400 : :
2401 [ + - ]: 4503 : if (rsa_enc || rsa_sign)
2402 : : {
2403 : 4503 : mask_a|=SSL_aRSA;
2404 : 4503 : emask_a|=SSL_aRSA;
2405 : : }
2406 : :
2407 [ - + ]: 4503 : if (dsa_sign)
2408 : : {
2409 : 0 : mask_a|=SSL_aDSS;
2410 : 0 : emask_a|=SSL_aDSS;
2411 : : }
2412 : :
2413 : 4503 : mask_a|=SSL_aNULL;
2414 : 4503 : emask_a|=SSL_aNULL;
2415 : :
2416 : : #ifndef OPENSSL_NO_KRB5
2417 : : mask_k|=SSL_kKRB5;
2418 : : mask_a|=SSL_aKRB5;
2419 : : emask_k|=SSL_kKRB5;
2420 : : emask_a|=SSL_aKRB5;
2421 : : #endif
2422 : :
2423 : : /* An ECC certificate may be usable for ECDH and/or
2424 : : * ECDSA cipher suites depending on the key usage extension.
2425 : : */
2426 : : #ifndef OPENSSL_NO_EC
2427 [ - + ]: 4503 : if (have_ecc_cert)
2428 : : {
2429 : 0 : cpk = &c->pkeys[SSL_PKEY_ECC];
2430 : 0 : x = cpk->x509;
2431 : : /* This call populates extension flags (ex_flags) */
2432 : 0 : X509_check_purpose(x, -1, 0);
2433 [ # # ]: 0 : ecdh_ok = (x->ex_flags & EXFLAG_KUSAGE) ?
2434 : 0 : (x->ex_kusage & X509v3_KU_KEY_AGREEMENT) : 1;
2435 [ # # ]: 0 : ecdsa_ok = (x->ex_flags & EXFLAG_KUSAGE) ?
2436 : 0 : (x->ex_kusage & X509v3_KU_DIGITAL_SIGNATURE) : 1;
2437 [ # # ]: 0 : if (!(cpk->valid_flags & CERT_PKEY_SIGN))
2438 : 0 : ecdsa_ok = 0;
2439 : 0 : ecc_pkey = X509_get_pubkey(x);
2440 : 0 : ecc_pkey_size = (ecc_pkey != NULL) ?
2441 [ # # ]: 0 : EVP_PKEY_bits(ecc_pkey) : 0;
2442 : 0 : EVP_PKEY_free(ecc_pkey);
2443 [ # # ][ # # ]: 0 : if ((x->sig_alg) && (x->sig_alg->algorithm))
2444 : : {
2445 : 0 : signature_nid = OBJ_obj2nid(x->sig_alg->algorithm);
2446 : 0 : OBJ_find_sigid_algs(signature_nid, &md_nid, &pk_nid);
2447 : : }
2448 : : #ifndef OPENSSL_NO_ECDH
2449 [ # # ]: 0 : if (ecdh_ok)
2450 : : {
2451 : :
2452 [ # # ]: 0 : if (pk_nid == NID_rsaEncryption || pk_nid == NID_rsa)
2453 : : {
2454 : 0 : mask_k|=SSL_kECDHr;
2455 : 0 : mask_a|=SSL_aECDH;
2456 [ # # ]: 0 : if (ecc_pkey_size <= 163)
2457 : : {
2458 : 0 : emask_k|=SSL_kECDHr;
2459 : 0 : emask_a|=SSL_aECDH;
2460 : : }
2461 : : }
2462 : :
2463 [ # # ]: 0 : if (pk_nid == NID_X9_62_id_ecPublicKey)
2464 : : {
2465 : 0 : mask_k|=SSL_kECDHe;
2466 : 0 : mask_a|=SSL_aECDH;
2467 [ # # ]: 0 : if (ecc_pkey_size <= 163)
2468 : : {
2469 : 0 : emask_k|=SSL_kECDHe;
2470 : 0 : emask_a|=SSL_aECDH;
2471 : : }
2472 : : }
2473 : : }
2474 : : #endif
2475 : : #ifndef OPENSSL_NO_ECDSA
2476 [ # # ]: 0 : if (ecdsa_ok)
2477 : : {
2478 : 0 : mask_a|=SSL_aECDSA;
2479 : 0 : emask_a|=SSL_aECDSA;
2480 : : }
2481 : : #endif
2482 : : }
2483 : : #endif
2484 : :
2485 : : #ifndef OPENSSL_NO_ECDH
2486 [ + + ]: 4503 : if (have_ecdh_tmp)
2487 : : {
2488 : 2226 : mask_k|=SSL_kECDHE;
2489 : 2226 : emask_k|=SSL_kECDHE;
2490 : : }
2491 : : #endif
2492 : :
2493 : : #ifndef OPENSSL_NO_PSK
2494 : 4503 : mask_k |= SSL_kPSK;
2495 : 4503 : mask_a |= SSL_aPSK;
2496 : 4503 : emask_k |= SSL_kPSK;
2497 : 4503 : emask_a |= SSL_aPSK;
2498 : : #endif
2499 : :
2500 : 4503 : c->mask_k=mask_k;
2501 : 4503 : c->mask_a=mask_a;
2502 : 4503 : c->export_mask_k=emask_k;
2503 : 4503 : c->export_mask_a=emask_a;
2504 : 4503 : c->valid=1;
2505 : : }
2506 : :
2507 : : /* This handy macro borrowed from crypto/x509v3/v3_purp.c */
2508 : : #define ku_reject(x, usage) \
2509 : : (((x)->ex_flags & EXFLAG_KUSAGE) && !((x)->ex_kusage & (usage)))
2510 : :
2511 : : #ifndef OPENSSL_NO_EC
2512 : :
2513 : 0 : int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
2514 : : {
2515 : : unsigned long alg_k, alg_a;
2516 : 0 : EVP_PKEY *pkey = NULL;
2517 : 0 : int keysize = 0;
2518 : 0 : int signature_nid = 0, md_nid = 0, pk_nid = 0;
2519 : 0 : const SSL_CIPHER *cs = s->s3->tmp.new_cipher;
2520 : :
2521 : 0 : alg_k = cs->algorithm_mkey;
2522 : 0 : alg_a = cs->algorithm_auth;
2523 : :
2524 [ # # ]: 0 : if (SSL_C_IS_EXPORT(cs))
2525 : : {
2526 : : /* ECDH key length in export ciphers must be <= 163 bits */
2527 : 0 : pkey = X509_get_pubkey(x);
2528 [ # # ]: 0 : if (pkey == NULL) return 0;
2529 : 0 : keysize = EVP_PKEY_bits(pkey);
2530 : 0 : EVP_PKEY_free(pkey);
2531 [ # # ]: 0 : if (keysize > 163) return 0;
2532 : : }
2533 : :
2534 : : /* This call populates the ex_flags field correctly */
2535 : 0 : X509_check_purpose(x, -1, 0);
2536 [ # # ][ # # ]: 0 : if ((x->sig_alg) && (x->sig_alg->algorithm))
2537 : : {
2538 : 0 : signature_nid = OBJ_obj2nid(x->sig_alg->algorithm);
2539 : 0 : OBJ_find_sigid_algs(signature_nid, &md_nid, &pk_nid);
2540 : : }
2541 [ # # ]: 0 : if (alg_k & SSL_kECDHe || alg_k & SSL_kECDHr)
2542 : : {
2543 : : /* key usage, if present, must allow key agreement */
2544 [ # # ][ # # ]: 0 : if (ku_reject(x, X509v3_KU_KEY_AGREEMENT))
2545 : : {
2546 : 0 : SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT);
2547 : 0 : return 0;
2548 : : }
2549 [ # # ][ # # ]: 0 : if ((alg_k & SSL_kECDHe) && TLS1_get_version(s) < TLS1_2_VERSION)
[ # # ]
2550 : : {
2551 : : /* signature alg must be ECDSA */
2552 [ # # ]: 0 : if (pk_nid != NID_X9_62_id_ecPublicKey)
2553 : : {
2554 : 0 : SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE);
2555 : 0 : return 0;
2556 : : }
2557 : : }
2558 [ # # ][ # # ]: 0 : if ((alg_k & SSL_kECDHr) && TLS1_get_version(s) < TLS1_2_VERSION)
[ # # ]
2559 : : {
2560 : : /* signature alg must be RSA */
2561 : :
2562 [ # # ]: 0 : if (pk_nid != NID_rsaEncryption && pk_nid != NID_rsa)
2563 : : {
2564 : 0 : SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE);
2565 : 0 : return 0;
2566 : : }
2567 : : }
2568 : : }
2569 [ # # ]: 0 : if (alg_a & SSL_aECDSA)
2570 : : {
2571 : : /* key usage, if present, must allow signing */
2572 [ # # ][ # # ]: 0 : if (ku_reject(x, X509v3_KU_DIGITAL_SIGNATURE))
2573 : : {
2574 : 0 : SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_NOT_FOR_SIGNING);
2575 : 0 : return 0;
2576 : : }
2577 : : }
2578 : :
2579 : : return 1; /* all checks are ok */
2580 : : }
2581 : :
2582 : : #endif
2583 : :
2584 : 2006 : static int ssl_get_server_cert_index(const SSL *s)
2585 : : {
2586 : : int idx;
2587 : 1003 : idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
2588 [ + - ][ - + ]: 1003 : if (idx == SSL_PKEY_RSA_ENC && !s->cert->pkeys[SSL_PKEY_RSA_ENC].x509)
2589 : 0 : idx = SSL_PKEY_RSA_SIGN;
2590 [ - + ]: 1003 : if (idx == -1)
2591 : 0 : SSLerr(SSL_F_SSL_GET_SERVER_CERT_INDEX,ERR_R_INTERNAL_ERROR);
2592 : 1003 : return idx;
2593 : : }
2594 : :
2595 : 937 : CERT_PKEY *ssl_get_server_send_pkey(const SSL *s)
2596 : : {
2597 : : CERT *c;
2598 : : int i;
2599 : :
2600 : 937 : c = s->cert;
2601 [ + - ][ + - ]: 937 : if (!s->s3 || !s->s3->tmp.new_cipher)
2602 : : return NULL;
2603 : 937 : ssl_set_cert_masks(c, s->s3->tmp.new_cipher);
2604 : :
2605 : : #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
2606 : : /* Broken protocol test: return last used certificate: which may
2607 : : * mismatch the one expected.
2608 : : */
2609 : : if (c->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
2610 : : return c->key;
2611 : : #endif
2612 : :
2613 : 937 : i = ssl_get_server_cert_index(s);
2614 : :
2615 : : /* This may or may not be an error. */
2616 [ + - ]: 937 : if (i < 0)
2617 : : return NULL;
2618 : :
2619 : : /* May be NULL. */
2620 : 937 : return &c->pkeys[i];
2621 : : }
2622 : :
2623 : 605 : EVP_PKEY *ssl_get_sign_pkey(SSL *s,const SSL_CIPHER *cipher, const EVP_MD **pmd)
2624 : : {
2625 : : unsigned long alg_a;
2626 : : CERT *c;
2627 : 605 : int idx = -1;
2628 : :
2629 : 605 : alg_a = cipher->algorithm_auth;
2630 : 605 : c=s->cert;
2631 : :
2632 : : #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
2633 : : /* Broken protocol test: use last key: which may
2634 : : * mismatch the one expected.
2635 : : */
2636 : : if (c->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
2637 : : idx = c->key - c->pkeys;
2638 : : else
2639 : : #endif
2640 : :
2641 [ - + ][ # # ]: 605 : if ((alg_a & SSL_aDSS) &&
2642 : 0 : (c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
2643 : : idx = SSL_PKEY_DSA_SIGN;
2644 [ + - ]: 605 : else if (alg_a & SSL_aRSA)
2645 : : {
2646 [ + - ]: 605 : if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
2647 : : idx = SSL_PKEY_RSA_SIGN;
2648 [ + - ]: 605 : else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
2649 : 605 : idx = SSL_PKEY_RSA_ENC;
2650 : : }
2651 [ # # ][ # # ]: 0 : else if ((alg_a & SSL_aECDSA) &&
2652 : 0 : (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
2653 : 0 : idx = SSL_PKEY_ECC;
2654 [ - + ]: 605 : if (idx == -1)
2655 : : {
2656 : 0 : SSLerr(SSL_F_SSL_GET_SIGN_PKEY,ERR_R_INTERNAL_ERROR);
2657 : 0 : return(NULL);
2658 : : }
2659 [ + - ]: 605 : if (pmd)
2660 : 605 : *pmd = c->pkeys[idx].digest;
2661 : 605 : return c->pkeys[idx].privatekey;
2662 : : }
2663 : :
2664 : : #ifndef OPENSSL_NO_TLSEXT
2665 : 66 : int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
2666 : : size_t *serverinfo_length)
2667 : : {
2668 : 66 : CERT *c = NULL;
2669 : 66 : int i = 0;
2670 : 66 : *serverinfo_length = 0;
2671 : :
2672 : 66 : c = s->cert;
2673 : 66 : i = ssl_get_server_cert_index(s);
2674 : :
2675 [ + - ]: 66 : if (i == -1)
2676 : : return 0;
2677 [ + - ]: 66 : if (c->pkeys[i].serverinfo == NULL)
2678 : : return 0;
2679 : :
2680 : 66 : *serverinfo = c->pkeys[i].serverinfo;
2681 : 66 : *serverinfo_length = c->pkeys[i].serverinfo_length;
2682 : 66 : return 1;
2683 : : }
2684 : : #endif
2685 : :
2686 : 2380 : void ssl_update_cache(SSL *s,int mode)
2687 : : {
2688 : : int i;
2689 : :
2690 : : /* If the session_id_length is 0, we are not supposed to cache it,
2691 : : * and it would be rather hard to do anyway :-) */
2692 [ + + ]: 2380 : if (s->session->session_id_length == 0) return;
2693 : :
2694 : 1564 : i=s->session_ctx->session_cache_mode;
2695 [ + + ][ + + ]: 1564 : if ((i & mode) && (!s->hit)
2696 [ + - ]: 363 : && ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
2697 [ + - ]: 363 : || SSL_CTX_add_session(s->session_ctx,s->session))
2698 [ - + ]: 363 : && (s->session_ctx->new_session_cb != NULL))
2699 : : {
2700 : 0 : CRYPTO_add(&s->session->references,1,CRYPTO_LOCK_SSL_SESSION);
2701 [ # # ]: 0 : if (!s->session_ctx->new_session_cb(s,s->session))
2702 : 0 : SSL_SESSION_free(s->session);
2703 : : }
2704 : :
2705 : : /* auto flush every 255 connections */
2706 [ + - ][ + + ]: 1564 : if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) &&
2707 : : ((i & mode) == mode))
2708 : : {
2709 [ - + ]: 374 : if ( (((mode & SSL_SESS_CACHE_CLIENT)
2710 : 0 : ?s->session_ctx->stats.sess_connect_good
2711 [ - + ]: 374 : :s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff)
2712 : : {
2713 : 0 : SSL_CTX_flush_sessions(s->session_ctx,(unsigned long)time(NULL));
2714 : : }
2715 : : }
2716 : : }
2717 : :
2718 : 0 : const SSL_METHOD *SSL_CTX_get_ssl_method(SSL_CTX *ctx)
2719 : : {
2720 : 0 : return ctx->method;
2721 : : }
2722 : :
2723 : 0 : const SSL_METHOD *SSL_get_ssl_method(SSL *s)
2724 : : {
2725 : 0 : return(s->method);
2726 : : }
2727 : :
2728 : 0 : int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
2729 : : {
2730 : 0 : int conn= -1;
2731 : 0 : int ret=1;
2732 : :
2733 [ # # ]: 0 : if (s->method != meth)
2734 : : {
2735 [ # # ]: 0 : if (s->handshake_func != NULL)
2736 : 0 : conn=(s->handshake_func == s->method->ssl_connect);
2737 : :
2738 [ # # ]: 0 : if (s->method->version == meth->version)
2739 : 0 : s->method=meth;
2740 : : else
2741 : : {
2742 : 0 : s->method->ssl_free(s);
2743 : 0 : s->method=meth;
2744 : 0 : ret=s->method->ssl_new(s);
2745 : : }
2746 : :
2747 [ # # ]: 0 : if (conn == 1)
2748 : 0 : s->handshake_func=meth->ssl_connect;
2749 [ # # ]: 0 : else if (conn == 0)
2750 : 0 : s->handshake_func=meth->ssl_accept;
2751 : : }
2752 : 0 : return(ret);
2753 : : }
2754 : :
2755 : 101247 : int SSL_get_error(const SSL *s,int i)
2756 : : {
2757 : : int reason;
2758 : : unsigned long l;
2759 : : BIO *bio;
2760 : :
2761 [ + + ]: 101247 : if (i > 0) return(SSL_ERROR_NONE);
2762 : :
2763 : : /* Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake
2764 : : * etc, where we do encode the error */
2765 [ + + ]: 86883 : if ((l=ERR_peek_error()) != 0)
2766 : : {
2767 [ + - ]: 22 : if (ERR_GET_LIB(l) == ERR_LIB_SYS)
2768 : : return(SSL_ERROR_SYSCALL);
2769 : : else
2770 : 22 : return(SSL_ERROR_SSL);
2771 : : }
2772 : :
2773 [ + - ][ + + ]: 86861 : if ((i < 0) && SSL_want_read(s))
2774 : : {
2775 : 68389 : bio=SSL_get_rbio(s);
2776 [ - + ]: 68389 : if (BIO_should_read(bio))
2777 : : return(SSL_ERROR_WANT_READ);
2778 [ # # ]: 0 : else if (BIO_should_write(bio))
2779 : : /* This one doesn't make too much sense ... We never try
2780 : : * to write to the rbio, and an application program where
2781 : : * rbio and wbio are separate couldn't even know what it
2782 : : * should wait for.
2783 : : * However if we ever set s->rwstate incorrectly
2784 : : * (so that we have SSL_want_read(s) instead of
2785 : : * SSL_want_write(s)) and rbio and wbio *are* the same,
2786 : : * this test works around that bug; so it might be safer
2787 : : * to keep it. */
2788 : : return(SSL_ERROR_WANT_WRITE);
2789 [ # # ]: 0 : else if (BIO_should_io_special(bio))
2790 : : {
2791 : 0 : reason=BIO_get_retry_reason(bio);
2792 [ # # ]: 0 : if (reason == BIO_RR_CONNECT)
2793 : : return(SSL_ERROR_WANT_CONNECT);
2794 [ # # ]: 0 : else if (reason == BIO_RR_ACCEPT)
2795 : : return(SSL_ERROR_WANT_ACCEPT);
2796 : : else
2797 : 0 : return(SSL_ERROR_SYSCALL); /* unknown */
2798 : : }
2799 : : }
2800 : :
2801 [ + - ][ + - ]: 18472 : if ((i < 0) && SSL_want_write(s))
2802 : : {
2803 : 18472 : bio=SSL_get_wbio(s);
2804 [ - + ]: 18472 : if (BIO_should_write(bio))
2805 : : return(SSL_ERROR_WANT_WRITE);
2806 [ # # ]: 0 : else if (BIO_should_read(bio))
2807 : : /* See above (SSL_want_read(s) with BIO_should_write(bio)) */
2808 : : return(SSL_ERROR_WANT_READ);
2809 [ # # ]: 0 : else if (BIO_should_io_special(bio))
2810 : : {
2811 : 0 : reason=BIO_get_retry_reason(bio);
2812 [ # # ]: 0 : if (reason == BIO_RR_CONNECT)
2813 : : return(SSL_ERROR_WANT_CONNECT);
2814 [ # # ]: 0 : else if (reason == BIO_RR_ACCEPT)
2815 : : return(SSL_ERROR_WANT_ACCEPT);
2816 : : else
2817 : 0 : return(SSL_ERROR_SYSCALL);
2818 : : }
2819 : : }
2820 [ # # ][ # # ]: 0 : if ((i < 0) && SSL_want_x509_lookup(s))
2821 : : {
2822 : : return(SSL_ERROR_WANT_X509_LOOKUP);
2823 : : }
2824 : :
2825 [ # # ]: 0 : if (i == 0)
2826 : : {
2827 [ # # ]: 0 : if (s->version == SSL2_VERSION)
2828 : : {
2829 : : /* assume it is the socket being closed */
2830 : : return(SSL_ERROR_ZERO_RETURN);
2831 : : }
2832 : : else
2833 : : {
2834 [ # # ][ # # ]: 0 : if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2835 : 0 : (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
2836 : : return(SSL_ERROR_ZERO_RETURN);
2837 : : }
2838 : : }
2839 : 0 : return(SSL_ERROR_SYSCALL);
2840 : : }
2841 : :
2842 : 0 : int SSL_do_handshake(SSL *s)
2843 : : {
2844 : 0 : int ret=1;
2845 : :
2846 [ # # ]: 0 : if (s->handshake_func == NULL)
2847 : : {
2848 : 0 : SSLerr(SSL_F_SSL_DO_HANDSHAKE,SSL_R_CONNECTION_TYPE_NOT_SET);
2849 : 0 : return(-1);
2850 : : }
2851 : :
2852 : 0 : s->method->ssl_renegotiate_check(s);
2853 : :
2854 [ # # ][ # # ]: 0 : if (SSL_in_init(s) || SSL_in_before(s))
2855 : : {
2856 : 0 : ret=s->handshake_func(s);
2857 : : }
2858 : 0 : return(ret);
2859 : : }
2860 : :
2861 : : /* For the next 2 functions, SSL_clear() sets shutdown and so
2862 : : * one of these calls will reset it */
2863 : 1212 : void SSL_set_accept_state(SSL *s)
2864 : : {
2865 : 1212 : s->server=1;
2866 : 1212 : s->shutdown=0;
2867 : 1212 : s->state=SSL_ST_ACCEPT|SSL_ST_BEFORE;
2868 : 1212 : s->handshake_func=s->method->ssl_accept;
2869 : : /* clear the current cipher */
2870 : 1212 : ssl_clear_cipher_ctx(s);
2871 : 1212 : ssl_clear_hash_ctx(&s->read_hash);
2872 : 1212 : ssl_clear_hash_ctx(&s->write_hash);
2873 : 1212 : }
2874 : :
2875 : 1212 : void SSL_set_connect_state(SSL *s)
2876 : : {
2877 : 1212 : s->server=0;
2878 : 1212 : s->shutdown=0;
2879 : 1212 : s->state=SSL_ST_CONNECT|SSL_ST_BEFORE;
2880 : 1212 : s->handshake_func=s->method->ssl_connect;
2881 : : /* clear the current cipher */
2882 : 1212 : ssl_clear_cipher_ctx(s);
2883 : 1212 : ssl_clear_hash_ctx(&s->read_hash);
2884 : 1212 : ssl_clear_hash_ctx(&s->write_hash);
2885 : 1212 : }
2886 : :
2887 : 0 : int ssl_undefined_function(SSL *s)
2888 : : {
2889 : 0 : SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2890 : 0 : return(0);
2891 : : }
2892 : :
2893 : 0 : int ssl_undefined_void_function(void)
2894 : : {
2895 : 0 : SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2896 : 0 : return(0);
2897 : : }
2898 : :
2899 : 670 : int ssl_undefined_const_function(const SSL *s)
2900 : : {
2901 : 670 : SSLerr(SSL_F_SSL_UNDEFINED_CONST_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2902 : 670 : return(0);
2903 : : }
2904 : :
2905 : 0 : SSL_METHOD *ssl_bad_method(int ver)
2906 : : {
2907 : 0 : SSLerr(SSL_F_SSL_BAD_METHOD,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2908 : 0 : return(NULL);
2909 : : }
2910 : :
2911 : 1190 : const char *SSL_get_version(const SSL *s)
2912 : : {
2913 [ + + ]: 1190 : if (s->version == TLS1_2_VERSION)
2914 : : return("TLSv1.2");
2915 [ + - ]: 990 : else if (s->version == TLS1_1_VERSION)
2916 : : return("TLSv1.1");
2917 [ + + ]: 990 : else if (s->version == TLS1_VERSION)
2918 : : return("TLSv1");
2919 [ + + ]: 385 : else if (s->version == SSL3_VERSION)
2920 : : return("SSLv3");
2921 [ - + ]: 132 : else if (s->version == SSL2_VERSION)
2922 : : return("SSLv2");
2923 : : else
2924 : 0 : return("unknown");
2925 : : }
2926 : :
2927 : 0 : SSL *SSL_dup(SSL *s)
2928 : : {
2929 : : STACK_OF(X509_NAME) *sk;
2930 : : X509_NAME *xn;
2931 : : SSL *ret;
2932 : : int i;
2933 : :
2934 [ # # ]: 0 : if ((ret=SSL_new(SSL_get_SSL_CTX(s))) == NULL)
2935 : : return(NULL);
2936 : :
2937 : 0 : ret->version = s->version;
2938 : 0 : ret->type = s->type;
2939 : 0 : ret->method = s->method;
2940 : :
2941 [ # # ]: 0 : if (s->session != NULL)
2942 : : {
2943 : : /* This copies session-id, SSL_METHOD, sid_ctx, and 'cert' */
2944 : 0 : SSL_copy_session_id(ret,s);
2945 : : }
2946 : : else
2947 : : {
2948 : : /* No session has been established yet, so we have to expect
2949 : : * that s->cert or ret->cert will be changed later --
2950 : : * they should not both point to the same object,
2951 : : * and thus we can't use SSL_copy_session_id. */
2952 : :
2953 : 0 : ret->method->ssl_free(ret);
2954 : 0 : ret->method = s->method;
2955 : 0 : ret->method->ssl_new(ret);
2956 : :
2957 [ # # ]: 0 : if (s->cert != NULL)
2958 : : {
2959 [ # # ]: 0 : if (ret->cert != NULL)
2960 : : {
2961 : 0 : ssl_cert_free(ret->cert);
2962 : : }
2963 : 0 : ret->cert = ssl_cert_dup(s->cert);
2964 [ # # ]: 0 : if (ret->cert == NULL)
2965 : : goto err;
2966 : : }
2967 : :
2968 : 0 : SSL_set_session_id_context(ret,
2969 : 0 : s->sid_ctx, s->sid_ctx_length);
2970 : : }
2971 : :
2972 : 0 : ret->options=s->options;
2973 : 0 : ret->mode=s->mode;
2974 : 0 : SSL_set_max_cert_list(ret,SSL_get_max_cert_list(s));
2975 : 0 : SSL_set_read_ahead(ret,SSL_get_read_ahead(s));
2976 : 0 : ret->msg_callback = s->msg_callback;
2977 : 0 : ret->msg_callback_arg = s->msg_callback_arg;
2978 : 0 : SSL_set_verify(ret,SSL_get_verify_mode(s),
2979 : : SSL_get_verify_callback(s));
2980 : 0 : SSL_set_verify_depth(ret,SSL_get_verify_depth(s));
2981 : 0 : ret->generate_session_id = s->generate_session_id;
2982 : :
2983 : 0 : SSL_set_info_callback(ret,SSL_get_info_callback(s));
2984 : :
2985 : 0 : ret->debug=s->debug;
2986 : :
2987 : : /* copy app data, a little dangerous perhaps */
2988 [ # # ]: 0 : if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
2989 : : goto err;
2990 : :
2991 : : /* setup rbio, and wbio */
2992 [ # # ]: 0 : if (s->rbio != NULL)
2993 : : {
2994 [ # # ]: 0 : if (!BIO_dup_state(s->rbio,(char *)&ret->rbio))
2995 : : goto err;
2996 : : }
2997 [ # # ]: 0 : if (s->wbio != NULL)
2998 : : {
2999 [ # # ]: 0 : if (s->wbio != s->rbio)
3000 : : {
3001 [ # # ]: 0 : if (!BIO_dup_state(s->wbio,(char *)&ret->wbio))
3002 : : goto err;
3003 : : }
3004 : : else
3005 : 0 : ret->wbio=ret->rbio;
3006 : : }
3007 : 0 : ret->rwstate = s->rwstate;
3008 : 0 : ret->in_handshake = s->in_handshake;
3009 : 0 : ret->handshake_func = s->handshake_func;
3010 : 0 : ret->server = s->server;
3011 : 0 : ret->renegotiate = s->renegotiate;
3012 : 0 : ret->new_session = s->new_session;
3013 : 0 : ret->quiet_shutdown = s->quiet_shutdown;
3014 : 0 : ret->shutdown=s->shutdown;
3015 : 0 : ret->state=s->state; /* SSL_dup does not really work at any state, though */
3016 : 0 : ret->rstate=s->rstate;
3017 : 0 : ret->init_num = 0; /* would have to copy ret->init_buf, ret->init_msg, ret->init_num, ret->init_off */
3018 : 0 : ret->hit=s->hit;
3019 : :
3020 : 0 : X509_VERIFY_PARAM_inherit(ret->param, s->param);
3021 : :
3022 : : /* dup the cipher_list and cipher_list_by_id stacks */
3023 [ # # ]: 0 : if (s->cipher_list != NULL)
3024 : : {
3025 [ # # ]: 0 : if ((ret->cipher_list=sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
3026 : : goto err;
3027 : : }
3028 [ # # ]: 0 : if (s->cipher_list_by_id != NULL)
3029 [ # # ]: 0 : if ((ret->cipher_list_by_id=sk_SSL_CIPHER_dup(s->cipher_list_by_id))
3030 : : == NULL)
3031 : : goto err;
3032 : :
3033 : : /* Dup the client_CA list */
3034 [ # # ]: 0 : if (s->client_CA != NULL)
3035 : : {
3036 [ # # ]: 0 : if ((sk=sk_X509_NAME_dup(s->client_CA)) == NULL) goto err;
3037 : 0 : ret->client_CA=sk;
3038 [ # # ]: 0 : for (i=0; i<sk_X509_NAME_num(sk); i++)
3039 : : {
3040 : 0 : xn=sk_X509_NAME_value(sk,i);
3041 [ # # ]: 0 : if (sk_X509_NAME_set(sk,i,X509_NAME_dup(xn)) == NULL)
3042 : : {
3043 : 0 : X509_NAME_free(xn);
3044 : 0 : goto err;
3045 : : }
3046 : : }
3047 : : }
3048 : :
3049 : : if (0)
3050 : : {
3051 : : err:
3052 [ # # ]: 0 : if (ret != NULL) SSL_free(ret);
3053 : : ret=NULL;
3054 : : }
3055 : 0 : return(ret);
3056 : : }
3057 : :
3058 : 8464 : void ssl_clear_cipher_ctx(SSL *s)
3059 : : {
3060 [ + + ]: 8464 : if (s->enc_read_ctx != NULL)
3061 : : {
3062 : 2380 : EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
3063 : 2380 : OPENSSL_free(s->enc_read_ctx);
3064 : 2380 : s->enc_read_ctx=NULL;
3065 : : }
3066 [ + + ]: 8464 : if (s->enc_write_ctx != NULL)
3067 : : {
3068 : 2380 : EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
3069 : 2380 : OPENSSL_free(s->enc_write_ctx);
3070 : 2380 : s->enc_write_ctx=NULL;
3071 : : }
3072 : : #ifndef OPENSSL_NO_COMP
3073 [ - + ]: 8464 : if (s->expand != NULL)
3074 : : {
3075 : 0 : COMP_CTX_free(s->expand);
3076 : 0 : s->expand=NULL;
3077 : : }
3078 [ - + ]: 8464 : if (s->compress != NULL)
3079 : : {
3080 : 0 : COMP_CTX_free(s->compress);
3081 : 0 : s->compress=NULL;
3082 : : }
3083 : : #endif
3084 : 8464 : }
3085 : :
3086 : 0 : X509 *SSL_get_certificate(const SSL *s)
3087 : : {
3088 [ # # ]: 0 : if (s->cert != NULL)
3089 : 0 : return(s->cert->key->x509);
3090 : : else
3091 : : return(NULL);
3092 : : }
3093 : :
3094 : 0 : EVP_PKEY *SSL_get_privatekey(const SSL *s)
3095 : : {
3096 [ # # ]: 0 : if (s->cert != NULL)
3097 : 0 : return(s->cert->key->privatekey);
3098 : : else
3099 : : return(NULL);
3100 : : }
3101 : :
3102 : 0 : X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
3103 : : {
3104 [ # # ]: 0 : if (ctx->cert != NULL)
3105 : 0 : return ctx->cert->key->x509;
3106 : : else
3107 : : return NULL;
3108 : : }
3109 : :
3110 : 0 : EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
3111 : : {
3112 [ # # ]: 0 : if (ctx->cert != NULL)
3113 : 0 : return ctx->cert->key->privatekey;
3114 : : else
3115 : : return NULL ;
3116 : : }
3117 : :
3118 : 1190 : const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
3119 : : {
3120 [ + - ][ + + ]: 1190 : if ((s->session != NULL) && (s->session->cipher != NULL))
3121 : 1168 : return(s->session->cipher);
3122 : : return(NULL);
3123 : : }
3124 : : #ifdef OPENSSL_NO_COMP
3125 : : const void *SSL_get_current_compression(SSL *s)
3126 : : {
3127 : : return NULL;
3128 : : }
3129 : : const void *SSL_get_current_expansion(SSL *s)
3130 : : {
3131 : : return NULL;
3132 : : }
3133 : : #else
3134 : :
3135 : 0 : const COMP_METHOD *SSL_get_current_compression(SSL *s)
3136 : : {
3137 [ # # ]: 0 : if (s->compress != NULL)
3138 : 0 : return(s->compress->meth);
3139 : : return(NULL);
3140 : : }
3141 : :
3142 : 0 : const COMP_METHOD *SSL_get_current_expansion(SSL *s)
3143 : : {
3144 [ # # ]: 0 : if (s->expand != NULL)
3145 : 0 : return(s->expand->meth);
3146 : : return(NULL);
3147 : : }
3148 : : #endif
3149 : :
3150 : 2160 : int ssl_init_wbio_buffer(SSL *s,int push)
3151 : : {
3152 : : BIO *bbio;
3153 : :
3154 [ + - ]: 2160 : if (s->bbio == NULL)
3155 : : {
3156 : 2160 : bbio=BIO_new(BIO_f_buffer());
3157 [ + - ]: 2160 : if (bbio == NULL) return(0);
3158 : 2160 : s->bbio=bbio;
3159 : : }
3160 : : else
3161 : : {
3162 : 0 : bbio=s->bbio;
3163 [ # # ]: 0 : if (s->bbio == s->wbio)
3164 : 0 : s->wbio=BIO_pop(s->wbio);
3165 : : }
3166 : 2160 : (void)BIO_reset(bbio);
3167 : : /* if (!BIO_set_write_buffer_size(bbio,16*1024)) */
3168 [ - + ]: 2160 : if (!BIO_set_read_buffer_size(bbio,1))
3169 : : {
3170 : 0 : SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER,ERR_R_BUF_LIB);
3171 : 0 : return(0);
3172 : : }
3173 [ + + ]: 2160 : if (push)
3174 : : {
3175 [ + - ]: 1280 : if (s->wbio != bbio)
3176 : 1280 : s->wbio=BIO_push(bbio,s->wbio);
3177 : : }
3178 : : else
3179 : : {
3180 [ - + ]: 880 : if (s->wbio == bbio)
3181 : 0 : s->wbio=BIO_pop(bbio);
3182 : : }
3183 : : return(1);
3184 : : }
3185 : :
3186 : 8556 : void ssl_free_wbio_buffer(SSL *s)
3187 : : {
3188 [ + + ]: 8556 : if (s->bbio == NULL) return;
3189 : :
3190 [ + - ]: 2160 : if (s->bbio == s->wbio)
3191 : : {
3192 : : /* remove buffering */
3193 : 2160 : s->wbio=BIO_pop(s->wbio);
3194 : : #ifdef REF_CHECK /* not the usual REF_CHECK, but this avoids adding one more preprocessor symbol */
3195 : : assert(s->wbio != NULL);
3196 : : #endif
3197 : : }
3198 : 2160 : BIO_free(s->bbio);
3199 : 2160 : s->bbio=NULL;
3200 : : }
3201 : :
3202 : 0 : void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx,int mode)
3203 : : {
3204 : 0 : ctx->quiet_shutdown=mode;
3205 : 0 : }
3206 : :
3207 : 0 : int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
3208 : : {
3209 : 0 : return(ctx->quiet_shutdown);
3210 : : }
3211 : :
3212 : 0 : void SSL_set_quiet_shutdown(SSL *s,int mode)
3213 : : {
3214 : 0 : s->quiet_shutdown=mode;
3215 : 0 : }
3216 : :
3217 : 0 : int SSL_get_quiet_shutdown(const SSL *s)
3218 : : {
3219 : 0 : return(s->quiet_shutdown);
3220 : : }
3221 : :
3222 : 0 : void SSL_set_shutdown(SSL *s,int mode)
3223 : : {
3224 : 0 : s->shutdown=mode;
3225 : 0 : }
3226 : :
3227 : 0 : int SSL_get_shutdown(const SSL *s)
3228 : : {
3229 : 0 : return(s->shutdown);
3230 : : }
3231 : :
3232 : 10158 : int SSL_version(const SSL *s)
3233 : : {
3234 : 10158 : return(s->version);
3235 : : }
3236 : :
3237 : 0 : SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
3238 : : {
3239 : 0 : return(ssl->ctx);
3240 : : }
3241 : :
3242 : 0 : SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx)
3243 : : {
3244 [ # # ]: 0 : if (ssl->ctx == ctx)
3245 : : return ssl->ctx;
3246 : : #ifndef OPENSSL_NO_TLSEXT
3247 [ # # ]: 0 : if (ctx == NULL)
3248 : 0 : ctx = ssl->initial_ctx;
3249 : : #endif
3250 [ # # ]: 0 : if (ssl->cert != NULL)
3251 : 0 : ssl_cert_free(ssl->cert);
3252 : 0 : ssl->cert = ssl_cert_dup(ctx->cert);
3253 : 0 : CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
3254 [ # # ]: 0 : if (ssl->ctx != NULL)
3255 : 0 : SSL_CTX_free(ssl->ctx); /* decrement reference count */
3256 : 0 : ssl->ctx = ctx;
3257 : 0 : return(ssl->ctx);
3258 : : }
3259 : :
3260 : : #ifndef OPENSSL_NO_STDIO
3261 : 462 : int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
3262 : : {
3263 : 462 : return(X509_STORE_set_default_paths(ctx->cert_store));
3264 : : }
3265 : :
3266 : 1124 : int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
3267 : : const char *CApath)
3268 : : {
3269 : 1124 : return(X509_STORE_load_locations(ctx->cert_store,CAfile,CApath));
3270 : : }
3271 : : #endif
3272 : :
3273 : 0 : void SSL_set_info_callback(SSL *ssl,
3274 : : void (*cb)(const SSL *ssl,int type,int val))
3275 : : {
3276 : 0 : ssl->info_callback=cb;
3277 : 0 : }
3278 : :
3279 : : /* One compiler (Diab DCC) doesn't like argument names in returned
3280 : : function pointer. */
3281 : 0 : void (*SSL_get_info_callback(const SSL *ssl))(const SSL * /*ssl*/,int /*type*/,int /*val*/)
3282 : : {
3283 : 0 : return ssl->info_callback;
3284 : : }
3285 : :
3286 : 304729 : int SSL_state(const SSL *ssl)
3287 : : {
3288 : 304729 : return(ssl->state);
3289 : : }
3290 : :
3291 : 0 : void SSL_set_state(SSL *ssl, int state)
3292 : : {
3293 : 0 : ssl->state = state;
3294 : 0 : }
3295 : :
3296 : 0 : void SSL_set_verify_result(SSL *ssl,long arg)
3297 : : {
3298 : 0 : ssl->verify_result=arg;
3299 : 0 : }
3300 : :
3301 : 0 : long SSL_get_verify_result(const SSL *ssl)
3302 : : {
3303 : 0 : return(ssl->verify_result);
3304 : : }
3305 : :
3306 : 0 : int SSL_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
3307 : : CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
3308 : : {
3309 : 0 : return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp,
3310 : : new_func, dup_func, free_func);
3311 : : }
3312 : :
3313 : 0 : int SSL_set_ex_data(SSL *s,int idx,void *arg)
3314 : : {
3315 : 0 : return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
3316 : : }
3317 : :
3318 : 0 : void *SSL_get_ex_data(const SSL *s,int idx)
3319 : : {
3320 : 0 : return(CRYPTO_get_ex_data(&s->ex_data,idx));
3321 : : }
3322 : :
3323 : 0 : int SSL_CTX_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
3324 : : CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
3325 : : {
3326 : 0 : return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp,
3327 : : new_func, dup_func, free_func);
3328 : : }
3329 : :
3330 : 0 : int SSL_CTX_set_ex_data(SSL_CTX *s,int idx,void *arg)
3331 : : {
3332 : 0 : return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
3333 : : }
3334 : :
3335 : 0 : void *SSL_CTX_get_ex_data(const SSL_CTX *s,int idx)
3336 : : {
3337 : 0 : return(CRYPTO_get_ex_data(&s->ex_data,idx));
3338 : : }
3339 : :
3340 : 0 : int ssl_ok(SSL *s)
3341 : : {
3342 : 0 : return(1);
3343 : : }
3344 : :
3345 : 0 : X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
3346 : : {
3347 : 0 : return(ctx->cert_store);
3348 : : }
3349 : :
3350 : 0 : void SSL_CTX_set_cert_store(SSL_CTX *ctx,X509_STORE *store)
3351 : : {
3352 [ # # ]: 0 : if (ctx->cert_store != NULL)
3353 : 0 : X509_STORE_free(ctx->cert_store);
3354 : 0 : ctx->cert_store=store;
3355 : 0 : }
3356 : :
3357 : 105333 : int SSL_want(const SSL *s)
3358 : : {
3359 : 105333 : return(s->rwstate);
3360 : : }
3361 : :
3362 : : /*!
3363 : : * \brief Set the callback for generating temporary RSA keys.
3364 : : * \param ctx the SSL context.
3365 : : * \param cb the callback
3366 : : */
3367 : :
3368 : : #ifndef OPENSSL_NO_RSA
3369 : 893 : void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
3370 : : int is_export,
3371 : : int keylength))
3372 : : {
3373 : 893 : SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
3374 : 893 : }
3375 : :
3376 : 0 : void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,
3377 : : int is_export,
3378 : : int keylength))
3379 : : {
3380 : 0 : SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
3381 : 0 : }
3382 : : #endif
3383 : :
3384 : : #ifdef DOXYGEN
3385 : : /*!
3386 : : * \brief The RSA temporary key callback function.
3387 : : * \param ssl the SSL session.
3388 : : * \param is_export \c TRUE if the temp RSA key is for an export ciphersuite.
3389 : : * \param keylength if \c is_export is \c TRUE, then \c keylength is the size
3390 : : * of the required key in bits.
3391 : : * \return the temporary RSA key.
3392 : : * \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
3393 : : */
3394 : :
3395 : : RSA *cb(SSL *ssl,int is_export,int keylength)
3396 : : {}
3397 : : #endif
3398 : :
3399 : : /*!
3400 : : * \brief Set the callback for generating temporary DH keys.
3401 : : * \param ctx the SSL context.
3402 : : * \param dh the callback
3403 : : */
3404 : :
3405 : : #ifndef OPENSSL_NO_DH
3406 : 0 : void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
3407 : : int keylength))
3408 : : {
3409 : 0 : SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
3410 : 0 : }
3411 : :
3412 : 0 : void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
3413 : : int keylength))
3414 : : {
3415 : 0 : SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
3416 : 0 : }
3417 : : #endif
3418 : :
3419 : : #ifndef OPENSSL_NO_ECDH
3420 : 0 : void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
3421 : : int keylength))
3422 : : {
3423 : 0 : SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
3424 : 0 : }
3425 : :
3426 : 0 : void SSL_set_tmp_ecdh_callback(SSL *ssl,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
3427 : : int keylength))
3428 : : {
3429 : 0 : SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
3430 : 0 : }
3431 : : #endif
3432 : :
3433 : : #ifndef OPENSSL_NO_PSK
3434 : 22 : int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
3435 : : {
3436 [ + - ][ - + ]: 22 : if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN)
3437 : : {
3438 : 0 : SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
3439 : 0 : return 0;
3440 : : }
3441 [ - + ]: 22 : if (ctx->psk_identity_hint != NULL)
3442 : 0 : OPENSSL_free(ctx->psk_identity_hint);
3443 [ + - ]: 22 : if (identity_hint != NULL)
3444 : : {
3445 : 22 : ctx->psk_identity_hint = BUF_strdup(identity_hint);
3446 [ + - ]: 22 : if (ctx->psk_identity_hint == NULL)
3447 : : return 0;
3448 : : }
3449 : : else
3450 : 0 : ctx->psk_identity_hint = NULL;
3451 : : return 1;
3452 : : }
3453 : :
3454 : 0 : int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
3455 : : {
3456 [ # # ]: 0 : if (s == NULL)
3457 : : return 0;
3458 : :
3459 [ # # ]: 0 : if (s->session == NULL)
3460 : : return 1; /* session not created yet, ignored */
3461 : :
3462 [ # # ][ # # ]: 0 : if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN)
3463 : : {
3464 : 0 : SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
3465 : 0 : return 0;
3466 : : }
3467 [ # # ]: 0 : if (s->session->psk_identity_hint != NULL)
3468 : 0 : OPENSSL_free(s->session->psk_identity_hint);
3469 [ # # ]: 0 : if (identity_hint != NULL)
3470 : : {
3471 : 0 : s->session->psk_identity_hint = BUF_strdup(identity_hint);
3472 [ # # ]: 0 : if (s->session->psk_identity_hint == NULL)
3473 : : return 0;
3474 : : }
3475 : : else
3476 : 0 : s->session->psk_identity_hint = NULL;
3477 : : return 1;
3478 : : }
3479 : :
3480 : 0 : const char *SSL_get_psk_identity_hint(const SSL *s)
3481 : : {
3482 [ # # ][ # # ]: 0 : if (s == NULL || s->session == NULL)
3483 : : return NULL;
3484 : 0 : return(s->session->psk_identity_hint);
3485 : : }
3486 : :
3487 : 0 : const char *SSL_get_psk_identity(const SSL *s)
3488 : : {
3489 [ # # ][ # # ]: 0 : if (s == NULL || s->session == NULL)
3490 : : return NULL;
3491 : 0 : return(s->session->psk_identity);
3492 : : }
3493 : :
3494 : 0 : void SSL_set_psk_client_callback(SSL *s,
3495 : : unsigned int (*cb)(SSL *ssl, const char *hint,
3496 : : char *identity, unsigned int max_identity_len, unsigned char *psk,
3497 : : unsigned int max_psk_len))
3498 : : {
3499 : 0 : s->psk_client_callback = cb;
3500 : 0 : }
3501 : :
3502 : 22 : void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
3503 : : unsigned int (*cb)(SSL *ssl, const char *hint,
3504 : : char *identity, unsigned int max_identity_len, unsigned char *psk,
3505 : : unsigned int max_psk_len))
3506 : : {
3507 : 22 : ctx->psk_client_callback = cb;
3508 : 22 : }
3509 : :
3510 : 0 : void SSL_set_psk_server_callback(SSL *s,
3511 : : unsigned int (*cb)(SSL *ssl, const char *identity,
3512 : : unsigned char *psk, unsigned int max_psk_len))
3513 : : {
3514 : 0 : s->psk_server_callback = cb;
3515 : 0 : }
3516 : :
3517 : 22 : void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
3518 : : unsigned int (*cb)(SSL *ssl, const char *identity,
3519 : : unsigned char *psk, unsigned int max_psk_len))
3520 : : {
3521 : 22 : ctx->psk_server_callback = cb;
3522 : 22 : }
3523 : : #endif
3524 : :
3525 : 0 : 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))
3526 : : {
3527 : 0 : SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3528 : 0 : }
3529 : 0 : 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))
3530 : : {
3531 : 0 : SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3532 : 0 : }
3533 : :
3534 : 0 : void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
3535 : : int (*cb)(SSL *ssl, int is_forward_secure))
3536 : : {
3537 : 0 : SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3538 : : (void (*)(void))cb);
3539 : 0 : }
3540 : 0 : void SSL_set_not_resumable_session_callback(SSL *ssl,
3541 : : int (*cb)(SSL *ssl, int is_forward_secure))
3542 : : {
3543 : 0 : SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3544 : : (void (*)(void))cb);
3545 : 0 : }
3546 : :
3547 : : /* Allocates new EVP_MD_CTX and sets pointer to it into given pointer
3548 : : * vairable, freeing EVP_MD_CTX previously stored in that variable, if
3549 : : * any. If EVP_MD pointer is passed, initializes ctx with this md
3550 : : * Returns newly allocated ctx;
3551 : : */
3552 : :
3553 : 4760 : EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash,const EVP_MD *md)
3554 : : {
3555 : 4760 : ssl_clear_hash_ctx(hash);
3556 : 4760 : *hash = EVP_MD_CTX_create();
3557 [ + + ]: 4760 : if (md) EVP_DigestInit_ex(*hash,md,NULL);
3558 : 4760 : return *hash;
3559 : : }
3560 : 21688 : void ssl_clear_hash_ctx(EVP_MD_CTX **hash)
3561 : : {
3562 : :
3563 [ + + ]: 21688 : if (*hash) EVP_MD_CTX_destroy(*hash);
3564 : 21688 : *hash=NULL;
3565 : 21688 : }
3566 : :
3567 : 0 : void SSL_set_debug(SSL *s, int debug)
3568 : : {
3569 : 0 : s->debug = debug;
3570 : 0 : }
3571 : :
3572 : 0 : int SSL_cache_hit(SSL *s)
3573 : : {
3574 : 0 : return s->hit;
3575 : : }
3576 : :
3577 : 0 : int SSL_is_server(SSL *s)
3578 : : {
3579 : 0 : return s->server;
3580 : : }
3581 : :
3582 : 0 : void SSL_set_security_level(SSL *s, int level)
3583 : : {
3584 : 0 : s->cert->sec_level = level;
3585 : 0 : }
3586 : :
3587 : 168915 : int SSL_get_security_level(const SSL *s)
3588 : : {
3589 : 168915 : return s->cert->sec_level;
3590 : : }
3591 : :
3592 : 0 : void SSL_set_security_callback(SSL *s, int (*cb)(SSL *s, SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex))
3593 : : {
3594 : 0 : s->cert->sec_cb = cb;
3595 : 0 : }
3596 : :
3597 : 0 : int (*SSL_get_security_callback(const SSL *s))(SSL *s, SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex)
3598 : : {
3599 : 0 : return s->cert->sec_cb;
3600 : : }
3601 : :
3602 : 0 : void SSL_set0_security_ex_data(SSL *s, void *ex)
3603 : : {
3604 : 0 : s->cert->sec_ex = ex;
3605 : 0 : }
3606 : :
3607 : 0 : void *SSL_get0_security_ex_data(const SSL *s)
3608 : : {
3609 : 0 : return s->cert->sec_ex;
3610 : : }
3611 : :
3612 : 1786 : void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
3613 : : {
3614 : 1786 : ctx->cert->sec_level = level;
3615 : 1786 : }
3616 : :
3617 : 2811 : int SSL_CTX_get_security_level(const SSL_CTX *ctx)
3618 : : {
3619 : 2811 : return ctx->cert->sec_level;
3620 : : }
3621 : :
3622 : 0 : void SSL_CTX_set_security_callback(SSL_CTX *ctx, int (*cb)(SSL *s, SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex))
3623 : : {
3624 : 0 : ctx->cert->sec_cb = cb;
3625 : 0 : }
3626 : :
3627 : 0 : int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx))(SSL *s, SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex)
3628 : : {
3629 : 0 : return ctx->cert->sec_cb;
3630 : : }
3631 : :
3632 : 0 : void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
3633 : : {
3634 : 0 : ctx->cert->sec_ex = ex;
3635 : 0 : }
3636 : :
3637 : 0 : void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
3638 : : {
3639 : 0 : return ctx->cert->sec_ex;
3640 : : }
3641 : :
3642 : :
3643 : : #if defined(_WINDLL) && defined(OPENSSL_SYS_WIN16)
3644 : : #include "../crypto/bio/bss_file.c"
3645 : : #endif
3646 : :
3647 : : IMPLEMENT_STACK_OF(SSL_CIPHER)
3648 : : IMPLEMENT_STACK_OF(SSL_COMP)
3649 : 832012 : IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER,
3650 : : ssl_cipher_id);
|
