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