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