Branch data Line data Source code
1 : : /* ssl/ssltest.c */
2 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 : : * All rights reserved.
4 : : *
5 : : * This package is an SSL implementation written
6 : : * by Eric Young (eay@cryptsoft.com).
7 : : * The implementation was written so as to conform with Netscapes SSL.
8 : : *
9 : : * This library is free for commercial and non-commercial use as long as
10 : : * the following conditions are aheared to. The following conditions
11 : : * apply to all code found in this distribution, be it the RC4, RSA,
12 : : * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 : : * included with this distribution is covered by the same copyright terms
14 : : * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 : : *
16 : : * Copyright remains Eric Young's, and as such any Copyright notices in
17 : : * the code are not to be removed.
18 : : * If this package is used in a product, Eric Young should be given attribution
19 : : * as the author of the parts of the library used.
20 : : * This can be in the form of a textual message at program startup or
21 : : * in documentation (online or textual) provided with the package.
22 : : *
23 : : * Redistribution and use in source and binary forms, with or without
24 : : * modification, are permitted provided that the following conditions
25 : : * are met:
26 : : * 1. Redistributions of source code must retain the copyright
27 : : * notice, this list of conditions and the following disclaimer.
28 : : * 2. Redistributions in binary form must reproduce the above copyright
29 : : * notice, this list of conditions and the following disclaimer in the
30 : : * documentation and/or other materials provided with the distribution.
31 : : * 3. All advertising materials mentioning features or use of this software
32 : : * must display the following acknowledgement:
33 : : * "This product includes cryptographic software written by
34 : : * Eric Young (eay@cryptsoft.com)"
35 : : * The word 'cryptographic' can be left out if the rouines from the library
36 : : * being used are not cryptographic related :-).
37 : : * 4. If you include any Windows specific code (or a derivative thereof) from
38 : : * the apps directory (application code) you must include an acknowledgement:
39 : : * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 : : *
41 : : * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 : : * SUCH DAMAGE.
52 : : *
53 : : * The licence and distribution terms for any publically available version or
54 : : * derivative of this code cannot be changed. i.e. this code cannot simply be
55 : : * copied and put under another distribution licence
56 : : * [including the GNU Public Licence.]
57 : : */
58 : : /* ====================================================================
59 : : * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved.
60 : : *
61 : : * Redistribution and use in source and binary forms, with or without
62 : : * modification, are permitted provided that the following conditions
63 : : * are met:
64 : : *
65 : : * 1. Redistributions of source code must retain the above copyright
66 : : * notice, this list of conditions and the following disclaimer.
67 : : *
68 : : * 2. Redistributions in binary form must reproduce the above copyright
69 : : * notice, this list of conditions and the following disclaimer in
70 : : * the documentation and/or other materials provided with the
71 : : * distribution.
72 : : *
73 : : * 3. All advertising materials mentioning features or use of this
74 : : * software must display the following acknowledgment:
75 : : * "This product includes software developed by the OpenSSL Project
76 : : * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77 : : *
78 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 : : * endorse or promote products derived from this software without
80 : : * prior written permission. For written permission, please contact
81 : : * openssl-core@openssl.org.
82 : : *
83 : : * 5. Products derived from this software may not be called "OpenSSL"
84 : : * nor may "OpenSSL" appear in their names without prior written
85 : : * permission of the OpenSSL Project.
86 : : *
87 : : * 6. Redistributions of any form whatsoever must retain the following
88 : : * acknowledgment:
89 : : * "This product includes software developed by the OpenSSL Project
90 : : * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91 : : *
92 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
104 : : * ====================================================================
105 : : *
106 : : * This product includes cryptographic software written by Eric Young
107 : : * (eay@cryptsoft.com). This product includes software written by Tim
108 : : * Hudson (tjh@cryptsoft.com).
109 : : *
110 : : */
111 : : /* ====================================================================
112 : : * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 : : * ECC cipher suite support in OpenSSL originally developed by
114 : : * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
115 : : */
116 : : /* ====================================================================
117 : : * Copyright 2005 Nokia. All rights reserved.
118 : : *
119 : : * The portions of the attached software ("Contribution") is developed by
120 : : * Nokia Corporation and is licensed pursuant to the OpenSSL open source
121 : : * license.
122 : : *
123 : : * The Contribution, originally written by Mika Kousa and Pasi Eronen of
124 : : * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
125 : : * support (see RFC 4279) to OpenSSL.
126 : : *
127 : : * No patent licenses or other rights except those expressly stated in
128 : : * the OpenSSL open source license shall be deemed granted or received
129 : : * expressly, by implication, estoppel, or otherwise.
130 : : *
131 : : * No assurances are provided by Nokia that the Contribution does not
132 : : * infringe the patent or other intellectual property rights of any third
133 : : * party or that the license provides you with all the necessary rights
134 : : * to make use of the Contribution.
135 : : *
136 : : * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
137 : : * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
138 : : * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
139 : : * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
140 : : * OTHERWISE.
141 : : */
142 : :
143 : : #define _BSD_SOURCE 1 /* Or gethostname won't be declared properly
144 : : on Linux and GNU platforms. */
145 : :
146 : : #include <assert.h>
147 : : #include <errno.h>
148 : : #include <limits.h>
149 : : #include <stdio.h>
150 : : #include <stdlib.h>
151 : : #include <string.h>
152 : : #include <time.h>
153 : :
154 : : #define USE_SOCKETS
155 : : #include "e_os.h"
156 : :
157 : : #ifdef OPENSSL_SYS_VMS
158 : : #define _XOPEN_SOURCE 500 /* Or isascii won't be declared properly on
159 : : VMS (at least with DECompHP C). */
160 : : #endif
161 : :
162 : : #include <ctype.h>
163 : :
164 : : #include <openssl/bio.h>
165 : : #include <openssl/crypto.h>
166 : : #include <openssl/evp.h>
167 : : #include <openssl/x509.h>
168 : : #include <openssl/x509v3.h>
169 : : #include <openssl/ssl.h>
170 : : #ifndef OPENSSL_NO_ENGINE
171 : : #include <openssl/engine.h>
172 : : #endif
173 : : #include <openssl/err.h>
174 : : #include <openssl/rand.h>
175 : : #ifndef OPENSSL_NO_RSA
176 : : #include <openssl/rsa.h>
177 : : #endif
178 : : #ifndef OPENSSL_NO_DSA
179 : : #include <openssl/dsa.h>
180 : : #endif
181 : : #ifndef OPENSSL_NO_DH
182 : : #include <openssl/dh.h>
183 : : #endif
184 : : #ifndef OPENSSL_NO_SRP
185 : : #include <openssl/srp.h>
186 : : #endif
187 : : #include <openssl/bn.h>
188 : :
189 : : #define _XOPEN_SOURCE_EXTENDED 1 /* Or gethostname won't be declared properly
190 : : on Compaq platforms (at least with DEC C).
191 : : Do not try to put it earlier, or IPv6 includes
192 : : get screwed...
193 : : */
194 : :
195 : : #ifdef OPENSSL_SYS_WINDOWS
196 : : #include <winsock.h>
197 : : #else
198 : : #include OPENSSL_UNISTD
199 : : #endif
200 : :
201 : : #ifdef OPENSSL_SYS_VMS
202 : : # define TEST_SERVER_CERT "SYS$DISK:[-.APPS]SERVER.PEM"
203 : : # define TEST_CLIENT_CERT "SYS$DISK:[-.APPS]CLIENT.PEM"
204 : : #elif defined(OPENSSL_SYS_WINCE)
205 : : # define TEST_SERVER_CERT "\\OpenSSL\\server.pem"
206 : : # define TEST_CLIENT_CERT "\\OpenSSL\\client.pem"
207 : : #elif defined(OPENSSL_SYS_NETWARE)
208 : : # define TEST_SERVER_CERT "\\openssl\\apps\\server.pem"
209 : : # define TEST_CLIENT_CERT "\\openssl\\apps\\client.pem"
210 : : #else
211 : : # define TEST_SERVER_CERT "../apps/server.pem"
212 : : # define TEST_CLIENT_CERT "../apps/client.pem"
213 : : #endif
214 : :
215 : : /* There is really no standard for this, so let's assign some tentative
216 : : numbers. In any case, these numbers are only for this test */
217 : : #define COMP_RLE 255
218 : : #define COMP_ZLIB 1
219 : :
220 : : static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx);
221 : : #ifndef OPENSSL_NO_RSA
222 : : static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export,int keylength);
223 : : static void free_tmp_rsa(void);
224 : : #endif
225 : : static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg);
226 : : #define APP_CALLBACK_STRING "Test Callback Argument"
227 : : struct app_verify_arg
228 : : {
229 : : char *string;
230 : : int app_verify;
231 : : int allow_proxy_certs;
232 : : char *proxy_auth;
233 : : char *proxy_cond;
234 : : };
235 : :
236 : : #ifndef OPENSSL_NO_DH
237 : : static DH *get_dh512(void);
238 : : static DH *get_dh1024(void);
239 : : static DH *get_dh1024dsa(void);
240 : : #endif
241 : :
242 : :
243 : : static char *psk_key=NULL; /* by default PSK is not used */
244 : : #ifndef OPENSSL_NO_PSK
245 : : static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
246 : : unsigned int max_identity_len, unsigned char *psk,
247 : : unsigned int max_psk_len);
248 : : static unsigned int psk_server_callback(SSL *ssl, const char *identity, unsigned char *psk,
249 : : unsigned int max_psk_len);
250 : : #endif
251 : :
252 : : #ifndef OPENSSL_NO_SRP
253 : : /* SRP client */
254 : : /* This is a context that we pass to all callbacks */
255 : : typedef struct srp_client_arg_st
256 : : {
257 : : char *srppassin;
258 : : char *srplogin;
259 : : } SRP_CLIENT_ARG;
260 : :
261 : : #define PWD_STRLEN 1024
262 : :
263 : 22 : static char * MS_CALLBACK ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
264 : : {
265 : 22 : SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
266 : 22 : return BUF_strdup((char *)srp_client_arg->srppassin);
267 : : }
268 : :
269 : : /* SRP server */
270 : : /* This is a context that we pass to SRP server callbacks */
271 : : typedef struct srp_server_arg_st
272 : : {
273 : : char *expected_user;
274 : : char *pass;
275 : : } SRP_SERVER_ARG;
276 : :
277 : 22 : static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
278 : : {
279 : 22 : SRP_SERVER_ARG * p = (SRP_SERVER_ARG *) arg;
280 : :
281 [ - + ]: 22 : if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0)
282 : : {
283 : 0 : fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
284 : 0 : return SSL3_AL_FATAL;
285 : : }
286 [ - + ]: 22 : if (SSL_set_srp_server_param_pw(s,p->expected_user,p->pass,"1024")<0)
287 : : {
288 : 0 : *ad = SSL_AD_INTERNAL_ERROR;
289 : 0 : return SSL3_AL_FATAL;
290 : : }
291 : : return SSL_ERROR_NONE;
292 : : }
293 : : #endif
294 : :
295 : : static BIO *bio_err=NULL;
296 : : static BIO *bio_stdout=NULL;
297 : :
298 : : #ifndef OPENSSL_NO_NEXTPROTONEG
299 : : /* Note that this code assumes that this is only a one element list: */
300 : : static const char NEXT_PROTO_STRING[] = "\x09testproto";
301 : : int npn_client = 0;
302 : : int npn_server = 0;
303 : : int npn_server_reject = 0;
304 : :
305 : 55 : static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
306 : : {
307 : : /* This callback only returns the protocol string, rather than a length
308 : : prefixed set. We assume that NEXT_PROTO_STRING is a one element list and
309 : : remove the first byte to chop off the length prefix. */
310 : 55 : *out = (unsigned char*) NEXT_PROTO_STRING + 1;
311 : 55 : *outlen = sizeof(NEXT_PROTO_STRING) - 2;
312 : 55 : return SSL_TLSEXT_ERR_OK;
313 : : }
314 : :
315 : 55 : static int cb_server_npn(SSL *s, const unsigned char **data, unsigned int *len, void *arg)
316 : : {
317 : 55 : *data = (const unsigned char *) NEXT_PROTO_STRING;
318 : 55 : *len = sizeof(NEXT_PROTO_STRING) - 1;
319 : 55 : return SSL_TLSEXT_ERR_OK;
320 : : }
321 : :
322 : 11 : static int cb_server_rejects_npn(SSL *s, const unsigned char **data, unsigned int *len, void *arg)
323 : : {
324 : 11 : return SSL_TLSEXT_ERR_NOACK;
325 : : }
326 : :
327 : 1190 : static int verify_npn(SSL *client, SSL *server)
328 : : {
329 : : const unsigned char *client_s;
330 : : unsigned client_len;
331 : : const unsigned char *server_s;
332 : : unsigned server_len;
333 : :
334 : 1190 : SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
335 : 1190 : SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
336 : :
337 [ + + ]: 1190 : if (client_len)
338 : : {
339 : 55 : BIO_printf(bio_stdout, "Client NPN: ");
340 : 55 : BIO_write(bio_stdout, client_s, client_len);
341 : 55 : BIO_printf(bio_stdout, "\n");
342 : : }
343 : :
344 [ + + ]: 1190 : if (server_len)
345 : : {
346 : 55 : BIO_printf(bio_stdout, "Server NPN: ");
347 : 55 : BIO_write(bio_stdout, server_s, server_len);
348 : 55 : BIO_printf(bio_stdout, "\n");
349 : : }
350 : :
351 : : /* If an NPN string was returned, it must be the protocol that we
352 : : * expected to negotiate. */
353 [ + + ][ + - ]: 1190 : if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||
[ + - ]
354 : 55 : memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))
355 : : return -1;
356 [ + + ][ + - ]: 1190 : if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||
[ + - ]
357 : 55 : memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))
358 : : return -1;
359 : :
360 [ + + ][ + - ]: 1190 : if (!npn_client && client_len)
361 : : return -1;
362 [ + + ][ + - ]: 1190 : if (!npn_server && server_len)
363 : : return -1;
364 [ + + ][ + - ]: 1190 : if (npn_server_reject && server_len)
365 : : return -1;
366 [ + + ][ + + ]: 1190 : if (npn_client && npn_server && (!client_len || !server_len))
[ + - ][ + - ]
367 : : return -1;
368 : :
369 : 1190 : return 0;
370 : : }
371 : : #endif
372 : :
373 : : static const char *alpn_client;
374 : : static const char *alpn_server;
375 : : static const char *alpn_expected;
376 : : static unsigned char *alpn_selected;
377 : :
378 : : /* next_protos_parse parses a comma separated list of strings into a string
379 : : * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
380 : : * outlen: (output) set to the length of the resulting buffer on success.
381 : : * err: (maybe NULL) on failure, an error message line is written to this BIO.
382 : : * in: a NUL termianted string like "abc,def,ghi"
383 : : *
384 : : * returns: a malloced buffer or NULL on failure.
385 : : */
386 : 176 : static unsigned char *next_protos_parse(unsigned short *outlen, const char *in)
387 : : {
388 : : size_t len;
389 : : unsigned char *out;
390 : 176 : size_t i, start = 0;
391 : :
392 : 176 : len = strlen(in);
393 [ + - ]: 176 : if (len >= 65535)
394 : : return NULL;
395 : :
396 : 176 : out = OPENSSL_malloc(strlen(in) + 1);
397 [ + - ]: 176 : if (!out)
398 : : return NULL;
399 : :
400 [ + + ]: 1276 : for (i = 0; i <= len; ++i)
401 : : {
402 [ + + ][ + + ]: 1100 : if (i == len || in[i] == ',')
403 : : {
404 [ - + ]: 275 : if (i - start > 255)
405 : : {
406 : 0 : OPENSSL_free(out);
407 : 0 : return NULL;
408 : : }
409 : 275 : out[start] = i - start;
410 : 275 : start = i + 1;
411 : : }
412 : : else
413 : 825 : out[i+1] = in[i];
414 : : }
415 : :
416 : 176 : *outlen = len + 1;
417 : 176 : return out;
418 : : }
419 : :
420 : 88 : static int cb_server_alpn(SSL *s, const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
421 : : {
422 : : unsigned char *protos;
423 : : unsigned short protos_len;
424 : :
425 : 88 : protos = next_protos_parse(&protos_len, alpn_server);
426 [ - + ]: 88 : if (protos == NULL)
427 : : {
428 : 0 : fprintf(stderr, "failed to parser ALPN server protocol string: %s\n", alpn_server);
429 : 0 : abort();
430 : : }
431 : :
432 [ + + ]: 88 : if (SSL_select_next_proto((unsigned char**) out, outlen, protos, protos_len, in, inlen) !=
433 : : OPENSSL_NPN_NEGOTIATED)
434 : : {
435 : 22 : OPENSSL_free(protos);
436 : 22 : return SSL_TLSEXT_ERR_NOACK;
437 : : }
438 : :
439 : : /* Make a copy of the selected protocol which will be freed in verify_alpn. */
440 : 66 : alpn_selected = OPENSSL_malloc(*outlen);
441 : 66 : memcpy(alpn_selected, *out, *outlen);
442 : 66 : *out = alpn_selected;
443 : :
444 : 66 : OPENSSL_free(protos);
445 : 66 : return SSL_TLSEXT_ERR_OK;
446 : : }
447 : :
448 : 759 : static int verify_alpn(SSL *client, SSL *server)
449 : : {
450 : : const unsigned char *client_proto, *server_proto;
451 : 759 : unsigned int client_proto_len = 0, server_proto_len = 0;
452 : 759 : SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
453 : 759 : SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
454 : :
455 [ + + ]: 759 : if (alpn_selected != NULL)
456 : : {
457 : 66 : OPENSSL_free(alpn_selected);
458 : 66 : alpn_selected = NULL;
459 : : }
460 : :
461 [ + - ][ - + ]: 759 : if (client_proto_len != server_proto_len ||
462 : 759 : memcmp(client_proto, server_proto, client_proto_len) != 0)
463 : : {
464 : 0 : BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
465 : 0 : goto err;
466 : : }
467 : :
468 [ + + ][ - + ]: 759 : if (client_proto_len > 0 && alpn_expected == NULL)
469 : : {
470 : 0 : BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
471 : 0 : goto err;
472 : : }
473 : :
474 [ + + ][ + - ]: 759 : if (alpn_expected != NULL &&
475 [ - + ]: 66 : (client_proto_len != strlen(alpn_expected) ||
476 : 66 : memcmp(client_proto, alpn_expected, client_proto_len) != 0))
477 : : {
478 : 0 : BIO_printf(bio_stdout, "ALPN selected protocols not equal to expected protocol: %s\n", alpn_expected);
479 : 0 : goto err;
480 : : }
481 : :
482 : : return 0;
483 : :
484 : : err:
485 : 0 : BIO_printf(bio_stdout, "ALPN results: client: '");
486 : 0 : BIO_write(bio_stdout, client_proto, client_proto_len);
487 : 0 : BIO_printf(bio_stdout, "', server: '");
488 : 0 : BIO_write(bio_stdout, server_proto, server_proto_len);
489 : 0 : BIO_printf(bio_stdout, "'\n");
490 : 0 : BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '%s'\n", alpn_client, alpn_server);
491 : 0 : return -1;
492 : : }
493 : :
494 : : #define SCT_EXT_TYPE 18
495 : :
496 : : /* WARNING : below extension types are *NOT* IETF assigned, and
497 : : could conflict if these types are reassigned and handled
498 : : specially by OpenSSL in the future */
499 : : #define TACK_EXT_TYPE 62208
500 : : #define CUSTOM_EXT_TYPE_0 1000
501 : : #define CUSTOM_EXT_TYPE_1 1001
502 : : #define CUSTOM_EXT_TYPE_2 1002
503 : : #define CUSTOM_EXT_TYPE_3 1003
504 : :
505 : : const char custom_ext_cli_string[] = "abc";
506 : : const char custom_ext_srv_string[] = "defg";
507 : :
508 : : /* These set from cmdline */
509 : : char* serverinfo_file = NULL;
510 : : int serverinfo_sct = 0;
511 : : int serverinfo_tack = 0;
512 : :
513 : : /* These set based on extension callbacks */
514 : : int serverinfo_sct_seen = 0;
515 : : int serverinfo_tack_seen = 0;
516 : : int serverinfo_other_seen = 0;
517 : :
518 : : /* This set from cmdline */
519 : : int custom_ext = 0;
520 : :
521 : : /* This set based on extension callbacks */
522 : : int custom_ext_error = 0;
523 : :
524 : 66 : static int serverinfo_cli_cb(SSL* s, unsigned short ext_type,
525 : : const unsigned char* in, unsigned short inlen,
526 : : int* al, void* arg)
527 : : {
528 [ + + ]: 66 : if (ext_type == SCT_EXT_TYPE)
529 : 33 : serverinfo_sct_seen++;
530 [ + - ]: 33 : else if (ext_type == TACK_EXT_TYPE)
531 : 33 : serverinfo_tack_seen++;
532 : : else
533 : 0 : serverinfo_other_seen++;
534 : 66 : return 1;
535 : : }
536 : :
537 : 1190 : static int verify_serverinfo()
538 : : {
539 [ + - ]: 1190 : if (serverinfo_sct != serverinfo_sct_seen)
540 : : return -1;
541 [ + - ]: 1190 : if (serverinfo_tack != serverinfo_tack_seen)
542 : : return -1;
543 [ + - ]: 1190 : if (serverinfo_other_seen)
544 : : return -1;
545 : 1190 : return 0;
546 : : }
547 : :
548 : : /* Four test cases for custom extensions:
549 : : * 0 - no ClientHello extension or ServerHello response
550 : : * 1 - ClientHello with "abc", no response
551 : : * 2 - ClientHello with "abc", empty response
552 : : * 3 - ClientHello with "abc", "defg" response
553 : : */
554 : :
555 : 22 : static int custom_ext_0_cli_first_cb(SSL *s, unsigned short ext_type,
556 : : const unsigned char **out,
557 : : unsigned short *outlen, int *al, void *arg)
558 : : {
559 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_0)
560 : 0 : custom_ext_error = 1;
561 : 22 : return -1; /* Don't send an extension */
562 : : }
563 : :
564 : 0 : static int custom_ext_0_cli_second_cb(SSL *s, unsigned short ext_type,
565 : : const unsigned char *in,
566 : : unsigned short inlen, int *al,
567 : : void *arg)
568 : : {
569 : 0 : return 1;
570 : : }
571 : :
572 : 22 : static int custom_ext_1_cli_first_cb(SSL *s, unsigned short ext_type,
573 : : const unsigned char **out,
574 : : unsigned short *outlen, int *al, void *arg)
575 : : {
576 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_1)
577 : 0 : custom_ext_error = 1;
578 : 22 : *out = (const unsigned char*)custom_ext_cli_string;
579 : 22 : *outlen = strlen(custom_ext_cli_string);
580 : 22 : return 1; /* Send "abc" */
581 : : }
582 : :
583 : 0 : static int custom_ext_1_cli_second_cb(SSL *s, unsigned short ext_type,
584 : : const unsigned char *in,
585 : : unsigned short inlen, int *al,
586 : : void *arg)
587 : : {
588 : 0 : return 1;
589 : : }
590 : :
591 : 22 : static int custom_ext_2_cli_first_cb(SSL *s, unsigned short ext_type,
592 : : const unsigned char **out,
593 : : unsigned short *outlen, int *al, void *arg)
594 : : {
595 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_2)
596 : 0 : custom_ext_error = 1;
597 : 22 : *out = (const unsigned char*)custom_ext_cli_string;
598 : 22 : *outlen = strlen(custom_ext_cli_string);
599 : 22 : return 1; /* Send "abc" */
600 : : }
601 : :
602 : 22 : static int custom_ext_2_cli_second_cb(SSL *s, unsigned short ext_type,
603 : : const unsigned char *in,
604 : : unsigned short inlen, int *al,
605 : : void *arg)
606 : : {
607 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_2)
608 : 0 : custom_ext_error = 1;
609 [ - + ]: 22 : if (inlen != 0)
610 : 0 : custom_ext_error = 1; /* Should be empty response */
611 : 22 : return 1;
612 : : }
613 : :
614 : 22 : static int custom_ext_3_cli_first_cb(SSL *s, unsigned short ext_type,
615 : : const unsigned char **out,
616 : : unsigned short *outlen, int *al, void *arg)
617 : : {
618 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_3)
619 : 0 : custom_ext_error = 1;
620 : 22 : *out = (const unsigned char*)custom_ext_cli_string;
621 : 22 : *outlen = strlen(custom_ext_cli_string);
622 : 22 : return 1; /* Send "abc" */
623 : : }
624 : :
625 : 22 : static int custom_ext_3_cli_second_cb(SSL *s, unsigned short ext_type,
626 : : const unsigned char *in,
627 : : unsigned short inlen, int *al,
628 : : void *arg)
629 : : {
630 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_3)
631 : 0 : custom_ext_error = 1;
632 [ - + ]: 22 : if (inlen != strlen(custom_ext_srv_string))
633 : 0 : custom_ext_error = 1;
634 [ - + ]: 22 : if (memcmp(custom_ext_srv_string, in, inlen) != 0)
635 : 0 : custom_ext_error = 1; /* Check for "defg" */
636 : 22 : return 1;
637 : : }
638 : :
639 : : /* custom_ext_0_cli_first_cb returns -1 - the server won't receive a callback for this extension */
640 : 0 : static int custom_ext_0_srv_first_cb(SSL *s, unsigned short ext_type,
641 : : const unsigned char *in,
642 : : unsigned short inlen, int *al,
643 : : void *arg)
644 : : {
645 : 0 : return 1;
646 : : }
647 : :
648 : : /* 'generate' callbacks are always called, even if the 'receive' callback isn't called */
649 : 22 : static int custom_ext_0_srv_second_cb(SSL *s, unsigned short ext_type,
650 : : const unsigned char **out,
651 : : unsigned short *outlen, int *al, void *arg)
652 : : {
653 : 22 : return -1; /* Don't send an extension */
654 : : }
655 : :
656 : 22 : static int custom_ext_1_srv_first_cb(SSL *s, unsigned short ext_type,
657 : : const unsigned char *in,
658 : : unsigned short inlen, int *al,
659 : : void *arg)
660 : : {
661 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_1)
662 : 0 : custom_ext_error = 1;
663 : : /* Check for "abc" */
664 [ - + ]: 22 : if (inlen != strlen(custom_ext_cli_string))
665 : 0 : custom_ext_error = 1;
666 [ - + ]: 22 : if (memcmp(in, custom_ext_cli_string, inlen) != 0)
667 : 0 : custom_ext_error = 1;
668 : 22 : return 1;
669 : : }
670 : :
671 : 22 : static int custom_ext_1_srv_second_cb(SSL *s, unsigned short ext_type,
672 : : const unsigned char **out,
673 : : unsigned short *outlen, int *al, void *arg)
674 : : {
675 : 22 : return -1; /* Don't send an extension */
676 : : }
677 : :
678 : 22 : static int custom_ext_2_srv_first_cb(SSL *s, unsigned short ext_type,
679 : : const unsigned char *in,
680 : : unsigned short inlen, int *al,
681 : : void *arg)
682 : : {
683 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_2)
684 : 0 : custom_ext_error = 1;
685 : : /* Check for "abc" */
686 [ - + ]: 22 : if (inlen != strlen(custom_ext_cli_string))
687 : 0 : custom_ext_error = 1;
688 [ - + ]: 22 : if (memcmp(in, custom_ext_cli_string, inlen) != 0)
689 : 0 : custom_ext_error = 1;
690 : 22 : return 1;
691 : : }
692 : :
693 : 22 : static int custom_ext_2_srv_second_cb(SSL *s, unsigned short ext_type,
694 : : const unsigned char **out,
695 : : unsigned short *outlen, int *al, void *arg)
696 : : {
697 : 22 : *out = NULL;
698 : 22 : *outlen = 0;
699 : 22 : return 1; /* Send empty extension */
700 : : }
701 : :
702 : 22 : static int custom_ext_3_srv_first_cb(SSL *s, unsigned short ext_type,
703 : : const unsigned char *in,
704 : : unsigned short inlen, int *al,
705 : : void *arg)
706 : : {
707 [ - + ]: 22 : if (ext_type != CUSTOM_EXT_TYPE_3)
708 : 0 : custom_ext_error = 1;
709 : : /* Check for "abc" */
710 [ - + ]: 22 : if (inlen != strlen(custom_ext_cli_string))
711 : 0 : custom_ext_error = 1;
712 [ - + ]: 22 : if (memcmp(in, custom_ext_cli_string, inlen) != 0)
713 : 0 : custom_ext_error = 1;
714 : 22 : return 1;
715 : : }
716 : :
717 : 22 : static int custom_ext_3_srv_second_cb(SSL *s, unsigned short ext_type,
718 : : const unsigned char **out,
719 : : unsigned short *outlen, int *al, void *arg)
720 : : {
721 : 22 : *out = (const unsigned char*)custom_ext_srv_string;
722 : 22 : *outlen = strlen(custom_ext_srv_string);
723 : 22 : return 1; /* Send "defg" */
724 : : }
725 : :
726 : : static char *cipher=NULL;
727 : : static int verbose=0;
728 : : static int debug=0;
729 : : #if 0
730 : : /* Not used yet. */
731 : : #ifdef FIONBIO
732 : : static int s_nbio=0;
733 : : #endif
734 : : #endif
735 : :
736 : : static const char rnd_seed[] = "string to make the random number generator think it has entropy";
737 : :
738 : : int doit_biopair(SSL *s_ssl,SSL *c_ssl,long bytes,clock_t *s_time,clock_t *c_time);
739 : : int doit(SSL *s_ssl,SSL *c_ssl,long bytes);
740 : : static int do_test_cipherlist(void);
741 : 0 : static void sv_usage(void)
742 : : {
743 : 0 : fprintf(stderr,"usage: ssltest [args ...]\n");
744 : 0 : fprintf(stderr,"\n");
745 : : #ifdef OPENSSL_FIPS
746 : : fprintf(stderr,"-F - run test in FIPS mode\n");
747 : : #endif
748 : 0 : fprintf(stderr," -server_auth - check server certificate\n");
749 : 0 : fprintf(stderr," -client_auth - do client authentication\n");
750 : 0 : fprintf(stderr," -proxy - allow proxy certificates\n");
751 : 0 : fprintf(stderr," -proxy_auth <val> - set proxy policy rights\n");
752 : 0 : fprintf(stderr," -proxy_cond <val> - experssion to test proxy policy rights\n");
753 : 0 : fprintf(stderr," -v - more output\n");
754 : 0 : fprintf(stderr," -d - debug output\n");
755 : 0 : fprintf(stderr," -reuse - use session-id reuse\n");
756 : 0 : fprintf(stderr," -num <val> - number of connections to perform\n");
757 : 0 : fprintf(stderr," -bytes <val> - number of bytes to swap between client/server\n");
758 : : #ifndef OPENSSL_NO_DH
759 : 0 : fprintf(stderr," -dhe1024 - use 1024 bit key (safe prime) for DHE\n");
760 : 0 : fprintf(stderr," -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
761 : 0 : fprintf(stderr," -no_dhe - disable DHE\n");
762 : : #endif
763 : : #ifndef OPENSSL_NO_ECDH
764 : 0 : fprintf(stderr," -no_ecdhe - disable ECDHE\n");
765 : : #endif
766 : : #ifndef OPENSSL_NO_PSK
767 : 0 : fprintf(stderr," -psk arg - PSK in hex (without 0x)\n");
768 : : #endif
769 : : #ifndef OPENSSL_NO_SRP
770 : 0 : fprintf(stderr," -srpuser user - SRP username to use\n");
771 : 0 : fprintf(stderr," -srppass arg - password for 'user'\n");
772 : : #endif
773 : : #ifndef OPENSSL_NO_SSL2
774 : 0 : fprintf(stderr," -ssl2 - use SSLv2\n");
775 : : #endif
776 : : #ifndef OPENSSL_NO_SSL3
777 : 0 : fprintf(stderr," -ssl3 - use SSLv3\n");
778 : : #endif
779 : : #ifndef OPENSSL_NO_TLS1
780 : 0 : fprintf(stderr," -tls1 - use TLSv1\n");
781 : : #endif
782 : 0 : fprintf(stderr," -CApath arg - PEM format directory of CA's\n");
783 : 0 : fprintf(stderr," -CAfile arg - PEM format file of CA's\n");
784 : 0 : fprintf(stderr," -cert arg - Server certificate file\n");
785 : 0 : fprintf(stderr," -key arg - Server key file (default: same as -cert)\n");
786 : 0 : fprintf(stderr," -c_cert arg - Client certificate file\n");
787 : 0 : fprintf(stderr," -c_key arg - Client key file (default: same as -c_cert)\n");
788 : 0 : fprintf(stderr," -cipher arg - The cipher list\n");
789 : 0 : fprintf(stderr," -bio_pair - Use BIO pairs\n");
790 : 0 : fprintf(stderr," -f - Test even cases that can't work\n");
791 : 0 : fprintf(stderr," -time - measure processor time used by client and server\n");
792 : 0 : fprintf(stderr," -zlib - use zlib compression\n");
793 : 0 : fprintf(stderr," -rle - use rle compression\n");
794 : : #ifndef OPENSSL_NO_ECDH
795 : 0 : fprintf(stderr," -named_curve arg - Elliptic curve name to use for ephemeral ECDH keys.\n" \
796 : : " Use \"openssl ecparam -list_curves\" for all names\n" \
797 : : " (default is sect163r2).\n");
798 : : #endif
799 : 0 : fprintf(stderr," -test_cipherlist - verifies the order of the ssl cipher lists\n");
800 : : #ifndef OPENSSL_NO_NEXTPROTONEG
801 : 0 : fprintf(stderr," -npn_client - have client side offer NPN\n");
802 : 0 : fprintf(stderr," -npn_server - have server side offer NPN\n");
803 : 0 : fprintf(stderr," -npn_server_reject - have server reject NPN\n");
804 : : #endif
805 : 0 : fprintf(stderr," -serverinfo_file file - have server use this file\n");
806 : 0 : fprintf(stderr," -serverinfo_sct - have client offer and expect SCT\n");
807 : 0 : fprintf(stderr," -serverinfo_tack - have client offer and expect TACK\n");
808 : 0 : fprintf(stderr," -custom_ext - try various custom extension callbacks\n");
809 : 0 : fprintf(stderr," -alpn_client <string> - have client side offer ALPN\n");
810 : 0 : fprintf(stderr," -alpn_server <string> - have server side offer ALPN\n");
811 : 0 : fprintf(stderr," -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
812 : 0 : }
813 : :
814 : 1190 : static void print_details(SSL *c_ssl, const char *prefix)
815 : : {
816 : : const SSL_CIPHER *ciph;
817 : : X509 *cert;
818 : :
819 : 1190 : ciph=SSL_get_current_cipher(c_ssl);
820 : 1190 : BIO_printf(bio_stdout,"%s%s, cipher %s %s",
821 : : prefix,
822 : : SSL_get_version(c_ssl),
823 : : SSL_CIPHER_get_version(ciph),
824 : : SSL_CIPHER_get_name(ciph));
825 : 1190 : cert=SSL_get_peer_certificate(c_ssl);
826 [ + + ]: 1190 : if (cert != NULL)
827 : : {
828 : 1036 : EVP_PKEY *pkey = X509_get_pubkey(cert);
829 [ + - ]: 1036 : if (pkey != NULL)
830 : : {
831 : : if (0)
832 : : ;
833 : : #ifndef OPENSSL_NO_RSA
834 [ + - ][ + - ]: 1036 : else if (pkey->type == EVP_PKEY_RSA && pkey->pkey.rsa != NULL
835 [ + - ]: 1036 : && pkey->pkey.rsa->n != NULL)
836 : : {
837 : 1036 : BIO_printf(bio_stdout, ", %d bit RSA",
838 : : BN_num_bits(pkey->pkey.rsa->n));
839 : : }
840 : : #endif
841 : : #ifndef OPENSSL_NO_DSA
842 [ # # ][ # # ]: 0 : else if (pkey->type == EVP_PKEY_DSA && pkey->pkey.dsa != NULL
843 [ # # ]: 0 : && pkey->pkey.dsa->p != NULL)
844 : : {
845 : 0 : BIO_printf(bio_stdout, ", %d bit DSA",
846 : : BN_num_bits(pkey->pkey.dsa->p));
847 : : }
848 : : #endif
849 : 1036 : EVP_PKEY_free(pkey);
850 : : }
851 : 1036 : X509_free(cert);
852 : : }
853 : : /* The SSL API does not allow us to look at temporary RSA/DH keys,
854 : : * otherwise we should print their lengths too */
855 : 1190 : BIO_printf(bio_stdout,"\n");
856 : 1190 : }
857 : :
858 : 215291554 : static void lock_dbg_cb(int mode, int type, const char *file, int line)
859 : : {
860 : : static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
861 : 215291554 : const char *errstr = NULL;
862 : : int rw;
863 : :
864 : 215291554 : rw = mode & (CRYPTO_READ|CRYPTO_WRITE);
865 [ + - ]: 215291554 : if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE)))
866 : : {
867 : : errstr = "invalid mode";
868 : : goto err;
869 : : }
870 : :
871 [ + - ]: 215291554 : if (type < 0 || type >= CRYPTO_NUM_LOCKS)
872 : : {
873 : : errstr = "type out of bounds";
874 : : goto err;
875 : : }
876 : :
877 [ + + ]: 215291554 : if (mode & CRYPTO_LOCK)
878 : : {
879 [ + - ]: 107645777 : if (modes[type])
880 : : {
881 : : errstr = "already locked";
882 : : /* must not happen in a single-threaded program
883 : : * (would deadlock) */
884 : : goto err;
885 : : }
886 : :
887 : 107645777 : modes[type] = rw;
888 : : }
889 [ + - ]: 107645777 : else if (mode & CRYPTO_UNLOCK)
890 : : {
891 [ + - ]: 107645777 : if (!modes[type])
892 : : {
893 : : errstr = "not locked";
894 : : goto err;
895 : : }
896 : :
897 [ - + ]: 107645777 : if (modes[type] != rw)
898 : : {
899 : 0 : errstr = (rw == CRYPTO_READ) ?
900 [ # # ]: 0 : "CRYPTO_r_unlock on write lock" :
901 : : "CRYPTO_w_unlock on read lock";
902 : : }
903 : :
904 : 107645777 : modes[type] = 0;
905 : : }
906 : : else
907 : : {
908 : : errstr = "invalid mode";
909 : : goto err;
910 : : }
911 : :
912 : : err:
913 [ - + ]: 215291554 : if (errstr)
914 : : {
915 : : /* we cannot use bio_err here */
916 : 0 : fprintf(stderr, "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
917 : : errstr, mode, type, file, line);
918 : : }
919 : 215291554 : }
920 : :
921 : : #ifdef TLSEXT_TYPE_opaque_prf_input
922 : : struct cb_info_st { void *input; size_t len; int ret; };
923 : : struct cb_info_st co1 = { "C", 1, 1 }; /* try to negotiate oqaque PRF input */
924 : : struct cb_info_st co2 = { "C", 1, 2 }; /* insist on oqaque PRF input */
925 : : struct cb_info_st so1 = { "S", 1, 1 }; /* try to negotiate oqaque PRF input */
926 : : struct cb_info_st so2 = { "S", 1, 2 }; /* insist on oqaque PRF input */
927 : :
928 : : int opaque_prf_input_cb(SSL *ssl, void *peerinput, size_t len, void *arg_)
929 : : {
930 : : struct cb_info_st *arg = arg_;
931 : :
932 : : if (arg == NULL)
933 : : return 1;
934 : :
935 : : if (!SSL_set_tlsext_opaque_prf_input(ssl, arg->input, arg->len))
936 : : return 0;
937 : : return arg->ret;
938 : : }
939 : : #endif
940 : :
941 : 894 : int main(int argc, char *argv[])
942 : : {
943 : 894 : char *CApath=NULL,*CAfile=NULL;
944 : 894 : int badop=0;
945 : 894 : int bio_pair=0;
946 : 894 : int force=0;
947 : 894 : int tls1=0,ssl2=0,ssl3=0,ret=1;
948 : 894 : int client_auth=0;
949 : 894 : int server_auth=0,i;
950 : 894 : struct app_verify_arg app_verify_arg =
951 : : { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
952 : 894 : char *server_cert=TEST_SERVER_CERT;
953 : 894 : char *server_key=NULL;
954 : 894 : char *client_cert=TEST_CLIENT_CERT;
955 : 894 : char *client_key=NULL;
956 : : #ifndef OPENSSL_NO_ECDH
957 : 894 : char *named_curve = NULL;
958 : : #endif
959 : 894 : SSL_CTX *s_ctx=NULL;
960 : 894 : SSL_CTX *c_ctx=NULL;
961 : 894 : const SSL_METHOD *meth=NULL;
962 : : SSL *c_ssl,*s_ssl;
963 : 894 : int number=1,reuse=0;
964 : 894 : long bytes=256L;
965 : : #ifndef OPENSSL_NO_DH
966 : : DH *dh;
967 : 894 : int dhe1024 = 0, dhe1024dsa = 0;
968 : : #endif
969 : : #ifndef OPENSSL_NO_ECDH
970 : 894 : EC_KEY *ecdh = NULL;
971 : : #endif
972 : : #ifndef OPENSSL_NO_SRP
973 : : /* client */
974 : 894 : SRP_CLIENT_ARG srp_client_arg = {NULL,NULL};
975 : : /* server */
976 : 894 : SRP_SERVER_ARG srp_server_arg = {NULL,NULL};
977 : : #endif
978 : 894 : int no_dhe = 0;
979 : 894 : int no_ecdhe = 0;
980 : 894 : int no_psk = 0;
981 : 894 : int print_time = 0;
982 : 894 : clock_t s_time = 0, c_time = 0;
983 : : #ifndef OPENSSL_NO_COMP
984 : 894 : int comp = 0;
985 : 894 : COMP_METHOD *cm = NULL;
986 : 894 : STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
987 : : #endif
988 : 894 : int test_cipherlist = 0;
989 : : #ifdef OPENSSL_FIPS
990 : : int fips_mode=0;
991 : : #endif
992 : :
993 : 894 : verbose = 0;
994 : 894 : debug = 0;
995 : 894 : cipher = 0;
996 : :
997 : 894 : bio_err=BIO_new_fp(stderr,BIO_NOCLOSE|BIO_FP_TEXT);
998 : :
999 : 894 : CRYPTO_set_locking_callback(lock_dbg_cb);
1000 : :
1001 : : /* enable memory leak checking unless explicitly disabled */
1002 [ + - ][ + - ]: 894 : if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))
1003 : : {
1004 : 894 : CRYPTO_malloc_debug_init();
1005 : 894 : CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
1006 : : }
1007 : : else
1008 : : {
1009 : : /* OPENSSL_DEBUG_MEMORY=off */
1010 : 0 : CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
1011 : : }
1012 : 894 : CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
1013 : :
1014 : 894 : RAND_seed(rnd_seed, sizeof rnd_seed);
1015 : :
1016 : 894 : bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE|BIO_FP_TEXT);
1017 : :
1018 : 894 : argc--;
1019 : 894 : argv++;
1020 : :
1021 [ + + ]: 8302 : while (argc >= 1)
1022 : : {
1023 [ - + ]: 7408 : if(!strcmp(*argv,"-F"))
1024 : : {
1025 : : #ifdef OPENSSL_FIPS
1026 : : fips_mode=1;
1027 : : #else
1028 : 0 : fprintf(stderr,"not compiled with FIPS support, so exitting without running.\n");
1029 : 0 : EXIT(0);
1030 : : #endif
1031 : : }
1032 [ + + ]: 7408 : else if (strcmp(*argv,"-server_auth") == 0)
1033 : : server_auth=1;
1034 [ + + ]: 7243 : else if (strcmp(*argv,"-client_auth") == 0)
1035 : : client_auth=1;
1036 [ + + ]: 7100 : else if (strcmp(*argv,"-proxy_auth") == 0)
1037 : : {
1038 [ + - ]: 364 : if (--argc < 1) goto bad;
1039 : 364 : app_verify_arg.proxy_auth= *(++argv);
1040 : : }
1041 [ + + ]: 6736 : else if (strcmp(*argv,"-proxy_cond") == 0)
1042 : : {
1043 [ + - ]: 364 : if (--argc < 1) goto bad;
1044 : 364 : app_verify_arg.proxy_cond= *(++argv);
1045 : : }
1046 [ + + ]: 6372 : else if (strcmp(*argv,"-v") == 0)
1047 : 44 : verbose=1;
1048 [ - + ]: 6328 : else if (strcmp(*argv,"-d") == 0)
1049 : 0 : debug=1;
1050 [ + + ]: 6328 : else if (strcmp(*argv,"-reuse") == 0)
1051 : : reuse=1;
1052 [ + - ]: 6317 : else if (strcmp(*argv,"-dhe1024") == 0)
1053 : : {
1054 : : #ifndef OPENSSL_NO_DH
1055 : : dhe1024=1;
1056 : : #else
1057 : : fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
1058 : : #endif
1059 : : }
1060 [ + + ]: 6317 : else if (strcmp(*argv,"-dhe1024dsa") == 0)
1061 : : {
1062 : : #ifndef OPENSSL_NO_DH
1063 : : dhe1024dsa=1;
1064 : : #else
1065 : : fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
1066 : : #endif
1067 : : }
1068 [ + + ]: 6284 : else if (strcmp(*argv,"-no_dhe") == 0)
1069 : : no_dhe=1;
1070 [ + + ]: 6262 : else if (strcmp(*argv,"-no_ecdhe") == 0)
1071 : : no_ecdhe=1;
1072 [ + + ]: 6240 : else if (strcmp(*argv,"-psk") == 0)
1073 : : {
1074 [ + - ]: 22 : if (--argc < 1) goto bad;
1075 : 22 : psk_key=*(++argv);
1076 : : #ifndef OPENSSL_NO_PSK
1077 [ - + ]: 22 : if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key))
1078 : : {
1079 : 0 : BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
1080 : 0 : goto bad;
1081 : : }
1082 : : #else
1083 : : no_psk=1;
1084 : : #endif
1085 : : }
1086 : : #ifndef OPENSSL_NO_SRP
1087 [ + + ]: 6218 : else if (strcmp(*argv,"-srpuser") == 0)
1088 : : {
1089 [ + - ]: 22 : if (--argc < 1) goto bad;
1090 : 22 : srp_server_arg.expected_user = srp_client_arg.srplogin= *(++argv);
1091 : 22 : tls1=1;
1092 : : }
1093 [ + + ]: 6196 : else if (strcmp(*argv,"-srppass") == 0)
1094 : : {
1095 [ + - ]: 22 : if (--argc < 1) goto bad;
1096 : 22 : srp_server_arg.pass = srp_client_arg.srppassin= *(++argv);
1097 : 22 : tls1=1;
1098 : : }
1099 : : #endif
1100 [ + + ]: 6174 : else if (strcmp(*argv,"-ssl2") == 0)
1101 : : ssl2=1;
1102 [ + + ]: 6042 : else if (strcmp(*argv,"-tls1") == 0)
1103 : : tls1=1;
1104 [ + + ]: 5734 : else if (strcmp(*argv,"-ssl3") == 0)
1105 : : ssl3=1;
1106 [ + + ]: 5481 : else if (strncmp(*argv,"-num",4) == 0)
1107 : : {
1108 [ + - ]: 55 : if (--argc < 1) goto bad;
1109 : 55 : number= atoi(*(++argv));
1110 [ - + ]: 55 : if (number == 0) number=1;
1111 : : }
1112 [ + + ]: 5426 : else if (strcmp(*argv,"-bytes") == 0)
1113 : : {
1114 [ + - ]: 2 : if (--argc < 1) goto bad;
1115 : 2 : bytes= atol(*(++argv));
1116 [ - + ]: 2 : if (bytes == 0L) bytes=1L;
1117 : 2 : i=strlen(argv[0]);
1118 [ - + ]: 2 : if (argv[0][i-1] == 'k') bytes*=1024L;
1119 [ + - ]: 2 : if (argv[0][i-1] == 'm') bytes*=1024L*1024L;
1120 : : }
1121 [ + + ]: 5424 : else if (strcmp(*argv,"-cert") == 0)
1122 : : {
1123 [ + - ]: 893 : if (--argc < 1) goto bad;
1124 : 893 : server_cert= *(++argv);
1125 : : }
1126 [ - + ]: 4531 : else if (strcmp(*argv,"-s_cert") == 0)
1127 : : {
1128 [ # # ]: 0 : if (--argc < 1) goto bad;
1129 : 0 : server_cert= *(++argv);
1130 : : }
1131 [ + + ]: 4531 : else if (strcmp(*argv,"-key") == 0)
1132 : : {
1133 [ + - ]: 871 : if (--argc < 1) goto bad;
1134 : 871 : server_key= *(++argv);
1135 : : }
1136 [ - + ]: 3660 : else if (strcmp(*argv,"-s_key") == 0)
1137 : : {
1138 [ # # ]: 0 : if (--argc < 1) goto bad;
1139 : 0 : server_key= *(++argv);
1140 : : }
1141 [ + + ]: 3660 : else if (strcmp(*argv,"-c_cert") == 0)
1142 : : {
1143 [ + - ]: 871 : if (--argc < 1) goto bad;
1144 : 871 : client_cert= *(++argv);
1145 : : }
1146 [ + + ]: 2789 : else if (strcmp(*argv,"-c_key") == 0)
1147 : : {
1148 [ + - ]: 871 : if (--argc < 1) goto bad;
1149 : 871 : client_key= *(++argv);
1150 : : }
1151 [ + + ]: 1918 : else if (strcmp(*argv,"-cipher") == 0)
1152 : : {
1153 [ + - ]: 299 : if (--argc < 1) goto bad;
1154 : 299 : cipher= *(++argv);
1155 : : }
1156 [ - + ]: 1619 : else if (strcmp(*argv,"-CApath") == 0)
1157 : : {
1158 [ # # ]: 0 : if (--argc < 1) goto bad;
1159 : 0 : CApath= *(++argv);
1160 : : }
1161 [ + + ]: 1619 : else if (strcmp(*argv,"-CAfile") == 0)
1162 : : {
1163 [ + - ]: 231 : if (--argc < 1) goto bad;
1164 : 231 : CAfile= *(++argv);
1165 : : }
1166 [ + + ]: 1388 : else if (strcmp(*argv,"-bio_pair") == 0)
1167 : : {
1168 : : bio_pair = 1;
1169 : : }
1170 [ + + ]: 948 : else if (strcmp(*argv,"-f") == 0)
1171 : : {
1172 : : force = 1;
1173 : : }
1174 [ + + ]: 915 : else if (strcmp(*argv,"-time") == 0)
1175 : : {
1176 : : print_time = 1;
1177 : : }
1178 : : #ifndef OPENSSL_NO_COMP
1179 [ + - ]: 882 : else if (strcmp(*argv,"-zlib") == 0)
1180 : : {
1181 : : comp = COMP_ZLIB;
1182 : : }
1183 [ + - ]: 882 : else if (strcmp(*argv,"-rle") == 0)
1184 : : {
1185 : : comp = COMP_RLE;
1186 : : }
1187 : : #endif
1188 [ - + ]: 882 : else if (strcmp(*argv,"-named_curve") == 0)
1189 : : {
1190 [ # # ]: 0 : if (--argc < 1) goto bad;
1191 : : #ifndef OPENSSL_NO_ECDH
1192 : 0 : named_curve = *(++argv);
1193 : : #else
1194 : : fprintf(stderr,"ignoring -named_curve, since I'm compiled without ECDH\n");
1195 : : ++argv;
1196 : : #endif
1197 : : }
1198 [ + + ]: 882 : else if (strcmp(*argv,"-app_verify") == 0)
1199 : : {
1200 : 11 : app_verify_arg.app_verify = 1;
1201 : : }
1202 [ + + ]: 871 : else if (strcmp(*argv,"-proxy") == 0)
1203 : : {
1204 : 364 : app_verify_arg.allow_proxy_certs = 1;
1205 : : }
1206 [ + + ]: 507 : else if (strcmp(*argv,"-test_cipherlist") == 0)
1207 : : {
1208 : : test_cipherlist = 1;
1209 : : }
1210 : : #ifndef OPENSSL_NO_NEXTPROTONEG
1211 [ + + ]: 506 : else if (strcmp(*argv,"-npn_client") == 0)
1212 : : {
1213 : 55 : npn_client = 1;
1214 : : }
1215 [ + + ]: 451 : else if (strcmp(*argv,"-npn_server") == 0)
1216 : : {
1217 : 44 : npn_server = 1;
1218 : : }
1219 [ + + ]: 407 : else if (strcmp(*argv,"-npn_server_reject") == 0)
1220 : : {
1221 : 22 : npn_server_reject = 1;
1222 : : }
1223 : : #endif
1224 [ + + ]: 385 : else if (strcmp(*argv,"-serverinfo_sct") == 0)
1225 : : {
1226 : 33 : serverinfo_sct = 1;
1227 : : }
1228 [ + + ]: 352 : else if (strcmp(*argv,"-serverinfo_tack") == 0)
1229 : : {
1230 : 33 : serverinfo_tack = 1;
1231 : : }
1232 [ + + ]: 319 : else if (strcmp(*argv,"-serverinfo_file") == 0)
1233 : : {
1234 [ + - ]: 55 : if (--argc < 1) goto bad;
1235 : 55 : serverinfo_file = *(++argv);
1236 : : }
1237 [ + + ]: 264 : else if (strcmp(*argv,"-custom_ext") == 0)
1238 : : {
1239 : 22 : custom_ext = 1;
1240 : : }
1241 [ + + ]: 242 : else if (strcmp(*argv,"-alpn_client") == 0)
1242 : : {
1243 [ + - ]: 88 : if (--argc < 1) goto bad;
1244 : 88 : alpn_client = *(++argv);
1245 : : }
1246 [ + + ]: 154 : else if (strcmp(*argv,"-alpn_server") == 0)
1247 : : {
1248 [ + - ]: 88 : if (--argc < 1) goto bad;
1249 : 88 : alpn_server = *(++argv);
1250 : : }
1251 [ + - ]: 66 : else if (strcmp(*argv,"-alpn_expected") == 0)
1252 : : {
1253 [ + - ]: 66 : if (--argc < 1) goto bad;
1254 : 66 : alpn_expected = *(++argv);
1255 : : }
1256 : : else
1257 : : {
1258 : 0 : fprintf(stderr,"unknown option %s\n",*argv);
1259 : 0 : badop=1;
1260 : 0 : break;
1261 : : }
1262 : 7408 : argc--;
1263 : 7408 : argv++;
1264 : : }
1265 [ - + ]: 894 : if (badop)
1266 : : {
1267 : : bad:
1268 : 0 : sv_usage();
1269 : 0 : goto end;
1270 : : }
1271 : :
1272 [ + + ]: 894 : if (test_cipherlist == 1)
1273 : : {
1274 : : /* ensure that the cipher list are correctly sorted and exit */
1275 [ - + ]: 1 : if (do_test_cipherlist() == 0)
1276 : 0 : EXIT(1);
1277 : : ret = 0;
1278 : : goto end;
1279 : : }
1280 : :
1281 [ + + ][ - + ]: 893 : if (!ssl2 && !ssl3 && !tls1 && number > 1 && !reuse && !force)
[ # # ]
1282 : : {
1283 : 0 : fprintf(stderr, "This case cannot work. Use -f to perform "
1284 : : "the test anyway (and\n-d to see what happens), "
1285 : : "or add one of -ssl2, -ssl3, -tls1, -reuse\n"
1286 : : "to avoid protocol mismatch.\n");
1287 : 0 : EXIT(1);
1288 : : }
1289 : :
1290 : : #ifdef OPENSSL_FIPS
1291 : : if(fips_mode)
1292 : : {
1293 : : if(!FIPS_mode_set(1))
1294 : : {
1295 : : ERR_load_crypto_strings();
1296 : : ERR_print_errors(BIO_new_fp(stderr,BIO_NOCLOSE));
1297 : : EXIT(1);
1298 : : }
1299 : : else
1300 : : fprintf(stderr,"*** IN FIPS MODE ***\n");
1301 : : }
1302 : : #endif
1303 : :
1304 [ + + ]: 893 : if (print_time)
1305 : : {
1306 [ - + ]: 33 : if (!bio_pair)
1307 : : {
1308 : 0 : fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1309 : 0 : bio_pair = 1;
1310 : : }
1311 [ - + ]: 33 : if (number < 50 && !force)
1312 : 0 : fprintf(stderr, "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1313 : : }
1314 : :
1315 : : /* if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1316 : :
1317 : 893 : SSL_library_init();
1318 : 893 : SSL_load_error_strings();
1319 : :
1320 : : #ifndef OPENSSL_NO_COMP
1321 [ - + ]: 893 : if (comp == COMP_ZLIB) cm = COMP_zlib();
1322 [ - + ]: 893 : if (comp == COMP_RLE) cm = COMP_rle();
1323 [ - + ]: 893 : if (cm != NULL)
1324 : : {
1325 [ # # ]: 0 : if (cm->type != NID_undef)
1326 : : {
1327 [ # # ]: 0 : if (SSL_COMP_add_compression_method(comp, cm) != 0)
1328 : : {
1329 : 0 : fprintf(stderr,
1330 : : "Failed to add compression method\n");
1331 : 0 : ERR_print_errors_fp(stderr);
1332 : : }
1333 : : }
1334 : : else
1335 : : {
1336 [ # # ]: 0 : fprintf(stderr,
1337 : : "Warning: %s compression not supported\n",
1338 : : (comp == COMP_RLE ? "rle" :
1339 [ # # ]: 0 : (comp == COMP_ZLIB ? "zlib" :
1340 : : "unknown")));
1341 : 0 : ERR_print_errors_fp(stderr);
1342 : : }
1343 : : }
1344 : 893 : ssl_comp_methods = SSL_COMP_get_compression_methods();
1345 : 893 : fprintf(stderr, "Available compression methods:\n");
1346 : : {
1347 : 893 : int j, n = sk_SSL_COMP_num(ssl_comp_methods);
1348 [ - + ]: 893 : if (n == 0)
1349 : 893 : fprintf(stderr, " NONE\n");
1350 : : else
1351 [ # # ]: 0 : for (j = 0; j < n; j++)
1352 : : {
1353 : 0 : SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1354 : 0 : fprintf(stderr, " %d: %s\n", c->id, c->name);
1355 : : }
1356 : : }
1357 : : #endif
1358 : :
1359 : : #if !defined(OPENSSL_NO_SSL2) && !defined(OPENSSL_NO_SSL3)
1360 [ + + ]: 893 : if (ssl2)
1361 : 132 : meth=SSLv2_method();
1362 : : else
1363 [ + + ]: 761 : if (tls1)
1364 : 308 : meth=TLSv1_method();
1365 : : else
1366 [ + + ]: 453 : if (ssl3)
1367 : 253 : meth=SSLv3_method();
1368 : : else
1369 : 200 : meth=SSLv23_method();
1370 : : #else
1371 : : #ifdef OPENSSL_NO_SSL2
1372 : : if (tls1)
1373 : : meth=TLSv1_method();
1374 : : else
1375 : : if (ssl3)
1376 : : meth=SSLv3_method();
1377 : : else
1378 : : meth=SSLv23_method();
1379 : : #else
1380 : : meth=SSLv2_method();
1381 : : #endif
1382 : : #endif
1383 : :
1384 : 893 : c_ctx=SSL_CTX_new(meth);
1385 : 893 : s_ctx=SSL_CTX_new(meth);
1386 [ - + ]: 893 : if ((c_ctx == NULL) || (s_ctx == NULL))
1387 : : {
1388 : 0 : ERR_print_errors(bio_err);
1389 : 0 : goto end;
1390 : : }
1391 : : /* Since we will use low security ciphersuites and keys for
1392 : : * testing set security level to zero.
1393 : : */
1394 : 893 : SSL_CTX_set_security_level(c_ctx, 0);
1395 : 893 : SSL_CTX_set_security_level(s_ctx, 0);
1396 : :
1397 [ + + ]: 893 : if (cipher != NULL)
1398 : : {
1399 : 299 : SSL_CTX_set_cipher_list(c_ctx,cipher);
1400 : 299 : SSL_CTX_set_cipher_list(s_ctx,cipher);
1401 : : }
1402 : :
1403 : : #ifndef OPENSSL_NO_DH
1404 [ + + ]: 893 : if (!no_dhe)
1405 : : {
1406 [ + + ]: 871 : if (dhe1024dsa)
1407 : : {
1408 : : /* use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks */
1409 : 33 : SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1410 : 33 : dh=get_dh1024dsa();
1411 : : }
1412 [ - + ]: 838 : else if (dhe1024)
1413 : 0 : dh=get_dh1024();
1414 : : else
1415 : 838 : dh=get_dh512();
1416 : 871 : SSL_CTX_set_tmp_dh(s_ctx,dh);
1417 : 871 : DH_free(dh);
1418 : : }
1419 : : #else
1420 : : (void)no_dhe;
1421 : : #endif
1422 : :
1423 : : #ifndef OPENSSL_NO_ECDH
1424 [ + + ]: 893 : if (!no_ecdhe)
1425 : : {
1426 : : int nid;
1427 : :
1428 [ - + ]: 871 : if (named_curve != NULL)
1429 : : {
1430 : 0 : nid = OBJ_sn2nid(named_curve);
1431 [ # # ]: 0 : if (nid == 0)
1432 : : {
1433 : 0 : BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1434 : 0 : goto end;
1435 : : }
1436 : : }
1437 : : else
1438 : : #ifdef OPENSSL_NO_EC2M
1439 : : nid = NID_X9_62_prime256v1;
1440 : : #else
1441 : : nid = NID_sect163r2;
1442 : : #endif
1443 : :
1444 : 871 : ecdh = EC_KEY_new_by_curve_name(nid);
1445 [ - + ]: 871 : if (ecdh == NULL)
1446 : : {
1447 : 0 : BIO_printf(bio_err, "unable to create curve\n");
1448 : 0 : goto end;
1449 : : }
1450 : :
1451 : 871 : SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1452 : 871 : SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1453 : 871 : EC_KEY_free(ecdh);
1454 : : }
1455 : : #else
1456 : : (void)no_ecdhe;
1457 : : #endif
1458 : :
1459 : : #ifndef OPENSSL_NO_RSA
1460 : 893 : SSL_CTX_set_tmp_rsa_callback(s_ctx,tmp_rsa_cb);
1461 : : #endif
1462 : :
1463 : : #ifdef TLSEXT_TYPE_opaque_prf_input
1464 : : SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
1465 : : SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
1466 : : SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1); /* or &co2 or NULL */
1467 : : SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1); /* or &so2 or NULL */
1468 : : #endif
1469 : :
1470 [ - + ]: 893 : if (!SSL_CTX_use_certificate_file(s_ctx,server_cert,SSL_FILETYPE_PEM))
1471 : : {
1472 : 0 : ERR_print_errors(bio_err);
1473 : : }
1474 [ + + ][ - + ]: 893 : else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
1475 : : (server_key?server_key:server_cert), SSL_FILETYPE_PEM))
1476 : : {
1477 : 0 : ERR_print_errors(bio_err);
1478 : 0 : goto end;
1479 : : }
1480 : :
1481 [ + + ]: 893 : if (client_auth)
1482 : : {
1483 : 143 : SSL_CTX_use_certificate_file(c_ctx,client_cert,
1484 : : SSL_FILETYPE_PEM);
1485 [ - + ]: 143 : SSL_CTX_use_PrivateKey_file(c_ctx,
1486 : : (client_key?client_key:client_cert),
1487 : : SSL_FILETYPE_PEM);
1488 : : }
1489 : :
1490 [ + + + - ]: 1124 : if ( (!SSL_CTX_load_verify_locations(s_ctx,CAfile,CApath)) ||
1491 [ + - ]: 462 : (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1492 [ - + ]: 462 : (!SSL_CTX_load_verify_locations(c_ctx,CAfile,CApath)) ||
1493 : 231 : (!SSL_CTX_set_default_verify_paths(c_ctx)))
1494 : : {
1495 : : /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1496 : 662 : ERR_print_errors(bio_err);
1497 : : /* goto end; */
1498 : : }
1499 : :
1500 [ + + ]: 893 : if (client_auth)
1501 : : {
1502 : 143 : BIO_printf(bio_err,"client authentication\n");
1503 : 143 : SSL_CTX_set_verify(s_ctx,
1504 : : SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1505 : : verify_callback);
1506 : 143 : SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback, &app_verify_arg);
1507 : : }
1508 [ + + ]: 893 : if (server_auth)
1509 : : {
1510 : 165 : BIO_printf(bio_err,"server authentication\n");
1511 : 165 : SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
1512 : : verify_callback);
1513 : 165 : SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback, &app_verify_arg);
1514 : : }
1515 : :
1516 : : {
1517 : 893 : int session_id_context = 0;
1518 : 893 : SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context, sizeof session_id_context);
1519 : : }
1520 : :
1521 : : /* Use PSK only if PSK key is given */
1522 [ + + ]: 893 : if (psk_key != NULL)
1523 : : {
1524 : : /* no_psk is used to avoid putting psk command to openssl tool */
1525 : : if (no_psk)
1526 : : {
1527 : : /* if PSK is not compiled in and psk key is
1528 : : * given, do nothing and exit successfully */
1529 : : ret=0;
1530 : : goto end;
1531 : : }
1532 : : #ifndef OPENSSL_NO_PSK
1533 : 22 : SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1534 : 22 : SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1535 [ - + ]: 22 : if (debug)
1536 : 0 : BIO_printf(bio_err,"setting PSK identity hint to s_ctx\n");
1537 [ - + ]: 22 : if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint"))
1538 : : {
1539 : 0 : BIO_printf(bio_err,"error setting PSK identity hint to s_ctx\n");
1540 : 0 : ERR_print_errors(bio_err);
1541 : 0 : goto end;
1542 : : }
1543 : : #endif
1544 : : }
1545 : : #ifndef OPENSSL_NO_SRP
1546 [ + + ]: 893 : if (srp_client_arg.srplogin)
1547 : : {
1548 [ - + ]: 22 : if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin))
1549 : : {
1550 : 0 : BIO_printf(bio_err,"Unable to set SRP username\n");
1551 : 0 : goto end;
1552 : : }
1553 : 22 : SSL_CTX_set_srp_cb_arg(c_ctx,&srp_client_arg);
1554 : 22 : SSL_CTX_set_srp_client_pwd_callback(c_ctx, ssl_give_srp_client_pwd_cb);
1555 : : /*SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);*/
1556 : : }
1557 : :
1558 [ + + ]: 893 : if (srp_server_arg.expected_user != NULL)
1559 : : {
1560 : 22 : SSL_CTX_set_verify(s_ctx,SSL_VERIFY_NONE,verify_callback);
1561 : 22 : SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1562 : 22 : SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1563 : : }
1564 : : #endif
1565 : :
1566 : : #ifndef OPENSSL_NO_NEXTPROTONEG
1567 [ + + ]: 893 : if (npn_client)
1568 : : {
1569 : 55 : SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1570 : : }
1571 [ + + ]: 893 : if (npn_server)
1572 : : {
1573 [ - + ]: 44 : if (npn_server_reject)
1574 : : {
1575 : 0 : BIO_printf(bio_err, "Can't have both -npn_server and -npn_server_reject\n");
1576 : 0 : goto end;
1577 : : }
1578 : 44 : SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1579 : : }
1580 [ + + ]: 893 : if (npn_server_reject)
1581 : : {
1582 : 22 : SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn, NULL);
1583 : : }
1584 : : #endif
1585 : :
1586 [ + + ]: 893 : if (serverinfo_sct)
1587 : 33 : SSL_CTX_set_custom_cli_ext(c_ctx, SCT_EXT_TYPE, NULL,
1588 : : serverinfo_cli_cb, NULL);
1589 [ + + ]: 893 : if (serverinfo_tack)
1590 : 33 : SSL_CTX_set_custom_cli_ext(c_ctx, TACK_EXT_TYPE, NULL,
1591 : : serverinfo_cli_cb, NULL);
1592 : :
1593 [ + + ]: 893 : if (serverinfo_file)
1594 [ - + ]: 55 : if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file))
1595 : : {
1596 : 0 : BIO_printf(bio_err, "missing serverinfo file\n");
1597 : 0 : goto end;
1598 : : }
1599 : :
1600 [ + + ]: 893 : if (custom_ext)
1601 : : {
1602 : 22 : SSL_CTX_set_custom_cli_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1603 : : custom_ext_0_cli_first_cb,
1604 : : custom_ext_0_cli_second_cb, NULL);
1605 : 22 : SSL_CTX_set_custom_cli_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1606 : : custom_ext_1_cli_first_cb,
1607 : : custom_ext_1_cli_second_cb, NULL);
1608 : 22 : SSL_CTX_set_custom_cli_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1609 : : custom_ext_2_cli_first_cb,
1610 : : custom_ext_2_cli_second_cb, NULL);
1611 : 22 : SSL_CTX_set_custom_cli_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1612 : : custom_ext_3_cli_first_cb,
1613 : : custom_ext_3_cli_second_cb, NULL);
1614 : :
1615 : :
1616 : 22 : SSL_CTX_set_custom_srv_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1617 : : custom_ext_0_srv_first_cb,
1618 : : custom_ext_0_srv_second_cb, NULL);
1619 : 22 : SSL_CTX_set_custom_srv_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1620 : : custom_ext_1_srv_first_cb,
1621 : : custom_ext_1_srv_second_cb, NULL);
1622 : 22 : SSL_CTX_set_custom_srv_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1623 : : custom_ext_2_srv_first_cb,
1624 : : custom_ext_2_srv_second_cb, NULL);
1625 : 22 : SSL_CTX_set_custom_srv_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1626 : : custom_ext_3_srv_first_cb,
1627 : : custom_ext_3_srv_second_cb, NULL);
1628 : : }
1629 : :
1630 [ + + ]: 893 : if (alpn_server)
1631 : 88 : SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
1632 : :
1633 [ + + ]: 893 : if (alpn_client)
1634 : : {
1635 : : unsigned short alpn_len;
1636 : 88 : unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1637 : :
1638 [ - + ]: 88 : if (alpn == NULL)
1639 : : {
1640 : 0 : BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1641 : 0 : goto end;
1642 : : }
1643 : 88 : SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len);
1644 : 88 : OPENSSL_free(alpn);
1645 : : }
1646 : :
1647 : 893 : c_ssl=SSL_new(c_ctx);
1648 : 893 : s_ssl=SSL_new(s_ctx);
1649 : :
1650 : : #ifndef OPENSSL_NO_KRB5
1651 : : if (c_ssl && c_ssl->kssl_ctx)
1652 : : {
1653 : : char localhost[MAXHOSTNAMELEN+2];
1654 : :
1655 : : if (gethostname(localhost, sizeof localhost-1) == 0)
1656 : : {
1657 : : localhost[sizeof localhost-1]='\0';
1658 : : if(strlen(localhost) == sizeof localhost-1)
1659 : : {
1660 : : BIO_printf(bio_err,"localhost name too long\n");
1661 : : goto end;
1662 : : }
1663 : : kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER,
1664 : : localhost);
1665 : : }
1666 : : }
1667 : : #endif /* OPENSSL_NO_KRB5 */
1668 : :
1669 [ + + ]: 2105 : for (i=0; i<number; i++)
1670 : : {
1671 [ + + ]: 1212 : if (!reuse) SSL_set_session(c_ssl,NULL);
1672 [ + + ]: 1212 : if (bio_pair)
1673 : 759 : ret=doit_biopair(s_ssl,c_ssl,bytes,&s_time,&c_time);
1674 : : else
1675 : 453 : ret=doit(s_ssl,c_ssl,bytes);
1676 : : }
1677 : :
1678 [ + + ]: 893 : if (!verbose)
1679 : : {
1680 : 849 : print_details(c_ssl, "");
1681 : : }
1682 [ + - ]: 893 : if ((number > 1) || (bytes > 1L))
1683 : 893 : BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n",number,bytes);
1684 [ + + ]: 893 : if (print_time)
1685 : : {
1686 : : #ifdef CLOCKS_PER_SEC
1687 : : /* "To determine the time in seconds, the value returned
1688 : : * by the clock function should be divided by the value
1689 : : * of the macro CLOCKS_PER_SEC."
1690 : : * -- ISO/IEC 9899 */
1691 : 33 : BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1692 : : "Approximate total client time: %6.2f s\n",
1693 : 33 : (double)s_time/CLOCKS_PER_SEC,
1694 : 33 : (double)c_time/CLOCKS_PER_SEC);
1695 : : #else
1696 : : /* "`CLOCKS_PER_SEC' undeclared (first use this function)"
1697 : : * -- cc on NeXTstep/OpenStep */
1698 : : BIO_printf(bio_stdout,
1699 : : "Approximate total server time: %6.2f units\n"
1700 : : "Approximate total client time: %6.2f units\n",
1701 : : (double)s_time,
1702 : : (double)c_time);
1703 : : #endif
1704 : : }
1705 : :
1706 : 893 : SSL_free(s_ssl);
1707 : 893 : SSL_free(c_ssl);
1708 : :
1709 : : end:
1710 [ + + ]: 894 : if (s_ctx != NULL) SSL_CTX_free(s_ctx);
1711 [ + + ]: 894 : if (c_ctx != NULL) SSL_CTX_free(c_ctx);
1712 : :
1713 [ + - ]: 894 : if (bio_stdout != NULL) BIO_free(bio_stdout);
1714 : :
1715 : : #ifndef OPENSSL_NO_RSA
1716 : 894 : free_tmp_rsa();
1717 : : #endif
1718 : : #ifndef OPENSSL_NO_ENGINE
1719 : 894 : ENGINE_cleanup();
1720 : : #endif
1721 : 894 : CRYPTO_cleanup_all_ex_data();
1722 : 894 : ERR_free_strings();
1723 : 894 : ERR_remove_thread_state(NULL);
1724 : 894 : EVP_cleanup();
1725 : 894 : CRYPTO_mem_leaks(bio_err);
1726 [ + - ]: 894 : if (bio_err != NULL) BIO_free(bio_err);
1727 : 894 : EXIT(ret);
1728 : : return ret;
1729 : : }
1730 : :
1731 : 759 : int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1732 : : clock_t *s_time, clock_t *c_time)
1733 : : {
1734 : 759 : long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1735 : 759 : BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1736 : 759 : BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1737 : 759 : int ret = 1;
1738 : :
1739 : 759 : size_t bufsiz = 256; /* small buffer for testing */
1740 : :
1741 [ + - ]: 759 : if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1742 : : goto err;
1743 [ + - ]: 759 : if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1744 : : goto err;
1745 : :
1746 : 759 : s_ssl_bio = BIO_new(BIO_f_ssl());
1747 [ + - ]: 759 : if (!s_ssl_bio)
1748 : : goto err;
1749 : :
1750 : 759 : c_ssl_bio = BIO_new(BIO_f_ssl());
1751 [ + - ]: 759 : if (!c_ssl_bio)
1752 : : goto err;
1753 : :
1754 : 759 : SSL_set_connect_state(c_ssl);
1755 : 759 : SSL_set_bio(c_ssl, client, client);
1756 : 759 : (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1757 : :
1758 : 759 : SSL_set_accept_state(s_ssl);
1759 : 759 : SSL_set_bio(s_ssl, server, server);
1760 : 25109 : (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1761 : :
1762 : : do
1763 : : {
1764 : : /* c_ssl_bio: SSL filter BIO
1765 : : *
1766 : : * client: pseudo-I/O for SSL library
1767 : : *
1768 : : * client_io: client's SSL communication; usually to be
1769 : : * relayed over some I/O facility, but in this
1770 : : * test program, we're the server, too:
1771 : : *
1772 : : * server_io: server's SSL communication
1773 : : *
1774 : : * server: pseudo-I/O for SSL library
1775 : : *
1776 : : * s_ssl_bio: SSL filter BIO
1777 : : *
1778 : : * The client and the server each employ a "BIO pair":
1779 : : * client + client_io, server + server_io.
1780 : : * BIO pairs are symmetric. A BIO pair behaves similar
1781 : : * to a non-blocking socketpair (but both endpoints must
1782 : : * be handled by the same thread).
1783 : : * [Here we could connect client and server to the ends
1784 : : * of a single BIO pair, but then this code would be less
1785 : : * suitable as an example for BIO pairs in general.]
1786 : : *
1787 : : * Useful functions for querying the state of BIO pair endpoints:
1788 : : *
1789 : : * BIO_ctrl_pending(bio) number of bytes we can read now
1790 : : * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
1791 : : * other side's read attempt
1792 : : * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
1793 : : *
1794 : : * ..._read_request is never more than ..._write_guarantee;
1795 : : * it depends on the application which one you should use.
1796 : : */
1797 : :
1798 : : /* We have non-blocking behaviour throughout this test program, but
1799 : : * can be sure that there is *some* progress in each iteration; so
1800 : : * we don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE
1801 : : * -- we just try everything in each iteration
1802 : : */
1803 : :
1804 : : {
1805 : : /* CLIENT */
1806 : :
1807 : : MS_STATIC char cbuf[1024*8];
1808 : : int i, r;
1809 : 25109 : clock_t c_clock = clock();
1810 : :
1811 : : memset(cbuf, 0, sizeof(cbuf));
1812 : :
1813 [ - + ]: 25109 : if (debug)
1814 [ # # ]: 0 : if (SSL_in_init(c_ssl))
1815 : 0 : printf("client waiting in SSL_connect - %s\n",
1816 : : SSL_state_string_long(c_ssl));
1817 : :
1818 [ + + ]: 25109 : if (cw_num > 0)
1819 : : {
1820 : : /* Write to server. */
1821 : :
1822 [ + - ]: 23591 : if (cw_num > (long)sizeof cbuf)
1823 : : i = sizeof cbuf;
1824 : : else
1825 : 23591 : i = (int)cw_num;
1826 : 23591 : r = BIO_write(c_ssl_bio, cbuf, i);
1827 [ + + ]: 23591 : if (r < 0)
1828 : : {
1829 [ - + ]: 22832 : if (!BIO_should_retry(c_ssl_bio))
1830 : : {
1831 : 0 : fprintf(stderr,"ERROR in CLIENT\n");
1832 : 0 : goto err;
1833 : : }
1834 : : /* BIO_should_retry(...) can just be ignored here.
1835 : : * The library expects us to call BIO_write with
1836 : : * the same arguments again, and that's what we will
1837 : : * do in the next iteration. */
1838 : : }
1839 [ - + ]: 759 : else if (r == 0)
1840 : : {
1841 : 0 : fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1842 : : goto err;
1843 : : }
1844 : : else
1845 : : {
1846 [ - + ]: 759 : if (debug)
1847 : : printf("client wrote %d\n", r);
1848 : 759 : cw_num -= r;
1849 : : }
1850 : : }
1851 : :
1852 [ + + ]: 25109 : if (cr_num > 0)
1853 : : {
1854 : : /* Read from server. */
1855 : :
1856 : 20071 : r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1857 [ + + ]: 20071 : if (r < 0)
1858 : : {
1859 [ - + ]: 19312 : if (!BIO_should_retry(c_ssl_bio))
1860 : : {
1861 : 0 : fprintf(stderr,"ERROR in CLIENT\n");
1862 : : goto err;
1863 : : }
1864 : : /* Again, "BIO_should_retry" can be ignored. */
1865 : : }
1866 [ - + ]: 759 : else if (r == 0)
1867 : : {
1868 : 0 : fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1869 : : goto err;
1870 : : }
1871 : : else
1872 : : {
1873 [ - + ]: 759 : if (debug)
1874 : : printf("client read %d\n", r);
1875 : 759 : cr_num -= r;
1876 : : }
1877 : : }
1878 : :
1879 : : /* c_time and s_time increments will typically be very small
1880 : : * (depending on machine speed and clock tick intervals),
1881 : : * but sampling over a large number of connections should
1882 : : * result in fairly accurate figures. We cannot guarantee
1883 : : * a lot, however -- if each connection lasts for exactly
1884 : : * one clock tick, it will be counted only for the client
1885 : : * or only for the server or even not at all.
1886 : : */
1887 : 25109 : *c_time += (clock() - c_clock);
1888 : : }
1889 : :
1890 : : {
1891 : : /* SERVER */
1892 : :
1893 : : MS_STATIC char sbuf[1024*8];
1894 : : int i, r;
1895 : 25109 : clock_t s_clock = clock();
1896 : :
1897 : : memset(sbuf, 0, sizeof(sbuf));
1898 : :
1899 [ - + ]: 25109 : if (debug)
1900 [ # # ]: 0 : if (SSL_in_init(s_ssl))
1901 : 0 : printf("server waiting in SSL_accept - %s\n",
1902 : : SSL_state_string_long(s_ssl));
1903 : :
1904 [ + + ]: 25109 : if (sw_num > 0)
1905 : : {
1906 : : /* Write to client. */
1907 : :
1908 [ + - ]: 19312 : if (sw_num > (long)sizeof sbuf)
1909 : : i = sizeof sbuf;
1910 : : else
1911 : 19312 : i = (int)sw_num;
1912 : 19312 : r = BIO_write(s_ssl_bio, sbuf, i);
1913 [ + + ]: 19312 : if (r < 0)
1914 : : {
1915 [ - + ]: 18553 : if (!BIO_should_retry(s_ssl_bio))
1916 : : {
1917 : 0 : fprintf(stderr,"ERROR in SERVER\n");
1918 : 0 : goto err;
1919 : : }
1920 : : /* Ignore "BIO_should_retry". */
1921 : : }
1922 [ - + ]: 759 : else if (r == 0)
1923 : : {
1924 : 0 : fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1925 : : goto err;
1926 : : }
1927 : : else
1928 : : {
1929 [ - + ]: 759 : if (debug)
1930 : : printf("server wrote %d\n", r);
1931 : 759 : sw_num -= r;
1932 : : }
1933 : : }
1934 : :
1935 [ + - ]: 25109 : if (sr_num > 0)
1936 : : {
1937 : : /* Read from client. */
1938 : :
1939 : 25109 : r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1940 [ + + ]: 25109 : if (r < 0)
1941 : : {
1942 [ - + ]: 24350 : if (!BIO_should_retry(s_ssl_bio))
1943 : : {
1944 : 0 : fprintf(stderr,"ERROR in SERVER\n");
1945 : : goto err;
1946 : : }
1947 : : /* blah, blah */
1948 : : }
1949 [ - + ]: 759 : else if (r == 0)
1950 : : {
1951 : 0 : fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1952 : : goto err;
1953 : : }
1954 : : else
1955 : : {
1956 [ - + ]: 759 : if (debug)
1957 : : printf("server read %d\n", r);
1958 : 759 : sr_num -= r;
1959 : : }
1960 : : }
1961 : :
1962 : 25109 : *s_time += (clock() - s_clock);
1963 : : }
1964 : :
1965 : : {
1966 : : /* "I/O" BETWEEN CLIENT AND SERVER. */
1967 : :
1968 : : size_t r1, r2;
1969 : 25109 : BIO *io1 = server_io, *io2 = client_io;
1970 : : /* we use the non-copying interface for io1
1971 : : * and the standard BIO_write/BIO_read interface for io2
1972 : : */
1973 : :
1974 : : static int prev_progress = 1;
1975 : 25109 : int progress = 0;
1976 : :
1977 : : /* io1 to io2 */
1978 : : do
1979 : : {
1980 : : size_t num;
1981 : : int r;
1982 : :
1983 : 31308 : r1 = BIO_ctrl_pending(io1);
1984 : 31308 : r2 = BIO_ctrl_get_write_guarantee(io2);
1985 : :
1986 : 31308 : num = r1;
1987 [ - + ]: 31308 : if (r2 < num)
1988 : 0 : num = r2;
1989 [ + + ]: 31308 : if (num)
1990 : : {
1991 : : char *dataptr;
1992 : :
1993 [ - + ]: 6199 : if (INT_MAX < num) /* yeah, right */
1994 : 0 : num = INT_MAX;
1995 : :
1996 : 6199 : r = BIO_nread(io1, &dataptr, (int)num);
1997 [ - + ]: 6199 : assert(r > 0);
1998 [ - + ]: 6199 : assert(r <= (int)num);
1999 : : /* possibly r < num (non-contiguous data) */
2000 : 6199 : num = r;
2001 : 6199 : r = BIO_write(io2, dataptr, (int)num);
2002 [ - + ]: 6199 : if (r != (int)num) /* can't happen */
2003 : : {
2004 : 0 : fprintf(stderr, "ERROR: BIO_write could not write "
2005 : : "BIO_ctrl_get_write_guarantee() bytes");
2006 : 0 : goto err;
2007 : : }
2008 : 6199 : progress = 1;
2009 : :
2010 [ - + ]: 6199 : if (debug)
2011 [ # # ]: 0 : printf((io1 == client_io) ?
2012 : : "C->S relaying: %d bytes\n" :
2013 : : "S->C relaying: %d bytes\n",
2014 : : (int)num);
2015 : : }
2016 : : }
2017 [ + + ]: 31308 : while (r1 && r2);
2018 : :
2019 : : /* io2 to io1 */
2020 : : {
2021 : : size_t num;
2022 : : int r;
2023 : :
2024 : 25109 : r1 = BIO_ctrl_pending(io2);
2025 : 25109 : r2 = BIO_ctrl_get_read_request(io1);
2026 : : /* here we could use ..._get_write_guarantee instead of
2027 : : * ..._get_read_request, but by using the latter
2028 : : * we test restartability of the SSL implementation
2029 : : * more thoroughly */
2030 : 25109 : num = r1;
2031 [ + + ]: 25109 : if (r2 < num)
2032 : 13013 : num = r2;
2033 [ + + ]: 25109 : if (num)
2034 : : {
2035 : : char *dataptr;
2036 : :
2037 [ - + ]: 19548 : if (INT_MAX < num)
2038 : 0 : num = INT_MAX;
2039 : :
2040 [ + + ]: 19548 : if (num > 1)
2041 : 10396 : --num; /* test restartability even more thoroughly */
2042 : :
2043 : 19548 : r = BIO_nwrite0(io1, &dataptr);
2044 [ - + ]: 19548 : assert(r > 0);
2045 [ - + ]: 19548 : if (r < (int)num)
2046 : 0 : num = r;
2047 : 19548 : r = BIO_read(io2, dataptr, (int)num);
2048 [ - + ]: 19548 : if (r != (int)num) /* can't happen */
2049 : : {
2050 : 0 : fprintf(stderr, "ERROR: BIO_read could not read "
2051 : : "BIO_ctrl_pending() bytes");
2052 : 0 : goto err;
2053 : : }
2054 : 19548 : progress = 1;
2055 : 19548 : r = BIO_nwrite(io1, &dataptr, (int)num);
2056 [ - + ]: 19548 : if (r != (int)num) /* can't happen */
2057 : : {
2058 : 0 : fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2059 : : "BIO_nwrite0() bytes");
2060 : : goto err;
2061 : : }
2062 : :
2063 [ - + ]: 19548 : if (debug)
2064 [ # # ]: 0 : printf((io2 == client_io) ?
2065 : : "C->S relaying: %d bytes\n" :
2066 : : "S->C relaying: %d bytes\n",
2067 : : (int)num);
2068 : : }
2069 : : } /* no loop, BIO_ctrl_get_read_request now returns 0 anyway */
2070 : :
2071 [ + + ][ - + ]: 25109 : if (!progress && !prev_progress)
2072 [ # # ][ # # ]: 0 : if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0)
2073 : : {
2074 : 0 : fprintf(stderr, "ERROR: got stuck\n");
2075 [ # # ]: 0 : if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0)
2076 : : {
2077 : 0 : fprintf(stderr, "This can happen for SSL2 because "
2078 : : "CLIENT-FINISHED and SERVER-VERIFY are written \n"
2079 : : "concurrently ...");
2080 [ # # ]: 0 : if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
2081 [ # # ]: 0 : && strncmp("2SSV", SSL_state_string(s_ssl), 4) == 0)
2082 : : {
2083 : 0 : fprintf(stderr, " ok.\n");
2084 : : goto end;
2085 : : }
2086 : : }
2087 : 0 : fprintf(stderr, " ERROR.\n");
2088 : : goto err;
2089 : : }
2090 : 25109 : prev_progress = progress;
2091 : : }
2092 : : }
2093 [ + + ][ + + ]: 25109 : while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2094 : :
2095 [ + + ]: 759 : if (verbose)
2096 : 341 : print_details(c_ssl, "DONE via BIO pair: ");
2097 : : #ifndef OPENSSL_NO_NEXTPROTONEG
2098 [ + - ]: 759 : if (verify_npn(c_ssl, s_ssl) < 0)
2099 : : {
2100 : : ret = 1;
2101 : : goto end;
2102 : : }
2103 : : #endif
2104 [ + - ]: 759 : if (verify_serverinfo() < 0)
2105 : : {
2106 : : ret = 1;
2107 : : goto err;
2108 : : }
2109 [ + - ]: 759 : if (verify_alpn(c_ssl, s_ssl) < 0)
2110 : : {
2111 : : ret = 1;
2112 : : goto err;
2113 : : }
2114 : :
2115 [ + - ]: 759 : if (custom_ext_error)
2116 : : {
2117 : : ret = 1;
2118 : : goto err;
2119 : : }
2120 : :
2121 : : end:
2122 : : ret = 0;
2123 : :
2124 : : err:
2125 : 759 : ERR_print_errors(bio_err);
2126 : :
2127 [ + - ]: 759 : if (server)
2128 : 759 : BIO_free(server);
2129 [ + - ]: 759 : if (server_io)
2130 : 759 : BIO_free(server_io);
2131 [ + - ]: 759 : if (client)
2132 : 759 : BIO_free(client);
2133 [ + - ]: 759 : if (client_io)
2134 : 759 : BIO_free(client_io);
2135 [ + - ]: 759 : if (s_ssl_bio)
2136 : 759 : BIO_free(s_ssl_bio);
2137 [ + - ]: 759 : if (c_ssl_bio)
2138 : 759 : BIO_free(c_ssl_bio);
2139 : :
2140 : 759 : return ret;
2141 : : }
2142 : :
2143 : :
2144 : : #define W_READ 1
2145 : : #define W_WRITE 2
2146 : : #define C_DONE 1
2147 : : #define S_DONE 2
2148 : :
2149 : 453 : int doit(SSL *s_ssl, SSL *c_ssl, long count)
2150 : : {
2151 : 453 : char *cbuf=NULL,*sbuf=NULL;
2152 : : long bufsiz;
2153 : 453 : long cw_num=count,cr_num=count;
2154 : 453 : long sw_num=count,sr_num=count;
2155 : 453 : int ret=1;
2156 : 453 : BIO *c_to_s=NULL;
2157 : 453 : BIO *s_to_c=NULL;
2158 : 453 : BIO *c_bio=NULL;
2159 : 453 : BIO *s_bio=NULL;
2160 : : int c_r,c_w,s_r,s_w;
2161 : : int i,j;
2162 : 453 : int done=0;
2163 : : int c_write,s_write;
2164 : 453 : int do_server=0,do_client=0;
2165 : 453 : int max_frag = 5*1024;
2166 : :
2167 : 453 : bufsiz = count>40*1024 ? 40*1024 : count;
2168 : :
2169 [ + - ]: 453 : if ((cbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2170 [ + - ]: 453 : if ((sbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2171 : :
2172 : 453 : memset(cbuf,0,bufsiz);
2173 : 453 : memset(sbuf,0,bufsiz);
2174 : :
2175 : 453 : c_to_s=BIO_new(BIO_s_mem());
2176 : 453 : s_to_c=BIO_new(BIO_s_mem());
2177 [ - + ]: 453 : if ((s_to_c == NULL) || (c_to_s == NULL))
2178 : : {
2179 : 0 : ERR_print_errors(bio_err);
2180 : 0 : goto err;
2181 : : }
2182 : :
2183 : 453 : c_bio=BIO_new(BIO_f_ssl());
2184 : 453 : s_bio=BIO_new(BIO_f_ssl());
2185 [ - + ]: 453 : if ((c_bio == NULL) || (s_bio == NULL))
2186 : : {
2187 : 0 : ERR_print_errors(bio_err);
2188 : 0 : goto err;
2189 : : }
2190 : :
2191 : 453 : SSL_set_connect_state(c_ssl);
2192 : 453 : SSL_set_bio(c_ssl,s_to_c,c_to_s);
2193 : 453 : SSL_set_max_send_fragment(c_ssl,max_frag);
2194 : 453 : BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
2195 : :
2196 : 453 : SSL_set_accept_state(s_ssl);
2197 : 453 : SSL_set_bio(s_ssl,c_to_s,s_to_c);
2198 : 453 : SSL_set_max_send_fragment(s_ssl,max_frag);
2199 : 453 : BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
2200 : :
2201 : 453 : c_r=0; s_r=1;
2202 : 453 : c_w=1; s_w=0;
2203 : 453 : c_write=1,s_write=0;
2204 : :
2205 : : /* We can always do writes */
2206 : : for (;;)
2207 : : {
2208 : 12346 : do_server=0;
2209 : 12346 : do_client=0;
2210 : :
2211 : 12346 : i=(int)BIO_pending(s_bio);
2212 [ + + ][ + + ]: 12346 : if ((i && s_r) || s_w) do_server=1;
2213 : :
2214 : 12346 : i=(int)BIO_pending(c_bio);
2215 [ + + ][ + + ]: 12346 : if ((i && c_r) || c_w) do_client=1;
2216 : :
2217 [ + + ][ - + ]: 12346 : if (do_server && debug)
2218 : : {
2219 [ # # ]: 0 : if (SSL_in_init(s_ssl))
2220 : 0 : printf("server waiting in SSL_accept - %s\n",
2221 : : SSL_state_string_long(s_ssl));
2222 : : /* else if (s_write)
2223 : : printf("server:SSL_write()\n");
2224 : : else
2225 : : printf("server:SSL_read()\n"); */
2226 : : }
2227 : :
2228 [ + + ][ - + ]: 12346 : if (do_client && debug)
2229 : : {
2230 [ # # ]: 0 : if (SSL_in_init(c_ssl))
2231 : 0 : printf("client waiting in SSL_connect - %s\n",
2232 : : SSL_state_string_long(c_ssl));
2233 : : /* else if (c_write)
2234 : : printf("client:SSL_write()\n");
2235 : : else
2236 : : printf("client:SSL_read()\n"); */
2237 : : }
2238 : :
2239 [ - + ]: 12346 : if (!do_client && !do_server)
2240 : : {
2241 : 0 : fprintf(stdout,"ERROR IN STARTUP\n");
2242 : 0 : ERR_print_errors(bio_err);
2243 : 0 : break;
2244 : : }
2245 [ + + ][ + - ]: 12346 : if (do_client && !(done & C_DONE))
2246 : : {
2247 [ + + ]: 7124 : if (c_write)
2248 : : {
2249 : 1767 : j = (cw_num > bufsiz) ?
2250 [ + + ]: 1767 : (int)bufsiz : (int)cw_num;
2251 : 1767 : i=BIO_write(c_bio,cbuf,j);
2252 [ + + ]: 1767 : if (i < 0)
2253 : : {
2254 : 928 : c_r=0;
2255 : 928 : c_w=0;
2256 [ + + ]: 928 : if (BIO_should_retry(c_bio))
2257 : : {
2258 [ + - ]: 906 : if (BIO_should_read(c_bio))
2259 : 906 : c_r=1;
2260 [ - + ]: 906 : if (BIO_should_write(c_bio))
2261 : 0 : c_w=1;
2262 : : }
2263 : : else
2264 : : {
2265 : 22 : fprintf(stderr,"ERROR in CLIENT\n");
2266 : 22 : ERR_print_errors(bio_err);
2267 : 22 : goto err;
2268 : : }
2269 : : }
2270 [ - + ]: 839 : else if (i == 0)
2271 : : {
2272 : 0 : fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2273 : : goto err;
2274 : : }
2275 : : else
2276 : : {
2277 [ - + ]: 839 : if (debug)
2278 : : printf("client wrote %d\n",i);
2279 : : /* ok */
2280 : 839 : s_r=1;
2281 : 839 : c_write=0;
2282 : 839 : cw_num-=i;
2283 [ + - ]: 839 : if (max_frag>1029)
2284 : 839 : SSL_set_max_send_fragment(c_ssl,max_frag-=5);
2285 : : }
2286 : : }
2287 : : else
2288 : : {
2289 : 5357 : i=BIO_read(c_bio,cbuf,bufsiz);
2290 [ + + ]: 5357 : if (i < 0)
2291 : : {
2292 : 2 : c_r=0;
2293 : 2 : c_w=0;
2294 [ + - ]: 2 : if (BIO_should_retry(c_bio))
2295 : : {
2296 [ + - ]: 2 : if (BIO_should_read(c_bio))
2297 : 2 : c_r=1;
2298 [ - + ]: 2 : if (BIO_should_write(c_bio))
2299 : 0 : c_w=1;
2300 : : }
2301 : : else
2302 : : {
2303 : 0 : fprintf(stderr,"ERROR in CLIENT\n");
2304 : 0 : ERR_print_errors(bio_err);
2305 : 0 : goto err;
2306 : : }
2307 : : }
2308 [ - + ]: 5355 : else if (i == 0)
2309 : : {
2310 : 0 : fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2311 : : goto err;
2312 : : }
2313 : : else
2314 : : {
2315 [ - + ]: 5355 : if (debug)
2316 : : printf("client read %d\n",i);
2317 : 5355 : cr_num-=i;
2318 [ + + ]: 5355 : if (sw_num > 0)
2319 : : {
2320 : 408 : s_write=1;
2321 : 408 : s_w=1;
2322 : : }
2323 [ + + ]: 5355 : if (cr_num <= 0)
2324 : : {
2325 : 431 : s_write=1;
2326 : 431 : s_w=1;
2327 : 431 : done=S_DONE|C_DONE;
2328 : : }
2329 : : }
2330 : : }
2331 : : }
2332 : :
2333 [ + + ][ + + ]: 12324 : if (do_server && !(done & S_DONE))
2334 : : {
2335 [ + + ]: 6040 : if (!s_write)
2336 : : {
2337 : 5201 : i=BIO_read(s_bio,sbuf,bufsiz);
2338 [ + + ]: 5201 : if (i < 0)
2339 : : {
2340 : 906 : s_r=0;
2341 : 906 : s_w=0;
2342 [ + - ]: 906 : if (BIO_should_retry(s_bio))
2343 : : {
2344 [ + - ]: 906 : if (BIO_should_read(s_bio))
2345 : 906 : s_r=1;
2346 [ - + ]: 906 : if (BIO_should_write(s_bio))
2347 : 0 : s_w=1;
2348 : : }
2349 : : else
2350 : : {
2351 : 0 : fprintf(stderr,"ERROR in SERVER\n");
2352 : 0 : ERR_print_errors(bio_err);
2353 : 0 : goto err;
2354 : : }
2355 : : }
2356 [ - + ]: 4295 : else if (i == 0)
2357 : : {
2358 : 0 : ERR_print_errors(bio_err);
2359 : 0 : fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_read\n");
2360 : : goto err;
2361 : : }
2362 : : else
2363 : : {
2364 [ - + ]: 4295 : if (debug)
2365 : : printf("server read %d\n",i);
2366 : 4295 : sr_num-=i;
2367 [ + + ]: 4295 : if (cw_num > 0)
2368 : : {
2369 : 408 : c_write=1;
2370 : 408 : c_w=1;
2371 : : }
2372 [ + + ]: 4295 : if (sr_num <= 0)
2373 : : {
2374 : 431 : s_write=1;
2375 : 431 : s_w=1;
2376 : 431 : c_write=0;
2377 : : }
2378 : : }
2379 : : }
2380 : : else
2381 : : {
2382 : 839 : j = (sw_num > bufsiz) ?
2383 [ + + ]: 839 : (int)bufsiz : (int)sw_num;
2384 : 839 : i=BIO_write(s_bio,sbuf,j);
2385 [ - + ]: 839 : if (i < 0)
2386 : : {
2387 : 0 : s_r=0;
2388 : 0 : s_w=0;
2389 [ # # ]: 0 : if (BIO_should_retry(s_bio))
2390 : : {
2391 [ # # ]: 0 : if (BIO_should_read(s_bio))
2392 : 0 : s_r=1;
2393 [ # # ]: 0 : if (BIO_should_write(s_bio))
2394 : 0 : s_w=1;
2395 : : }
2396 : : else
2397 : : {
2398 : 0 : fprintf(stderr,"ERROR in SERVER\n");
2399 : 0 : ERR_print_errors(bio_err);
2400 : 0 : goto err;
2401 : : }
2402 : : }
2403 [ - + ]: 839 : else if (i == 0)
2404 : : {
2405 : 0 : ERR_print_errors(bio_err);
2406 : 0 : fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_write\n");
2407 : : goto err;
2408 : : }
2409 : : else
2410 : : {
2411 [ - + ]: 839 : if (debug)
2412 : : printf("server wrote %d\n",i);
2413 : 839 : sw_num-=i;
2414 : 839 : s_write=0;
2415 : 839 : c_r=1;
2416 [ + + ]: 839 : if (sw_num <= 0)
2417 : 431 : done|=S_DONE;
2418 [ + - ]: 839 : if (max_frag>1029)
2419 : 839 : SSL_set_max_send_fragment(s_ssl,max_frag-=5);
2420 : : }
2421 : : }
2422 : : }
2423 : :
2424 [ + + ]: 12324 : if ((done & S_DONE) && (done & C_DONE)) break;
2425 : : }
2426 : :
2427 [ - + ]: 431 : if (verbose)
2428 : 0 : print_details(c_ssl, "DONE: ");
2429 : : #ifndef OPENSSL_NO_NEXTPROTONEG
2430 [ + - ]: 431 : if (verify_npn(c_ssl, s_ssl) < 0)
2431 : : {
2432 : : ret = 1;
2433 : : goto err;
2434 : : }
2435 : : #endif
2436 [ + - ]: 431 : if (verify_serverinfo() < 0)
2437 : : {
2438 : : ret = 1;
2439 : : goto err;
2440 : : }
2441 [ + - ]: 431 : if (custom_ext_error)
2442 : : {
2443 : : ret = 1;
2444 : : goto err;
2445 : : }
2446 : 431 : ret=0;
2447 : : err:
2448 : : /* We have to set the BIO's to NULL otherwise they will be
2449 : : * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and
2450 : : * again when c_ssl is SSL_free()ed.
2451 : : * This is a hack required because s_ssl and c_ssl are sharing the same
2452 : : * BIO structure and SSL_set_bio() and SSL_free() automatically
2453 : : * BIO_free non NULL entries.
2454 : : * You should not normally do this or be required to do this */
2455 [ + - ]: 453 : if (s_ssl != NULL)
2456 : : {
2457 : 453 : s_ssl->rbio=NULL;
2458 : 453 : s_ssl->wbio=NULL;
2459 : : }
2460 [ + - ]: 453 : if (c_ssl != NULL)
2461 : : {
2462 : 453 : c_ssl->rbio=NULL;
2463 : 453 : c_ssl->wbio=NULL;
2464 : : }
2465 : :
2466 [ + - ]: 453 : if (c_to_s != NULL) BIO_free(c_to_s);
2467 [ + - ]: 453 : if (s_to_c != NULL) BIO_free(s_to_c);
2468 [ + - ]: 453 : if (c_bio != NULL) BIO_free_all(c_bio);
2469 [ + - ]: 453 : if (s_bio != NULL) BIO_free_all(s_bio);
2470 : :
2471 [ + - ]: 453 : if (cbuf) OPENSSL_free(cbuf);
2472 [ + - ]: 453 : if (sbuf) OPENSSL_free(sbuf);
2473 : :
2474 : 453 : return(ret);
2475 : : }
2476 : :
2477 : 632 : static int get_proxy_auth_ex_data_idx(void)
2478 : : {
2479 : : static volatile int idx = -1;
2480 [ + + ]: 632 : if (idx < 0)
2481 : : {
2482 : 202 : CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2483 [ + - ]: 202 : if (idx < 0)
2484 : : {
2485 : 202 : idx = X509_STORE_CTX_get_ex_new_index(0,
2486 : : "SSLtest for verify callback", NULL,NULL,NULL);
2487 : : }
2488 : 202 : CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2489 : : }
2490 : 632 : return idx;
2491 : : }
2492 : :
2493 : 942 : static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
2494 : : {
2495 : : char *s,buf[256];
2496 : :
2497 : 942 : s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),buf,
2498 : : sizeof buf);
2499 [ + - ]: 942 : if (s != NULL)
2500 : : {
2501 [ + - ]: 942 : if (ok)
2502 : 942 : fprintf(stderr,"depth=%d %s\n",
2503 : : ctx->error_depth,buf);
2504 : : else
2505 : : {
2506 : 0 : fprintf(stderr,"depth=%d error=%d %s\n",
2507 : : ctx->error_depth,ctx->error,buf);
2508 : : }
2509 : : }
2510 : :
2511 [ - + ]: 942 : if (ok == 0)
2512 : : {
2513 : 0 : fprintf(stderr,"Error string: %s\n",
2514 : 0 : X509_verify_cert_error_string(ctx->error));
2515 [ # # ][ # # ]: 0 : switch (ctx->error)
2516 : : {
2517 : : case X509_V_ERR_CERT_NOT_YET_VALID:
2518 : : case X509_V_ERR_CERT_HAS_EXPIRED:
2519 : : case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2520 : 0 : fprintf(stderr," ... ignored.\n");
2521 : 0 : ok=1;
2522 : : }
2523 : : }
2524 : :
2525 [ + - ]: 942 : if (ok == 1)
2526 : : {
2527 : 942 : X509 *xs = ctx->current_cert;
2528 : : #if 0
2529 : : X509 *xi = ctx->current_issuer;
2530 : : #endif
2531 : :
2532 [ + + ]: 942 : if (xs->ex_flags & EXFLAG_PROXY)
2533 : : {
2534 : 370 : unsigned int *letters =
2535 : 370 : X509_STORE_CTX_get_ex_data(ctx,
2536 : : get_proxy_auth_ex_data_idx());
2537 : :
2538 [ + - ]: 370 : if (letters)
2539 : : {
2540 : 370 : int found_any = 0;
2541 : : int i;
2542 : 370 : PROXY_CERT_INFO_EXTENSION *pci =
2543 : : X509_get_ext_d2i(xs, NID_proxyCertInfo,
2544 : : NULL, NULL);
2545 : :
2546 [ - - + ]: 370 : switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage))
2547 : : {
2548 : : case NID_Independent:
2549 : : /* Completely meaningless in this
2550 : : program, as there's no way to
2551 : : grant explicit rights to a
2552 : : specific PrC. Basically, using
2553 : : id-ppl-Independent is the perfect
2554 : : way to grant no rights at all. */
2555 : 0 : fprintf(stderr, " Independent proxy certificate");
2556 [ # # ]: 0 : for (i = 0; i < 26; i++)
2557 : 0 : letters[i] = 0;
2558 : : break;
2559 : : case NID_id_ppl_inheritAll:
2560 : : /* This is basically a NOP, we
2561 : : simply let the current rights
2562 : : stand as they are. */
2563 : 0 : fprintf(stderr, " Proxy certificate inherits all");
2564 : : break;
2565 : : default:
2566 : 370 : s = (char *)
2567 : 370 : pci->proxyPolicy->policy->data;
2568 : 370 : i = pci->proxyPolicy->policy->length;
2569 : :
2570 : : /* The algorithm works as follows:
2571 : : it is assumed that previous
2572 : : iterations or the initial granted
2573 : : rights has already set some elements
2574 : : of `letters'. What we need to do is
2575 : : to clear those that weren't granted
2576 : : by the current PrC as well. The
2577 : : easiest way to do this is to add 1
2578 : : to all the elements whose letters
2579 : : are given with the current policy.
2580 : : That way, all elements that are set
2581 : : by the current policy and were
2582 : : already set by earlier policies and
2583 : : through the original grant of rights
2584 : : will get the value 2 or higher.
2585 : : The last thing to do is to sweep
2586 : : through `letters' and keep the
2587 : : elements having the value 2 as set,
2588 : : and clear all the others. */
2589 : :
2590 : 370 : fprintf(stderr, " Certificate proxy rights = %*.*s", i, i, s);
2591 [ + + ]: 1110 : while(i-- > 0)
2592 : : {
2593 : 740 : int c = *s++;
2594 [ + - ][ + - ]: 740 : if (isascii(c) && isalpha(c))
2595 : : {
2596 [ - + ]: 740 : if (islower(c))
2597 [ # # ][ # # ]: 0 : c = toupper(c);
2598 : 740 : letters[c - 'A']++;
2599 : : }
2600 : : }
2601 [ + + ]: 9990 : for (i = 0; i < 26; i++)
2602 [ + + ]: 9620 : if (letters[i] < 2)
2603 : 9266 : letters[i] = 0;
2604 : : else
2605 : 354 : letters[i] = 1;
2606 : : }
2607 : :
2608 : 370 : found_any = 0;
2609 : 370 : fprintf(stderr,
2610 : : ", resulting proxy rights = ");
2611 [ + + ]: 9990 : for(i = 0; i < 26; i++)
2612 [ + + ]: 9620 : if (letters[i])
2613 : : {
2614 : 354 : fprintf(stderr, "%c", i + 'A');
2615 : 354 : found_any = 1;
2616 : : }
2617 [ + + ]: 370 : if (!found_any)
2618 : 16 : fprintf(stderr, "none");
2619 : 370 : fprintf(stderr, "\n");
2620 : :
2621 : 370 : PROXY_CERT_INFO_EXTENSION_free(pci);
2622 : : }
2623 : : }
2624 : : }
2625 : :
2626 : 942 : return(ok);
2627 : : }
2628 : :
2629 : 0 : static void process_proxy_debug(int indent, const char *format, ...)
2630 : : {
2631 : : static const char indentation[] =
2632 : : ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2633 : : ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"; /* That's 80 > */
2634 : : char my_format[256];
2635 : : va_list args;
2636 : :
2637 : 0 : BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2638 : : indent, indent, indentation, format);
2639 : :
2640 : 0 : va_start(args, format);
2641 : 0 : vfprintf(stderr, my_format, args);
2642 : 0 : va_end(args);
2643 : 0 : }
2644 : : /* Priority levels:
2645 : : 0 [!]var, ()
2646 : : 1 & ^
2647 : : 2 |
2648 : : */
2649 : : static int process_proxy_cond_adders(unsigned int letters[26],
2650 : : const char *cond, const char **cond_end, int *pos, int indent);
2651 : 508 : static int process_proxy_cond_val(unsigned int letters[26],
2652 : : const char *cond, const char **cond_end, int *pos, int indent)
2653 : : {
2654 : : int c;
2655 : 508 : int ok = 1;
2656 : 508 : int negate = 0;
2657 : :
2658 [ - + ]: 508 : while(isspace((int)*cond))
2659 : : {
2660 : 0 : cond++; (*pos)++;
2661 : : }
2662 : 508 : c = *cond;
2663 : :
2664 [ - + ]: 508 : if (debug)
2665 : 508 : process_proxy_debug(indent,
2666 : : "Start process_proxy_cond_val at position %d: %s\n",
2667 : : *pos, cond);
2668 : :
2669 [ + + ]: 631 : while(c == '!')
2670 : : {
2671 : 123 : negate = !negate;
2672 : 123 : cond++; (*pos)++;
2673 [ - + ]: 123 : while(isspace((int)*cond))
2674 : : {
2675 : 0 : cond++; (*pos)++;
2676 : : }
2677 : 123 : c = *cond;
2678 : : }
2679 : :
2680 [ - + ]: 508 : if (c == '(')
2681 : : {
2682 : 0 : cond++; (*pos)++;
2683 : 0 : ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2684 : : indent + 1);
2685 : 0 : cond = *cond_end;
2686 [ # # ]: 0 : if (ok < 0)
2687 : : goto end;
2688 [ # # ]: 0 : while(isspace((int)*cond))
2689 : : {
2690 : 0 : cond++; (*pos)++;
2691 : : }
2692 : 0 : c = *cond;
2693 [ # # ]: 0 : if (c != ')')
2694 : : {
2695 : 0 : fprintf(stderr,
2696 : : "Weird condition character in position %d: "
2697 : : "%c\n", *pos, c);
2698 : 0 : ok = -1;
2699 : 0 : goto end;
2700 : : }
2701 : 0 : cond++; (*pos)++;
2702 : : }
2703 [ + - ][ + - ]: 508 : else if (isascii(c) && isalpha(c))
2704 : : {
2705 [ - + ]: 508 : if (islower(c))
2706 [ # # ][ # # ]: 0 : c = toupper(c);
2707 : 508 : ok = letters[c - 'A'];
2708 : 508 : cond++; (*pos)++;
2709 : : }
2710 : : else
2711 : : {
2712 : 0 : fprintf(stderr,
2713 : : "Weird condition character in position %d: "
2714 : : "%c\n", *pos, c);
2715 : 0 : ok = -1;
2716 : 0 : goto end;
2717 : : }
2718 : : end:
2719 : 508 : *cond_end = cond;
2720 [ + + ]: 508 : if (ok >= 0 && negate)
2721 : 123 : ok = !ok;
2722 : :
2723 [ - + ]: 508 : if (debug)
2724 : 0 : process_proxy_debug(indent,
2725 : : "End process_proxy_cond_val at position %d: %s, returning %d\n",
2726 : : *pos, cond, ok);
2727 : :
2728 : 508 : return ok;
2729 : : }
2730 : 385 : static int process_proxy_cond_multipliers(unsigned int letters[26],
2731 : : const char *cond, const char **cond_end, int *pos, int indent)
2732 : : {
2733 : : int ok;
2734 : : char c;
2735 : :
2736 [ - + ]: 385 : if (debug)
2737 : 0 : process_proxy_debug(indent,
2738 : : "Start process_proxy_cond_multipliers at position %d: %s\n",
2739 : : *pos, cond);
2740 : :
2741 : 385 : ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2742 : 385 : cond = *cond_end;
2743 [ + - ]: 385 : if (ok < 0)
2744 : : goto end;
2745 : :
2746 [ + - ]: 508 : while(ok >= 0)
2747 : : {
2748 [ - + ]: 508 : while(isspace((int)*cond))
2749 : : {
2750 : 0 : cond++; (*pos)++;
2751 : : }
2752 : 508 : c = *cond;
2753 : :
2754 [ + + ]: 508 : switch(c)
2755 : : {
2756 : : case '&':
2757 : : case '^':
2758 : : {
2759 : 123 : int save_ok = ok;
2760 : :
2761 : 123 : cond++; (*pos)++;
2762 : 123 : ok = process_proxy_cond_val(letters,
2763 : : cond, cond_end, pos, indent + 1);
2764 : 123 : cond = *cond_end;
2765 [ + - ]: 123 : if (ok < 0)
2766 : : break;
2767 : :
2768 [ + - - ]: 123 : switch(c)
2769 : : {
2770 : : case '&':
2771 : 123 : ok &= save_ok;
2772 : 123 : break;
2773 : : case '^':
2774 : 0 : ok ^= save_ok;
2775 : 0 : break;
2776 : : default:
2777 : 0 : fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2778 : : " STOPPING\n");
2779 : 123 : EXIT(1);
2780 : : }
2781 : : }
2782 : : break;
2783 : : default:
2784 : : goto end;
2785 : : }
2786 : : }
2787 : : end:
2788 [ - + ]: 385 : if (debug)
2789 : 0 : process_proxy_debug(indent,
2790 : : "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2791 : : *pos, cond, ok);
2792 : :
2793 : 385 : *cond_end = cond;
2794 : 385 : return ok;
2795 : : }
2796 : 262 : static int process_proxy_cond_adders(unsigned int letters[26],
2797 : : const char *cond, const char **cond_end, int *pos, int indent)
2798 : : {
2799 : : int ok;
2800 : : char c;
2801 : :
2802 [ - + ]: 262 : if (debug)
2803 : 0 : process_proxy_debug(indent,
2804 : : "Start process_proxy_cond_adders at position %d: %s\n",
2805 : : *pos, cond);
2806 : :
2807 : 262 : ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2808 : : indent + 1);
2809 : 262 : cond = *cond_end;
2810 [ + - ]: 262 : if (ok < 0)
2811 : : goto end;
2812 : :
2813 [ + - ]: 385 : while(ok >= 0)
2814 : : {
2815 [ - + ]: 385 : while(isspace((int)*cond))
2816 : : {
2817 : 0 : cond++; (*pos)++;
2818 : : }
2819 : 385 : c = *cond;
2820 : :
2821 [ + + ]: 385 : switch(c)
2822 : : {
2823 : : case '|':
2824 : : {
2825 : 123 : int save_ok = ok;
2826 : :
2827 : 123 : cond++; (*pos)++;
2828 : 123 : ok = process_proxy_cond_multipliers(letters,
2829 : : cond, cond_end, pos, indent + 1);
2830 : 123 : cond = *cond_end;
2831 [ + - ]: 123 : if (ok < 0)
2832 : : break;
2833 : :
2834 [ + - ]: 123 : switch(c)
2835 : : {
2836 : : case '|':
2837 : 123 : ok |= save_ok;
2838 : : break;
2839 : : default:
2840 : 0 : fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2841 : : " STOPPING\n");
2842 : 123 : EXIT(1);
2843 : : }
2844 : : }
2845 : 123 : break;
2846 : : default:
2847 : : goto end;
2848 : : }
2849 : : }
2850 : : end:
2851 [ - + ]: 262 : if (debug)
2852 : 0 : process_proxy_debug(indent,
2853 : : "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2854 : : *pos, cond, ok);
2855 : :
2856 : 262 : *cond_end = cond;
2857 : 262 : return ok;
2858 : : }
2859 : :
2860 : 262 : static int process_proxy_cond(unsigned int letters[26],
2861 : : const char *cond, const char **cond_end)
2862 : : {
2863 : 262 : int pos = 1;
2864 : 262 : return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2865 : : }
2866 : :
2867 : 308 : static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2868 : : {
2869 : 308 : int ok=1;
2870 : 308 : struct app_verify_arg *cb_arg = arg;
2871 : : unsigned int letters[26]; /* only used with proxy_auth */
2872 : :
2873 [ + + ]: 308 : if (cb_arg->app_verify)
2874 : : {
2875 : 22 : char *s = NULL,buf[256];
2876 : :
2877 : 22 : fprintf(stderr, "In app_verify_callback, allowing cert. ");
2878 : 22 : fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2879 : 22 : fprintf(stderr, "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2880 : 22 : (void *)ctx, (void *)ctx->cert);
2881 [ + - ]: 22 : if (ctx->cert)
2882 : 22 : s=X509_NAME_oneline(X509_get_subject_name(ctx->cert),buf,256);
2883 [ + - ]: 22 : if (s != NULL)
2884 : : {
2885 : 22 : fprintf(stderr,"cert depth=%d %s\n",ctx->error_depth,buf);
2886 : : }
2887 : : return(1);
2888 : : }
2889 [ + + ]: 286 : if (cb_arg->proxy_auth)
2890 : : {
2891 : : int found_any = 0, i;
2892 : : char *sp;
2893 : :
2894 [ + + ]: 7074 : for(i = 0; i < 26; i++)
2895 : 6812 : letters[i] = 0;
2896 [ + + ]: 624 : for(sp = cb_arg->proxy_auth; *sp; sp++)
2897 : : {
2898 : 362 : int c = *sp;
2899 [ + - ][ + - ]: 362 : if (isascii(c) && isalpha(c))
2900 : : {
2901 [ - + ]: 362 : if (islower(c))
2902 [ # # ][ # # ]: 0 : c = toupper(c);
2903 : 362 : letters[c - 'A'] = 1;
2904 : : }
2905 : : }
2906 : :
2907 : 262 : fprintf(stderr,
2908 : : " Initial proxy rights = ");
2909 [ + + ]: 7074 : for(i = 0; i < 26; i++)
2910 [ + + ]: 6812 : if (letters[i])
2911 : : {
2912 : 362 : fprintf(stderr, "%c", i + 'A');
2913 : 362 : found_any = 1;
2914 : : }
2915 [ - + ]: 262 : if (!found_any)
2916 : 0 : fprintf(stderr, "none");
2917 : 262 : fprintf(stderr, "\n");
2918 : :
2919 : 262 : X509_STORE_CTX_set_ex_data(ctx,
2920 : : get_proxy_auth_ex_data_idx(),letters);
2921 : : }
2922 [ + + ]: 286 : if (cb_arg->allow_proxy_certs)
2923 : : {
2924 : 262 : X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2925 : : }
2926 : :
2927 : : #ifndef OPENSSL_NO_X509_VERIFY
2928 : 286 : ok = X509_verify_cert(ctx);
2929 : : #endif
2930 : :
2931 [ + + ]: 286 : if (cb_arg->proxy_auth)
2932 : : {
2933 [ + - ]: 262 : if (ok > 0)
2934 : : {
2935 : 262 : const char *cond_end = NULL;
2936 : :
2937 : 262 : ok = process_proxy_cond(letters,
2938 : 262 : cb_arg->proxy_cond, &cond_end);
2939 : :
2940 [ - + ]: 262 : if (ok < 0)
2941 : 0 : EXIT(3);
2942 [ - + ]: 262 : if (*cond_end)
2943 : : {
2944 : 0 : fprintf(stderr, "Stopped processing condition before it's end.\n");
2945 : 0 : ok = 0;
2946 : : }
2947 [ + + ]: 262 : if (!ok)
2948 : 22 : fprintf(stderr, "Proxy rights check with condition '%s' proved invalid\n",
2949 : : cb_arg->proxy_cond);
2950 : : else
2951 : 240 : fprintf(stderr, "Proxy rights check with condition '%s' proved valid\n",
2952 : : cb_arg->proxy_cond);
2953 : : }
2954 : : }
2955 : 286 : return(ok);
2956 : : }
2957 : :
2958 : : #ifndef OPENSSL_NO_RSA
2959 : : static RSA *rsa_tmp=NULL;
2960 : :
2961 : 33 : static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2962 : : {
2963 : 33 : BIGNUM *bn = NULL;
2964 [ + - ]: 33 : if (rsa_tmp == NULL)
2965 : : {
2966 : 33 : bn = BN_new();
2967 : 33 : rsa_tmp = RSA_new();
2968 [ + - ][ + - ]: 33 : if(!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4))
[ - + ]
2969 : : {
2970 : 0 : BIO_printf(bio_err, "Memory error...");
2971 : 0 : goto end;
2972 : : }
2973 : 33 : BIO_printf(bio_err,"Generating temp (%d bit) RSA key...",keylength);
2974 : 33 : (void)BIO_flush(bio_err);
2975 [ - + ]: 33 : if(!RSA_generate_key_ex(rsa_tmp,keylength,bn,NULL))
2976 : : {
2977 : 0 : BIO_printf(bio_err, "Error generating key.");
2978 : 0 : RSA_free(rsa_tmp);
2979 : 0 : rsa_tmp = NULL;
2980 : : }
2981 : : end:
2982 : 33 : BIO_printf(bio_err,"\n");
2983 : 33 : (void)BIO_flush(bio_err);
2984 : : }
2985 [ + - ]: 33 : if(bn) BN_free(bn);
2986 : 33 : return(rsa_tmp);
2987 : : }
2988 : :
2989 : 894 : static void free_tmp_rsa(void)
2990 : : {
2991 [ + + ]: 894 : if (rsa_tmp != NULL)
2992 : : {
2993 : 33 : RSA_free(rsa_tmp);
2994 : 33 : rsa_tmp = NULL;
2995 : : }
2996 : 894 : }
2997 : : #endif
2998 : :
2999 : : #ifndef OPENSSL_NO_DH
3000 : : /* These DH parameters have been generated as follows:
3001 : : * $ openssl dhparam -C -noout 512
3002 : : * $ openssl dhparam -C -noout 1024
3003 : : * $ openssl dhparam -C -noout -dsaparam 1024
3004 : : * (The third function has been renamed to avoid name conflicts.)
3005 : : */
3006 : 838 : static DH *get_dh512()
3007 : : {
3008 : : static unsigned char dh512_p[]={
3009 : : 0xCB,0xC8,0xE1,0x86,0xD0,0x1F,0x94,0x17,0xA6,0x99,0xF0,0xC6,
3010 : : 0x1F,0x0D,0xAC,0xB6,0x25,0x3E,0x06,0x39,0xCA,0x72,0x04,0xB0,
3011 : : 0x6E,0xDA,0xC0,0x61,0xE6,0x7A,0x77,0x25,0xE8,0x3B,0xB9,0x5F,
3012 : : 0x9A,0xB6,0xB5,0xFE,0x99,0x0B,0xA1,0x93,0x4E,0x35,0x33,0xB8,
3013 : : 0xE1,0xF1,0x13,0x4F,0x59,0x1A,0xD2,0x57,0xC0,0x26,0x21,0x33,
3014 : : 0x02,0xC5,0xAE,0x23,
3015 : : };
3016 : : static unsigned char dh512_g[]={
3017 : : 0x02,
3018 : : };
3019 : : DH *dh;
3020 : :
3021 [ + - ]: 838 : if ((dh=DH_new()) == NULL) return(NULL);
3022 : 838 : dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
3023 : 838 : dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
3024 [ + - ][ - + ]: 838 : if ((dh->p == NULL) || (dh->g == NULL))
3025 : 0 : { DH_free(dh); return(NULL); }
3026 : : return(dh);
3027 : : }
3028 : :
3029 : 0 : static DH *get_dh1024()
3030 : : {
3031 : : static unsigned char dh1024_p[]={
3032 : : 0xF8,0x81,0x89,0x7D,0x14,0x24,0xC5,0xD1,0xE6,0xF7,0xBF,0x3A,
3033 : : 0xE4,0x90,0xF4,0xFC,0x73,0xFB,0x34,0xB5,0xFA,0x4C,0x56,0xA2,
3034 : : 0xEA,0xA7,0xE9,0xC0,0xC0,0xCE,0x89,0xE1,0xFA,0x63,0x3F,0xB0,
3035 : : 0x6B,0x32,0x66,0xF1,0xD1,0x7B,0xB0,0x00,0x8F,0xCA,0x87,0xC2,
3036 : : 0xAE,0x98,0x89,0x26,0x17,0xC2,0x05,0xD2,0xEC,0x08,0xD0,0x8C,
3037 : : 0xFF,0x17,0x52,0x8C,0xC5,0x07,0x93,0x03,0xB1,0xF6,0x2F,0xB8,
3038 : : 0x1C,0x52,0x47,0x27,0x1B,0xDB,0xD1,0x8D,0x9D,0x69,0x1D,0x52,
3039 : : 0x4B,0x32,0x81,0xAA,0x7F,0x00,0xC8,0xDC,0xE6,0xD9,0xCC,0xC1,
3040 : : 0x11,0x2D,0x37,0x34,0x6C,0xEA,0x02,0x97,0x4B,0x0E,0xBB,0xB1,
3041 : : 0x71,0x33,0x09,0x15,0xFD,0xDD,0x23,0x87,0x07,0x5E,0x89,0xAB,
3042 : : 0x6B,0x7C,0x5F,0xEC,0xA6,0x24,0xDC,0x53,
3043 : : };
3044 : : static unsigned char dh1024_g[]={
3045 : : 0x02,
3046 : : };
3047 : : DH *dh;
3048 : :
3049 [ # # ]: 0 : if ((dh=DH_new()) == NULL) return(NULL);
3050 : 0 : dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3051 : 0 : dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3052 [ # # ][ # # ]: 0 : if ((dh->p == NULL) || (dh->g == NULL))
3053 : 0 : { DH_free(dh); return(NULL); }
3054 : : return(dh);
3055 : : }
3056 : :
3057 : 33 : static DH *get_dh1024dsa()
3058 : : {
3059 : : static unsigned char dh1024_p[]={
3060 : : 0xC8,0x00,0xF7,0x08,0x07,0x89,0x4D,0x90,0x53,0xF3,0xD5,0x00,
3061 : : 0x21,0x1B,0xF7,0x31,0xA6,0xA2,0xDA,0x23,0x9A,0xC7,0x87,0x19,
3062 : : 0x3B,0x47,0xB6,0x8C,0x04,0x6F,0xFF,0xC6,0x9B,0xB8,0x65,0xD2,
3063 : : 0xC2,0x5F,0x31,0x83,0x4A,0xA7,0x5F,0x2F,0x88,0x38,0xB6,0x55,
3064 : : 0xCF,0xD9,0x87,0x6D,0x6F,0x9F,0xDA,0xAC,0xA6,0x48,0xAF,0xFC,
3065 : : 0x33,0x84,0x37,0x5B,0x82,0x4A,0x31,0x5D,0xE7,0xBD,0x52,0x97,
3066 : : 0xA1,0x77,0xBF,0x10,0x9E,0x37,0xEA,0x64,0xFA,0xCA,0x28,0x8D,
3067 : : 0x9D,0x3B,0xD2,0x6E,0x09,0x5C,0x68,0xC7,0x45,0x90,0xFD,0xBB,
3068 : : 0x70,0xC9,0x3A,0xBB,0xDF,0xD4,0x21,0x0F,0xC4,0x6A,0x3C,0xF6,
3069 : : 0x61,0xCF,0x3F,0xD6,0x13,0xF1,0x5F,0xBC,0xCF,0xBC,0x26,0x9E,
3070 : : 0xBC,0x0B,0xBD,0xAB,0x5D,0xC9,0x54,0x39,
3071 : : };
3072 : : static unsigned char dh1024_g[]={
3073 : : 0x3B,0x40,0x86,0xE7,0xF3,0x6C,0xDE,0x67,0x1C,0xCC,0x80,0x05,
3074 : : 0x5A,0xDF,0xFE,0xBD,0x20,0x27,0x74,0x6C,0x24,0xC9,0x03,0xF3,
3075 : : 0xE1,0x8D,0xC3,0x7D,0x98,0x27,0x40,0x08,0xB8,0x8C,0x6A,0xE9,
3076 : : 0xBB,0x1A,0x3A,0xD6,0x86,0x83,0x5E,0x72,0x41,0xCE,0x85,0x3C,
3077 : : 0xD2,0xB3,0xFC,0x13,0xCE,0x37,0x81,0x9E,0x4C,0x1C,0x7B,0x65,
3078 : : 0xD3,0xE6,0xA6,0x00,0xF5,0x5A,0x95,0x43,0x5E,0x81,0xCF,0x60,
3079 : : 0xA2,0x23,0xFC,0x36,0xA7,0x5D,0x7A,0x4C,0x06,0x91,0x6E,0xF6,
3080 : : 0x57,0xEE,0x36,0xCB,0x06,0xEA,0xF5,0x3D,0x95,0x49,0xCB,0xA7,
3081 : : 0xDD,0x81,0xDF,0x80,0x09,0x4A,0x97,0x4D,0xA8,0x22,0x72,0xA1,
3082 : : 0x7F,0xC4,0x70,0x56,0x70,0xE8,0x20,0x10,0x18,0x8F,0x2E,0x60,
3083 : : 0x07,0xE7,0x68,0x1A,0x82,0x5D,0x32,0xA2,
3084 : : };
3085 : : DH *dh;
3086 : :
3087 [ + - ]: 33 : if ((dh=DH_new()) == NULL) return(NULL);
3088 : 33 : dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3089 : 33 : dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3090 [ + - ][ - + ]: 33 : if ((dh->p == NULL) || (dh->g == NULL))
3091 : 0 : { DH_free(dh); return(NULL); }
3092 : 33 : dh->length = 160;
3093 : 33 : return(dh);
3094 : : }
3095 : : #endif
3096 : :
3097 : : #ifndef OPENSSL_NO_PSK
3098 : : /* convert the PSK key (psk_key) in ascii to binary (psk) */
3099 : 44 : static int psk_key2bn(const char *pskkey, unsigned char *psk,
3100 : : unsigned int max_psk_len)
3101 : : {
3102 : : int ret;
3103 : 44 : BIGNUM *bn = NULL;
3104 : :
3105 : 44 : ret = BN_hex2bn(&bn, pskkey);
3106 [ - + ]: 44 : if (!ret)
3107 : : {
3108 : 0 : BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey);
3109 [ # # ]: 0 : if (bn)
3110 : 0 : BN_free(bn);
3111 : : return 0;
3112 : : }
3113 [ - + ]: 44 : if (BN_num_bytes(bn) > (int)max_psk_len)
3114 : : {
3115 : 0 : BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
3116 : 0 : max_psk_len, BN_num_bytes(bn));
3117 : 0 : BN_free(bn);
3118 : 0 : return 0;
3119 : : }
3120 : 44 : ret = BN_bn2bin(bn, psk);
3121 : 44 : BN_free(bn);
3122 : 44 : return ret;
3123 : : }
3124 : :
3125 : 22 : static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
3126 : : unsigned int max_identity_len, unsigned char *psk,
3127 : : unsigned int max_psk_len)
3128 : : {
3129 : : int ret;
3130 : 22 : unsigned int psk_len = 0;
3131 : :
3132 : 22 : ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3133 [ + - ]: 22 : if (ret < 0)
3134 : : goto out_err;
3135 [ - + ]: 22 : if (debug)
3136 : 0 : fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
3137 : 22 : ret = psk_key2bn(psk_key, psk, max_psk_len);
3138 [ + - ]: 22 : if (ret < 0)
3139 : : goto out_err;
3140 : 22 : psk_len = ret;
3141 : : out_err:
3142 : 22 : return psk_len;
3143 : : }
3144 : :
3145 : 22 : static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3146 : : unsigned char *psk, unsigned int max_psk_len)
3147 : : {
3148 : 22 : unsigned int psk_len=0;
3149 : :
3150 [ - + ]: 22 : if (strcmp(identity, "Client_identity") != 0)
3151 : : {
3152 : 0 : BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3153 : 0 : return 0;
3154 : : }
3155 : 22 : psk_len=psk_key2bn(psk_key, psk, max_psk_len);
3156 : 22 : return psk_len;
3157 : : }
3158 : : #endif
3159 : :
3160 : 1 : static int do_test_cipherlist(void)
3161 : : {
3162 : 1 : int i = 0;
3163 : : const SSL_METHOD *meth;
3164 : 1 : const SSL_CIPHER *ci, *tci = NULL;
3165 : :
3166 : : #ifndef OPENSSL_NO_SSL2
3167 : 1 : fprintf(stderr, "testing SSLv2 cipher list order: ");
3168 : 1 : meth = SSLv2_method();
3169 [ + + ]: 8 : while ((ci = meth->get_cipher(i++)) != NULL)
3170 : : {
3171 [ + + ]: 7 : if (tci != NULL)
3172 [ - + ]: 6 : if (ci->id >= tci->id)
3173 : : {
3174 : 0 : fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3175 : 7 : return 0;
3176 : : }
3177 : : tci = ci;
3178 : : }
3179 : 1 : fprintf(stderr, "ok\n");
3180 : : #endif
3181 : : #ifndef OPENSSL_NO_SSL3
3182 : 1 : fprintf(stderr, "testing SSLv3 cipher list order: ");
3183 : 1 : meth = SSLv3_method();
3184 : 1 : tci = NULL;
3185 [ + + ]: 145 : while ((ci = meth->get_cipher(i++)) != NULL)
3186 : : {
3187 [ + + ]: 144 : if (tci != NULL)
3188 [ - + ]: 143 : if (ci->id >= tci->id)
3189 : : {
3190 : 0 : fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3191 : 144 : return 0;
3192 : : }
3193 : : tci = ci;
3194 : : }
3195 : 1 : fprintf(stderr, "ok\n");
3196 : : #endif
3197 : : #ifndef OPENSSL_NO_TLS1
3198 : 1 : fprintf(stderr, "testing TLSv1 cipher list order: ");
3199 : 1 : meth = TLSv1_method();
3200 : 1 : tci = NULL;
3201 [ - + ]: 1 : while ((ci = meth->get_cipher(i++)) != NULL)
3202 : : {
3203 [ # # ]: 0 : if (tci != NULL)
3204 [ # # ]: 0 : if (ci->id >= tci->id)
3205 : : {
3206 : 0 : fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3207 : 0 : return 0;
3208 : : }
3209 : : tci = ci;
3210 : : }
3211 : 1 : fprintf(stderr, "ok\n");
3212 : : #endif
3213 : :
3214 : 1 : return 1;
3215 : : }
|
