Add HMAC ECC ciphersuites from RFC5289. Include SHA384 PRF support and
[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 MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx);
221 #ifndef OPENSSL_NO_RSA
222 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export,int keylength);
223 static void free_tmp_rsa(void);
224 #endif
225 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg);
226 #define APP_CALLBACK_STRING "Test Callback Argument"
227 struct app_verify_arg
228         {
229         char *string;
230         int app_verify;
231         int allow_proxy_certs;
232         char *proxy_auth;
233         char *proxy_cond;
234         };
235
236 #ifndef OPENSSL_NO_DH
237 static DH *get_dh512(void);
238 static DH *get_dh1024(void);
239 static DH *get_dh1024dsa(void);
240 #endif
241
242
243 static char *psk_key=NULL; /* by default PSK is not used */
244 #ifndef OPENSSL_NO_PSK
245 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
246         unsigned int max_identity_len, unsigned char *psk,
247         unsigned int max_psk_len);
248 static unsigned int psk_server_callback(SSL *ssl, const char *identity, unsigned char *psk,
249         unsigned int max_psk_len);
250 #endif
251
252 #ifndef OPENSSL_NO_SRP
253 /* SRP client */
254 /* This is a context that we pass to all callbacks */
255 typedef struct srp_client_arg_st
256         {
257         char *srppassin;
258         char *srplogin;
259         } SRP_CLIENT_ARG;
260
261 #define PWD_STRLEN 1024
262
263 static char * MS_CALLBACK ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
264         {
265         SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
266         return BUF_strdup((char *)srp_client_arg->srppassin);
267         }
268
269 static char * MS_CALLBACK missing_srp_username_callback(SSL *s, void *arg)
270         {
271         SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
272         return BUF_strdup(srp_client_arg->srplogin);
273         }
274
275 /* SRP server */
276 /* This is a context that we pass to SRP server callbacks */
277 typedef struct srp_server_arg_st
278         {
279         char *expected_user;
280         char *pass;
281         } SRP_SERVER_ARG;
282
283 static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
284         {
285         SRP_SERVER_ARG * p = (SRP_SERVER_ARG *) arg;
286
287         if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0)
288                 {
289                 fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
290                 return SSL3_AL_FATAL;
291                 }
292         if (SSL_set_srp_server_param_pw(s,p->expected_user,p->pass,"1024")<0)
293                 {
294                 *ad = SSL_AD_INTERNAL_ERROR;
295                 return SSL3_AL_FATAL;
296                 }
297         return SSL_ERROR_NONE;
298         }
299 #endif
300
301 static BIO *bio_err=NULL;
302 static BIO *bio_stdout=NULL;
303
304 #ifndef OPENSSL_NO_NPN
305 /* Note that this code assumes that this is only a one element list: */
306 static const char NEXT_PROTO_STRING[] = "\x09testproto";
307 int npn_client = 0;
308 int npn_server = 0;
309 int npn_server_reject = 0;
310
311 static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
312         {
313         /* This callback only returns the protocol string, rather than a length
314            prefixed set. We assume that NEXT_PROTO_STRING is a one element list and
315            remove the first byte to chop off the length prefix. */
316         *out = (unsigned char*) NEXT_PROTO_STRING + 1;
317         *outlen = sizeof(NEXT_PROTO_STRING) - 2;
318         return SSL_TLSEXT_ERR_OK;
319         }
320
321 static int cb_server_npn(SSL *s, const unsigned char **data, unsigned int *len, void *arg)
322         {
323         *data = (const unsigned char *) NEXT_PROTO_STRING;
324         *len = sizeof(NEXT_PROTO_STRING) - 1;
325         return SSL_TLSEXT_ERR_OK;
326         }
327
328 static int cb_server_rejects_npn(SSL *s, const unsigned char **data, unsigned int *len, void *arg)
329         {
330         return SSL_TLSEXT_ERR_NOACK;
331         }
332
333 static int verify_npn(SSL *client, SSL *server)
334         {
335         const unsigned char *client_s;
336         unsigned client_len;
337         const unsigned char *server_s;
338         unsigned server_len;
339
340         SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
341         SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
342
343         if (client_len)
344                 {
345                 BIO_printf(bio_stdout, "Client NPN: ");
346                 BIO_write(bio_stdout, client_s, client_len);
347                 BIO_printf(bio_stdout, "\n");
348                 }
349
350         if (server_len)
351                 {
352                 BIO_printf(bio_stdout, "Server NPN: ");
353                 BIO_write(bio_stdout, server_s, server_len);
354                 BIO_printf(bio_stdout, "\n");
355                 }
356
357         /* If an NPN string was returned, it must be the protocol that we
358          * expected to negotiate. */
359         if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||
360                            memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))
361                 return -1;
362         if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||
363                            memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))
364                 return -1;
365
366         if (!npn_client && client_len)
367                 return -1;
368         if (!npn_server && server_len)
369                 return -1;
370         if (npn_server_reject && server_len)
371                 return -1;
372         if (npn_client && npn_server && (!client_len || !server_len))
373                 return -1;
374
375         return 0;
376         }
377 #endif
378
379 static char *cipher=NULL;
380 static int verbose=0;
381 static int debug=0;
382 #if 0
383 /* Not used yet. */
384 #ifdef FIONBIO
385 static int s_nbio=0;
386 #endif
387 #endif
388
389 static const char rnd_seed[] = "string to make the random number generator think it has entropy";
390
391 int doit_biopair(SSL *s_ssl,SSL *c_ssl,long bytes,clock_t *s_time,clock_t *c_time);
392 int doit(SSL *s_ssl,SSL *c_ssl,long bytes);
393 static int do_test_cipherlist(void);
394 static void sv_usage(void)
395         {
396         fprintf(stderr,"usage: ssltest [args ...]\n");
397         fprintf(stderr,"\n");
398 #ifdef OPENSSL_FIPS
399         fprintf(stderr,"-F             - run test in FIPS mode\n");
400 #endif
401         fprintf(stderr," -server_auth  - check server certificate\n");
402         fprintf(stderr," -client_auth  - do client authentication\n");
403         fprintf(stderr," -proxy        - allow proxy certificates\n");
404         fprintf(stderr," -proxy_auth <val> - set proxy policy rights\n");
405         fprintf(stderr," -proxy_cond <val> - experssion to test proxy policy rights\n");
406         fprintf(stderr," -v            - more output\n");
407         fprintf(stderr," -d            - debug output\n");
408         fprintf(stderr," -reuse        - use session-id reuse\n");
409         fprintf(stderr," -num <val>    - number of connections to perform\n");
410         fprintf(stderr," -bytes <val>  - number of bytes to swap between client/server\n");
411 #ifndef OPENSSL_NO_DH
412         fprintf(stderr," -dhe1024      - use 1024 bit key (safe prime) for DHE\n");
413         fprintf(stderr," -dhe1024dsa   - use 1024 bit key (with 160-bit subprime) for DHE\n");
414         fprintf(stderr," -no_dhe       - disable DHE\n");
415 #endif
416 #ifndef OPENSSL_NO_ECDH
417         fprintf(stderr," -no_ecdhe     - disable ECDHE\n");
418 #endif
419 #ifndef OPENSSL_NO_PSK
420         fprintf(stderr," -psk arg      - PSK in hex (without 0x)\n");
421 #endif
422 #ifndef OPENSSL_NO_SRP
423         fprintf(stderr," -srpuser user  - SRP username to use\n");
424         fprintf(stderr," -srppass arg   - password for 'user'\n");
425 #endif
426 #ifndef OPENSSL_NO_SSL2
427         fprintf(stderr," -ssl2         - use SSLv2\n");
428 #endif
429 #ifndef OPENSSL_NO_SSL3
430         fprintf(stderr," -ssl3         - use SSLv3\n");
431 #endif
432 #ifndef OPENSSL_NO_TLS1
433         fprintf(stderr," -tls1         - use TLSv1\n");
434 #endif
435         fprintf(stderr," -CApath arg   - PEM format directory of CA's\n");
436         fprintf(stderr," -CAfile arg   - PEM format file of CA's\n");
437         fprintf(stderr," -cert arg     - Server certificate file\n");
438         fprintf(stderr," -key arg      - Server key file (default: same as -cert)\n");
439         fprintf(stderr," -c_cert arg   - Client certificate file\n");
440         fprintf(stderr," -c_key arg    - Client key file (default: same as -c_cert)\n");
441         fprintf(stderr," -cipher arg   - The cipher list\n");
442         fprintf(stderr," -bio_pair     - Use BIO pairs\n");
443         fprintf(stderr," -f            - Test even cases that can't work\n");
444         fprintf(stderr," -time         - measure processor time used by client and server\n");
445         fprintf(stderr," -zlib         - use zlib compression\n");
446         fprintf(stderr," -rle          - use rle compression\n");
447 #ifndef OPENSSL_NO_ECDH
448         fprintf(stderr," -named_curve arg  - Elliptic curve name to use for ephemeral ECDH keys.\n" \
449                        "                 Use \"openssl ecparam -list_curves\" for all names\n"  \
450                        "                 (default is sect163r2).\n");
451 #endif
452         fprintf(stderr," -test_cipherlist - verifies the order of the ssl cipher lists\n");
453 #ifndef OPENSSL_NO_NPN
454         fprintf(stderr," -npn_client - have client side offer NPN\n");
455         fprintf(stderr," -npn_server - have server side offer NPN\n");
456         fprintf(stderr," -npn_server_reject - have server reject NPN\n");
457 #endif
458         }
459
460 static void print_details(SSL *c_ssl, const char *prefix)
461         {
462         const SSL_CIPHER *ciph;
463         X509 *cert;
464                 
465         ciph=SSL_get_current_cipher(c_ssl);
466         BIO_printf(bio_stdout,"%s%s, cipher %s %s",
467                 prefix,
468                 SSL_get_version(c_ssl),
469                 SSL_CIPHER_get_version(ciph),
470                 SSL_CIPHER_get_name(ciph));
471         cert=SSL_get_peer_certificate(c_ssl);
472         if (cert != NULL)
473                 {
474                 EVP_PKEY *pkey = X509_get_pubkey(cert);
475                 if (pkey != NULL)
476                         {
477                         if (0) 
478                                 ;
479 #ifndef OPENSSL_NO_RSA
480                         else if (pkey->type == EVP_PKEY_RSA && pkey->pkey.rsa != NULL
481                                 && pkey->pkey.rsa->n != NULL)
482                                 {
483                                 BIO_printf(bio_stdout, ", %d bit RSA",
484                                         BN_num_bits(pkey->pkey.rsa->n));
485                                 }
486 #endif
487 #ifndef OPENSSL_NO_DSA
488                         else if (pkey->type == EVP_PKEY_DSA && pkey->pkey.dsa != NULL
489                                 && pkey->pkey.dsa->p != NULL)
490                                 {
491                                 BIO_printf(bio_stdout, ", %d bit DSA",
492                                         BN_num_bits(pkey->pkey.dsa->p));
493                                 }
494 #endif
495                         EVP_PKEY_free(pkey);
496                         }
497                 X509_free(cert);
498                 }
499         /* The SSL API does not allow us to look at temporary RSA/DH keys,
500          * otherwise we should print their lengths too */
501         BIO_printf(bio_stdout,"\n");
502         }
503
504 static void lock_dbg_cb(int mode, int type, const char *file, int line)
505         {
506         static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
507         const char *errstr = NULL;
508         int rw;
509         
510         rw = mode & (CRYPTO_READ|CRYPTO_WRITE);
511         if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE)))
512                 {
513                 errstr = "invalid mode";
514                 goto err;
515                 }
516
517         if (type < 0 || type >= CRYPTO_NUM_LOCKS)
518                 {
519                 errstr = "type out of bounds";
520                 goto err;
521                 }
522
523         if (mode & CRYPTO_LOCK)
524                 {
525                 if (modes[type])
526                         {
527                         errstr = "already locked";
528                         /* must not happen in a single-threaded program
529                          * (would deadlock) */
530                         goto err;
531                         }
532
533                 modes[type] = rw;
534                 }
535         else if (mode & CRYPTO_UNLOCK)
536                 {
537                 if (!modes[type])
538                         {
539                         errstr = "not locked";
540                         goto err;
541                         }
542                 
543                 if (modes[type] != rw)
544                         {
545                         errstr = (rw == CRYPTO_READ) ?
546                                 "CRYPTO_r_unlock on write lock" :
547                                 "CRYPTO_w_unlock on read lock";
548                         }
549
550                 modes[type] = 0;
551                 }
552         else
553                 {
554                 errstr = "invalid mode";
555                 goto err;
556                 }
557
558  err:
559         if (errstr)
560                 {
561                 /* we cannot use bio_err here */
562                 fprintf(stderr, "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
563                         errstr, mode, type, file, line);
564                 }
565         }
566
567 #ifdef TLSEXT_TYPE_opaque_prf_input
568 struct cb_info_st { void *input; size_t len; int ret; };
569 struct cb_info_st co1 = { "C", 1, 1 }; /* try to negotiate oqaque PRF input */
570 struct cb_info_st co2 = { "C", 1, 2 }; /* insist on oqaque PRF input */
571 struct cb_info_st so1 = { "S", 1, 1 }; /* try to negotiate oqaque PRF input */
572 struct cb_info_st so2 = { "S", 1, 2 }; /* insist on oqaque PRF input */
573
574 int opaque_prf_input_cb(SSL *ssl, void *peerinput, size_t len, void *arg_)
575         {
576         struct cb_info_st *arg = arg_;
577
578         if (arg == NULL)
579                 return 1;
580         
581         if (!SSL_set_tlsext_opaque_prf_input(ssl, arg->input, arg->len))
582                 return 0;
583         return arg->ret;
584         }
585 #endif
586
587 int main(int argc, char *argv[])
588         {
589         char *CApath=NULL,*CAfile=NULL;
590         int badop=0;
591         int bio_pair=0;
592         int force=0;
593         int tls1=0,ssl2=0,ssl3=0,ret=1;
594         int client_auth=0;
595         int server_auth=0,i;
596         struct app_verify_arg app_verify_arg =
597                 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
598         char *server_cert=TEST_SERVER_CERT;
599         char *server_key=NULL;
600         char *client_cert=TEST_CLIENT_CERT;
601         char *client_key=NULL;
602 #ifndef OPENSSL_NO_ECDH
603         char *named_curve = NULL;
604 #endif
605         SSL_CTX *s_ctx=NULL;
606         SSL_CTX *c_ctx=NULL;
607         const SSL_METHOD *meth=NULL;
608         SSL *c_ssl,*s_ssl;
609         int number=1,reuse=0;
610         long bytes=256L;
611 #ifndef OPENSSL_NO_DH
612         DH *dh;
613         int dhe1024 = 0, dhe1024dsa = 0;
614 #endif
615 #ifndef OPENSSL_NO_ECDH
616         EC_KEY *ecdh = NULL;
617 #endif
618 #ifndef OPENSSL_NO_SRP
619         /* client */
620         int srp_lateuser = 0;
621         SRP_CLIENT_ARG srp_client_arg = {NULL,NULL};
622         /* server */
623         SRP_SERVER_ARG srp_server_arg = {NULL,NULL};
624 #endif
625         int no_dhe = 0;
626         int no_ecdhe = 0;
627         int no_psk = 0;
628         int print_time = 0;
629         clock_t s_time = 0, c_time = 0;
630         int comp = 0;
631 #ifndef OPENSSL_NO_COMP
632         COMP_METHOD *cm = NULL;
633         STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
634 #endif
635         int test_cipherlist = 0;
636 #ifdef OPENSSL_FIPS
637         int fips_mode=0;
638 #endif
639
640         verbose = 0;
641         debug = 0;
642         cipher = 0;
643
644         bio_err=BIO_new_fp(stderr,BIO_NOCLOSE|BIO_FP_TEXT);     
645
646         CRYPTO_set_locking_callback(lock_dbg_cb);
647
648         /* enable memory leak checking unless explicitly disabled */
649         if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))
650                 {
651                 CRYPTO_malloc_debug_init();
652                 CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
653                 }
654         else
655                 {
656                 /* OPENSSL_DEBUG_MEMORY=off */
657                 CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
658                 }
659         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
660
661         RAND_seed(rnd_seed, sizeof rnd_seed);
662
663         bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE|BIO_FP_TEXT);
664
665         argc--;
666         argv++;
667
668         while (argc >= 1)
669                 {
670                 if(!strcmp(*argv,"-F"))
671                         {
672 #ifdef OPENSSL_FIPS
673                         fips_mode=1;
674 #else
675                         fprintf(stderr,"not compiled with FIPS support, so exitting without running.\n");
676                         EXIT(0);
677 #endif
678                         }
679                 else if (strcmp(*argv,"-server_auth") == 0)
680                         server_auth=1;
681                 else if (strcmp(*argv,"-client_auth") == 0)
682                         client_auth=1;
683                 else if (strcmp(*argv,"-proxy_auth") == 0)
684                         {
685                         if (--argc < 1) goto bad;
686                         app_verify_arg.proxy_auth= *(++argv);
687                         }
688                 else if (strcmp(*argv,"-proxy_cond") == 0)
689                         {
690                         if (--argc < 1) goto bad;
691                         app_verify_arg.proxy_cond= *(++argv);
692                         }
693                 else if (strcmp(*argv,"-v") == 0)
694                         verbose=1;
695                 else if (strcmp(*argv,"-d") == 0)
696                         debug=1;
697                 else if (strcmp(*argv,"-reuse") == 0)
698                         reuse=1;
699                 else if (strcmp(*argv,"-dhe1024") == 0)
700                         {
701 #ifndef OPENSSL_NO_DH
702                         dhe1024=1;
703 #else
704                         fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
705 #endif
706                         }
707                 else if (strcmp(*argv,"-dhe1024dsa") == 0)
708                         {
709 #ifndef OPENSSL_NO_DH
710                         dhe1024dsa=1;
711 #else
712                         fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
713 #endif
714                         }
715                 else if (strcmp(*argv,"-no_dhe") == 0)
716                         no_dhe=1;
717                 else if (strcmp(*argv,"-no_ecdhe") == 0)
718                         no_ecdhe=1;
719                 else if (strcmp(*argv,"-psk") == 0)
720                         {
721                         if (--argc < 1) goto bad;
722                         psk_key=*(++argv);
723 #ifndef OPENSSL_NO_PSK
724                         if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key))
725                                 {
726                                 BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
727                                 goto bad;
728                                 }
729 #else
730                         no_psk=1;
731 #endif
732                         }
733 #ifndef OPENSSL_NO_SRP
734                 else if (strcmp(*argv,"-srpuser") == 0)
735                         {
736                         if (--argc < 1) goto bad;
737                         srp_server_arg.expected_user = srp_client_arg.srplogin= *(++argv);
738                         tls1=1;
739                         }
740                 else if (strcmp(*argv,"-srppass") == 0)
741                         {
742                         if (--argc < 1) goto bad;
743                         srp_server_arg.pass = srp_client_arg.srppassin= *(++argv);
744                         tls1=1;
745                         }
746 #endif
747                 else if (strcmp(*argv,"-ssl2") == 0)
748                         ssl2=1;
749                 else if (strcmp(*argv,"-tls1") == 0)
750                         tls1=1;
751                 else if (strcmp(*argv,"-ssl3") == 0)
752                         ssl3=1;
753                 else if (strncmp(*argv,"-num",4) == 0)
754                         {
755                         if (--argc < 1) goto bad;
756                         number= atoi(*(++argv));
757                         if (number == 0) number=1;
758                         }
759                 else if (strcmp(*argv,"-bytes") == 0)
760                         {
761                         if (--argc < 1) goto bad;
762                         bytes= atol(*(++argv));
763                         if (bytes == 0L) bytes=1L;
764                         i=strlen(argv[0]);
765                         if (argv[0][i-1] == 'k') bytes*=1024L;
766                         if (argv[0][i-1] == 'm') bytes*=1024L*1024L;
767                         }
768                 else if (strcmp(*argv,"-cert") == 0)
769                         {
770                         if (--argc < 1) goto bad;
771                         server_cert= *(++argv);
772                         }
773                 else if (strcmp(*argv,"-s_cert") == 0)
774                         {
775                         if (--argc < 1) goto bad;
776                         server_cert= *(++argv);
777                         }
778                 else if (strcmp(*argv,"-key") == 0)
779                         {
780                         if (--argc < 1) goto bad;
781                         server_key= *(++argv);
782                         }
783                 else if (strcmp(*argv,"-s_key") == 0)
784                         {
785                         if (--argc < 1) goto bad;
786                         server_key= *(++argv);
787                         }
788                 else if (strcmp(*argv,"-c_cert") == 0)
789                         {
790                         if (--argc < 1) goto bad;
791                         client_cert= *(++argv);
792                         }
793                 else if (strcmp(*argv,"-c_key") == 0)
794                         {
795                         if (--argc < 1) goto bad;
796                         client_key= *(++argv);
797                         }
798                 else if (strcmp(*argv,"-cipher") == 0)
799                         {
800                         if (--argc < 1) goto bad;
801                         cipher= *(++argv);
802                         }
803                 else if (strcmp(*argv,"-CApath") == 0)
804                         {
805                         if (--argc < 1) goto bad;
806                         CApath= *(++argv);
807                         }
808                 else if (strcmp(*argv,"-CAfile") == 0)
809                         {
810                         if (--argc < 1) goto bad;
811                         CAfile= *(++argv);
812                         }
813                 else if (strcmp(*argv,"-bio_pair") == 0)
814                         {
815                         bio_pair = 1;
816                         }
817                 else if (strcmp(*argv,"-f") == 0)
818                         {
819                         force = 1;
820                         }
821                 else if (strcmp(*argv,"-time") == 0)
822                         {
823                         print_time = 1;
824                         }
825                 else if (strcmp(*argv,"-zlib") == 0)
826                         {
827                         comp = COMP_ZLIB;
828                         }
829                 else if (strcmp(*argv,"-rle") == 0)
830                         {
831                         comp = COMP_RLE;
832                         }
833                 else if (strcmp(*argv,"-named_curve") == 0)
834                         {
835                         if (--argc < 1) goto bad;
836 #ifndef OPENSSL_NO_ECDH         
837                         named_curve = *(++argv);
838 #else
839                         fprintf(stderr,"ignoring -named_curve, since I'm compiled without ECDH\n");
840                         ++argv;
841 #endif
842                         }
843                 else if (strcmp(*argv,"-app_verify") == 0)
844                         {
845                         app_verify_arg.app_verify = 1;
846                         }
847                 else if (strcmp(*argv,"-proxy") == 0)
848                         {
849                         app_verify_arg.allow_proxy_certs = 1;
850                         }
851                 else if (strcmp(*argv,"-test_cipherlist") == 0)
852                         {
853                         test_cipherlist = 1;
854                         }
855 #ifndef OPENSSL_NO_NPN
856                 else if (strcmp(*argv,"-npn_client") == 0)
857                         {
858                         npn_client = 1;
859                         }
860                 else if (strcmp(*argv,"-npn_server") == 0)
861                         {
862                         npn_server = 1;
863                         }
864                 else if (strcmp(*argv,"-npn_server_reject") == 0)
865                         {
866                         npn_server_reject = 1;
867                         }
868 #endif
869                 else
870                         {
871                         fprintf(stderr,"unknown option %s\n",*argv);
872                         badop=1;
873                         break;
874                         }
875                 argc--;
876                 argv++;
877                 }
878         if (badop)
879                 {
880 bad:
881                 sv_usage();
882                 goto end;
883                 }
884
885         if (test_cipherlist == 1)
886                 {
887                 /* ensure that the cipher list are correctly sorted and exit */
888                 if (do_test_cipherlist() == 0)
889                         EXIT(1);
890                 ret = 0;
891                 goto end;
892                 }
893
894         if (!ssl2 && !ssl3 && !tls1 && number > 1 && !reuse && !force)
895                 {
896                 fprintf(stderr, "This case cannot work.  Use -f to perform "
897                         "the test anyway (and\n-d to see what happens), "
898                         "or add one of -ssl2, -ssl3, -tls1, -reuse\n"
899                         "to avoid protocol mismatch.\n");
900                 EXIT(1);
901                 }
902
903 #ifdef OPENSSL_FIPS
904         if(fips_mode)
905                 {
906                 if(!FIPS_mode_set(1))
907                         {
908                         ERR_load_crypto_strings();
909                         ERR_print_errors(BIO_new_fp(stderr,BIO_NOCLOSE));
910                         EXIT(1);
911                         }
912                 else
913                         fprintf(stderr,"*** IN FIPS MODE ***\n");
914                 }
915 #endif
916
917         if (print_time)
918                 {
919                 if (!bio_pair)
920                         {
921                         fprintf(stderr, "Using BIO pair (-bio_pair)\n");
922                         bio_pair = 1;
923                         }
924                 if (number < 50 && !force)
925                         fprintf(stderr, "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
926                 }
927
928 /*      if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
929
930         SSL_library_init();
931         SSL_load_error_strings();
932
933 #ifndef OPENSSL_NO_COMP
934         if (comp == COMP_ZLIB) cm = COMP_zlib();
935         if (comp == COMP_RLE) cm = COMP_rle();
936         if (cm != NULL)
937                 {
938                 if (cm->type != NID_undef)
939                         {
940                         if (SSL_COMP_add_compression_method(comp, cm) != 0)
941                                 {
942                                 fprintf(stderr,
943                                         "Failed to add compression method\n");
944                                 ERR_print_errors_fp(stderr);
945                                 }
946                         }
947                 else
948                         {
949                         fprintf(stderr,
950                                 "Warning: %s compression not supported\n",
951                                 (comp == COMP_RLE ? "rle" :
952                                         (comp == COMP_ZLIB ? "zlib" :
953                                                 "unknown")));
954                         ERR_print_errors_fp(stderr);
955                         }
956                 }
957         ssl_comp_methods = SSL_COMP_get_compression_methods();
958         fprintf(stderr, "Available compression methods:\n");
959         {
960         int j, n = sk_SSL_COMP_num(ssl_comp_methods);
961         if (n == 0)
962                 fprintf(stderr, "  NONE\n");
963         else
964                 for (j = 0; j < n; j++)
965                         {
966                         SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
967                         fprintf(stderr, "  %d: %s\n", c->id, c->name);
968                         }
969         }
970 #endif
971
972 #if !defined(OPENSSL_NO_SSL2) && !defined(OPENSSL_NO_SSL3)
973         if (ssl2)
974                 meth=SSLv2_method();
975         else 
976         if (tls1)
977                 meth=TLSv1_method();
978         else
979         if (ssl3)
980                 meth=SSLv3_method();
981         else
982                 meth=SSLv23_method();
983 #else
984 #ifdef OPENSSL_NO_SSL2
985         meth=SSLv3_method();
986 #else
987         meth=SSLv2_method();
988 #endif
989 #endif
990
991         c_ctx=SSL_CTX_new(meth);
992         s_ctx=SSL_CTX_new(meth);
993         if ((c_ctx == NULL) || (s_ctx == NULL))
994                 {
995                 ERR_print_errors(bio_err);
996                 goto end;
997                 }
998
999         if (cipher != NULL)
1000                 {
1001                 SSL_CTX_set_cipher_list(c_ctx,cipher);
1002                 SSL_CTX_set_cipher_list(s_ctx,cipher);
1003                 }
1004
1005 #ifndef OPENSSL_NO_DH
1006         if (!no_dhe)
1007                 {
1008                 if (dhe1024dsa)
1009                         {
1010                         /* use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks */
1011                         SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1012                         dh=get_dh1024dsa();
1013                         }
1014                 else if (dhe1024)
1015                         dh=get_dh1024();
1016                 else
1017                         dh=get_dh512();
1018                 SSL_CTX_set_tmp_dh(s_ctx,dh);
1019                 DH_free(dh);
1020                 }
1021 #else
1022         (void)no_dhe;
1023 #endif
1024
1025 #ifndef OPENSSL_NO_ECDH
1026         if (!no_ecdhe)
1027                 {
1028                 int nid;
1029
1030                 if (named_curve != NULL)
1031                         {
1032                         nid = OBJ_sn2nid(named_curve);
1033                         if (nid == 0)
1034                         {
1035                                 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1036                                 goto end;
1037                                 }
1038                         }
1039                 else
1040 #ifdef OPENSSL_NO_EC2M
1041                         nid = NID_X9_62_prime256v1;
1042 #else
1043                         nid = NID_sect163r2;
1044 #endif
1045
1046                 ecdh = EC_KEY_new_by_curve_name(nid);
1047                 if (ecdh == NULL)
1048                         {
1049                         BIO_printf(bio_err, "unable to create curve\n");
1050                         goto end;
1051                         }
1052
1053                 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1054                 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1055                 EC_KEY_free(ecdh);
1056                 }
1057 #else
1058         (void)no_ecdhe;
1059 #endif
1060
1061 #ifndef OPENSSL_NO_RSA
1062         SSL_CTX_set_tmp_rsa_callback(s_ctx,tmp_rsa_cb);
1063 #endif
1064
1065 #ifdef TLSEXT_TYPE_opaque_prf_input
1066         SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
1067         SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
1068         SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1); /* or &co2 or NULL */
1069         SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1); /* or &so2 or NULL */
1070 #endif
1071
1072         if (!SSL_CTX_use_certificate_file(s_ctx,server_cert,SSL_FILETYPE_PEM))
1073                 {
1074                 ERR_print_errors(bio_err);
1075                 }
1076         else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
1077                 (server_key?server_key:server_cert), SSL_FILETYPE_PEM))
1078                 {
1079                 ERR_print_errors(bio_err);
1080                 goto end;
1081                 }
1082
1083         if (client_auth)
1084                 {
1085                 SSL_CTX_use_certificate_file(c_ctx,client_cert,
1086                         SSL_FILETYPE_PEM);
1087                 SSL_CTX_use_PrivateKey_file(c_ctx,
1088                         (client_key?client_key:client_cert),
1089                         SSL_FILETYPE_PEM);
1090                 }
1091
1092         if (    (!SSL_CTX_load_verify_locations(s_ctx,CAfile,CApath)) ||
1093                 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1094                 (!SSL_CTX_load_verify_locations(c_ctx,CAfile,CApath)) ||
1095                 (!SSL_CTX_set_default_verify_paths(c_ctx)))
1096                 {
1097                 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1098                 ERR_print_errors(bio_err);
1099                 /* goto end; */
1100                 }
1101
1102         if (client_auth)
1103                 {
1104                 BIO_printf(bio_err,"client authentication\n");
1105                 SSL_CTX_set_verify(s_ctx,
1106                         SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1107                         verify_callback);
1108                 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback, &app_verify_arg);
1109                 }
1110         if (server_auth)
1111                 {
1112                 BIO_printf(bio_err,"server authentication\n");
1113                 SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
1114                         verify_callback);
1115                 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback, &app_verify_arg);
1116                 }
1117         
1118         {
1119                 int session_id_context = 0;
1120                 SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context, sizeof session_id_context);
1121         }
1122
1123         /* Use PSK only if PSK key is given */
1124         if (psk_key != NULL)
1125                 {
1126                 /* no_psk is used to avoid putting psk command to openssl tool */
1127                 if (no_psk)
1128                         {
1129                         /* if PSK is not compiled in and psk key is
1130                          * given, do nothing and exit successfully */
1131                         ret=0;
1132                         goto end;
1133                         }
1134 #ifndef OPENSSL_NO_PSK
1135                 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1136                 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1137                 if (debug)
1138                         BIO_printf(bio_err,"setting PSK identity hint to s_ctx\n");
1139                 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint"))
1140                         {
1141                         BIO_printf(bio_err,"error setting PSK identity hint to s_ctx\n");
1142                         ERR_print_errors(bio_err);
1143                         goto end;
1144                         }
1145 #endif
1146                 }
1147 #ifndef OPENSSL_NO_SRP
1148         if (srp_client_arg.srplogin)
1149                 {
1150                 if (srp_lateuser) 
1151                         SSL_CTX_set_srp_missing_srp_username_callback(c_ctx,missing_srp_username_callback);
1152                 else if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin))
1153                         {
1154                         BIO_printf(bio_err,"Unable to set SRP username\n");
1155                         goto end;
1156                         }
1157                 SSL_CTX_set_srp_cb_arg(c_ctx,&srp_client_arg);
1158                 SSL_CTX_set_srp_client_pwd_callback(c_ctx, ssl_give_srp_client_pwd_cb);
1159                 /*SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);*/
1160                 }
1161
1162         if (srp_server_arg.expected_user != NULL)
1163                 {
1164                 SSL_CTX_set_verify(s_ctx,SSL_VERIFY_NONE,verify_callback);
1165                 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1166                 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1167                 }
1168 #endif
1169
1170 #ifndef OPENSSL_NO_NPN
1171         if (npn_client)
1172                 {
1173                 SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1174                 }
1175         if (npn_server)
1176                 {
1177                 if (npn_server_reject)
1178                         {
1179                         BIO_printf(bio_err, "Can't have both -npn_server and -npn_server_reject\n");
1180                         goto end;
1181                         }
1182                 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1183                 }
1184         if (npn_server_reject)
1185                 {
1186                 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn, NULL);
1187                 }
1188 #endif
1189
1190         c_ssl=SSL_new(c_ctx);
1191         s_ssl=SSL_new(s_ctx);
1192
1193 #ifndef OPENSSL_NO_KRB5
1194         if (c_ssl  &&  c_ssl->kssl_ctx)
1195                 {
1196                 char    localhost[MAXHOSTNAMELEN+2];
1197
1198                 if (gethostname(localhost, sizeof localhost-1) == 0)
1199                         {
1200                         localhost[sizeof localhost-1]='\0';
1201                         if(strlen(localhost) == sizeof localhost-1)
1202                                 {
1203                                 BIO_printf(bio_err,"localhost name too long\n");
1204                                 goto end;
1205                                 }
1206                         kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER,
1207                                 localhost);
1208                         }
1209                 }
1210 #endif    /* OPENSSL_NO_KRB5  */
1211
1212         for (i=0; i<number; i++)
1213                 {
1214                 if (!reuse) SSL_set_session(c_ssl,NULL);
1215                 if (bio_pair)
1216                         ret=doit_biopair(s_ssl,c_ssl,bytes,&s_time,&c_time);
1217                 else
1218                         ret=doit(s_ssl,c_ssl,bytes);
1219                 }
1220
1221         if (!verbose)
1222                 {
1223                 print_details(c_ssl, "");
1224                 }
1225         if ((number > 1) || (bytes > 1L))
1226                 BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n",number,bytes);
1227         if (print_time)
1228                 {
1229 #ifdef CLOCKS_PER_SEC
1230                 /* "To determine the time in seconds, the value returned
1231                  * by the clock function should be divided by the value
1232                  * of the macro CLOCKS_PER_SEC."
1233                  *                                       -- ISO/IEC 9899 */
1234                 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1235                         "Approximate total client time: %6.2f s\n",
1236                         (double)s_time/CLOCKS_PER_SEC,
1237                         (double)c_time/CLOCKS_PER_SEC);
1238 #else
1239                 /* "`CLOCKS_PER_SEC' undeclared (first use this function)"
1240                  *                            -- cc on NeXTstep/OpenStep */
1241                 BIO_printf(bio_stdout,
1242                         "Approximate total server time: %6.2f units\n"
1243                         "Approximate total client time: %6.2f units\n",
1244                         (double)s_time,
1245                         (double)c_time);
1246 #endif
1247                 }
1248
1249         SSL_free(s_ssl);
1250         SSL_free(c_ssl);
1251
1252 end:
1253         if (s_ctx != NULL) SSL_CTX_free(s_ctx);
1254         if (c_ctx != NULL) SSL_CTX_free(c_ctx);
1255
1256         if (bio_stdout != NULL) BIO_free(bio_stdout);
1257
1258 #ifndef OPENSSL_NO_RSA
1259         free_tmp_rsa();
1260 #endif
1261 #ifndef OPENSSL_NO_ENGINE
1262         ENGINE_cleanup();
1263 #endif
1264         CRYPTO_cleanup_all_ex_data();
1265         ERR_free_strings();
1266         ERR_remove_thread_state(NULL);
1267         EVP_cleanup();
1268         CRYPTO_mem_leaks(bio_err);
1269         if (bio_err != NULL) BIO_free(bio_err);
1270         EXIT(ret);
1271         return ret;
1272         }
1273
1274 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1275         clock_t *s_time, clock_t *c_time)
1276         {
1277         long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1278         BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1279         BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1280         int ret = 1;
1281         
1282         size_t bufsiz = 256; /* small buffer for testing */
1283
1284         if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1285                 goto err;
1286         if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1287                 goto err;
1288         
1289         s_ssl_bio = BIO_new(BIO_f_ssl());
1290         if (!s_ssl_bio)
1291                 goto err;
1292
1293         c_ssl_bio = BIO_new(BIO_f_ssl());
1294         if (!c_ssl_bio)
1295                 goto err;
1296
1297         SSL_set_connect_state(c_ssl);
1298         SSL_set_bio(c_ssl, client, client);
1299         (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1300
1301         SSL_set_accept_state(s_ssl);
1302         SSL_set_bio(s_ssl, server, server);
1303         (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1304
1305         do
1306                 {
1307                 /* c_ssl_bio:          SSL filter BIO
1308                  *
1309                  * client:             pseudo-I/O for SSL library
1310                  *
1311                  * client_io:          client's SSL communication; usually to be
1312                  *                     relayed over some I/O facility, but in this
1313                  *                     test program, we're the server, too:
1314                  *
1315                  * server_io:          server's SSL communication
1316                  *
1317                  * server:             pseudo-I/O for SSL library
1318                  *
1319                  * s_ssl_bio:          SSL filter BIO
1320                  *
1321                  * The client and the server each employ a "BIO pair":
1322                  * client + client_io, server + server_io.
1323                  * BIO pairs are symmetric.  A BIO pair behaves similar
1324                  * to a non-blocking socketpair (but both endpoints must
1325                  * be handled by the same thread).
1326                  * [Here we could connect client and server to the ends
1327                  * of a single BIO pair, but then this code would be less
1328                  * suitable as an example for BIO pairs in general.]
1329                  *
1330                  * Useful functions for querying the state of BIO pair endpoints:
1331                  *
1332                  * BIO_ctrl_pending(bio)              number of bytes we can read now
1333                  * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
1334                  *                                      other side's read attempt
1335                  * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
1336                  *
1337                  * ..._read_request is never more than ..._write_guarantee;
1338                  * it depends on the application which one you should use.
1339                  */
1340
1341                 /* We have non-blocking behaviour throughout this test program, but
1342                  * can be sure that there is *some* progress in each iteration; so
1343                  * we don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE
1344                  * -- we just try everything in each iteration
1345                  */
1346
1347                         {
1348                         /* CLIENT */
1349                 
1350                         MS_STATIC char cbuf[1024*8];
1351                         int i, r;
1352                         clock_t c_clock = clock();
1353
1354                         memset(cbuf, 0, sizeof(cbuf));
1355
1356                         if (debug)
1357                                 if (SSL_in_init(c_ssl))
1358                                         printf("client waiting in SSL_connect - %s\n",
1359                                                 SSL_state_string_long(c_ssl));
1360
1361                         if (cw_num > 0)
1362                                 {
1363                                 /* Write to server. */
1364                                 
1365                                 if (cw_num > (long)sizeof cbuf)
1366                                         i = sizeof cbuf;
1367                                 else
1368                                         i = (int)cw_num;
1369                                 r = BIO_write(c_ssl_bio, cbuf, i);
1370                                 if (r < 0)
1371                                         {
1372                                         if (!BIO_should_retry(c_ssl_bio))
1373                                                 {
1374                                                 fprintf(stderr,"ERROR in CLIENT\n");
1375                                                 goto err;
1376                                                 }
1377                                         /* BIO_should_retry(...) can just be ignored here.
1378                                          * The library expects us to call BIO_write with
1379                                          * the same arguments again, and that's what we will
1380                                          * do in the next iteration. */
1381                                         }
1382                                 else if (r == 0)
1383                                         {
1384                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1385                                         goto err;
1386                                         }
1387                                 else
1388                                         {
1389                                         if (debug)
1390                                                 printf("client wrote %d\n", r);
1391                                         cw_num -= r;                            
1392                                         }
1393                                 }
1394
1395                         if (cr_num > 0)
1396                                 {
1397                                 /* Read from server. */
1398
1399                                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1400                                 if (r < 0)
1401                                         {
1402                                         if (!BIO_should_retry(c_ssl_bio))
1403                                                 {
1404                                                 fprintf(stderr,"ERROR in CLIENT\n");
1405                                                 goto err;
1406                                                 }
1407                                         /* Again, "BIO_should_retry" can be ignored. */
1408                                         }
1409                                 else if (r == 0)
1410                                         {
1411                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1412                                         goto err;
1413                                         }
1414                                 else
1415                                         {
1416                                         if (debug)
1417                                                 printf("client read %d\n", r);
1418                                         cr_num -= r;
1419                                         }
1420                                 }
1421
1422                         /* c_time and s_time increments will typically be very small
1423                          * (depending on machine speed and clock tick intervals),
1424                          * but sampling over a large number of connections should
1425                          * result in fairly accurate figures.  We cannot guarantee
1426                          * a lot, however -- if each connection lasts for exactly
1427                          * one clock tick, it will be counted only for the client
1428                          * or only for the server or even not at all.
1429                          */
1430                         *c_time += (clock() - c_clock);
1431                         }
1432
1433                         {
1434                         /* SERVER */
1435                 
1436                         MS_STATIC char sbuf[1024*8];
1437                         int i, r;
1438                         clock_t s_clock = clock();
1439
1440                         memset(sbuf, 0, sizeof(sbuf));
1441
1442                         if (debug)
1443                                 if (SSL_in_init(s_ssl))
1444                                         printf("server waiting in SSL_accept - %s\n",
1445                                                 SSL_state_string_long(s_ssl));
1446
1447                         if (sw_num > 0)
1448                                 {
1449                                 /* Write to client. */
1450                                 
1451                                 if (sw_num > (long)sizeof sbuf)
1452                                         i = sizeof sbuf;
1453                                 else
1454                                         i = (int)sw_num;
1455                                 r = BIO_write(s_ssl_bio, sbuf, i);
1456                                 if (r < 0)
1457                                         {
1458                                         if (!BIO_should_retry(s_ssl_bio))
1459                                                 {
1460                                                 fprintf(stderr,"ERROR in SERVER\n");
1461                                                 goto err;
1462                                                 }
1463                                         /* Ignore "BIO_should_retry". */
1464                                         }
1465                                 else if (r == 0)
1466                                         {
1467                                         fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1468                                         goto err;
1469                                         }
1470                                 else
1471                                         {
1472                                         if (debug)
1473                                                 printf("server wrote %d\n", r);
1474                                         sw_num -= r;                            
1475                                         }
1476                                 }
1477
1478                         if (sr_num > 0)
1479                                 {
1480                                 /* Read from client. */
1481
1482                                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1483                                 if (r < 0)
1484                                         {
1485                                         if (!BIO_should_retry(s_ssl_bio))
1486                                                 {
1487                                                 fprintf(stderr,"ERROR in SERVER\n");
1488                                                 goto err;
1489                                                 }
1490                                         /* blah, blah */
1491                                         }
1492                                 else if (r == 0)
1493                                         {
1494                                         fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1495                                         goto err;
1496                                         }
1497                                 else
1498                                         {
1499                                         if (debug)
1500                                                 printf("server read %d\n", r);
1501                                         sr_num -= r;
1502                                         }
1503                                 }
1504
1505                         *s_time += (clock() - s_clock);
1506                         }
1507                         
1508                         {
1509                         /* "I/O" BETWEEN CLIENT AND SERVER. */
1510
1511                         size_t r1, r2;
1512                         BIO *io1 = server_io, *io2 = client_io;
1513                         /* we use the non-copying interface for io1
1514                          * and the standard BIO_write/BIO_read interface for io2
1515                          */
1516                         
1517                         static int prev_progress = 1;
1518                         int progress = 0;
1519                         
1520                         /* io1 to io2 */
1521                         do
1522                                 {
1523                                 size_t num;
1524                                 int r;
1525
1526                                 r1 = BIO_ctrl_pending(io1);
1527                                 r2 = BIO_ctrl_get_write_guarantee(io2);
1528
1529                                 num = r1;
1530                                 if (r2 < num)
1531                                         num = r2;
1532                                 if (num)
1533                                         {
1534                                         char *dataptr;
1535
1536                                         if (INT_MAX < num) /* yeah, right */
1537                                                 num = INT_MAX;
1538                                         
1539                                         r = BIO_nread(io1, &dataptr, (int)num);
1540                                         assert(r > 0);
1541                                         assert(r <= (int)num);
1542                                         /* possibly r < num (non-contiguous data) */
1543                                         num = r;
1544                                         r = BIO_write(io2, dataptr, (int)num);
1545                                         if (r != (int)num) /* can't happen */
1546                                                 {
1547                                                 fprintf(stderr, "ERROR: BIO_write could not write "
1548                                                         "BIO_ctrl_get_write_guarantee() bytes");
1549                                                 goto err;
1550                                                 }
1551                                         progress = 1;
1552
1553                                         if (debug)
1554                                                 printf((io1 == client_io) ?
1555                                                         "C->S relaying: %d bytes\n" :
1556                                                         "S->C relaying: %d bytes\n",
1557                                                         (int)num);
1558                                         }
1559                                 }
1560                         while (r1 && r2);
1561
1562                         /* io2 to io1 */
1563                         {
1564                                 size_t num;
1565                                 int r;
1566
1567                                 r1 = BIO_ctrl_pending(io2);
1568                                 r2 = BIO_ctrl_get_read_request(io1);
1569                                 /* here we could use ..._get_write_guarantee instead of
1570                                  * ..._get_read_request, but by using the latter
1571                                  * we test restartability of the SSL implementation
1572                                  * more thoroughly */
1573                                 num = r1;
1574                                 if (r2 < num)
1575                                         num = r2;
1576                                 if (num)
1577                                         {
1578                                         char *dataptr;
1579                                         
1580                                         if (INT_MAX < num)
1581                                                 num = INT_MAX;
1582
1583                                         if (num > 1)
1584                                                 --num; /* test restartability even more thoroughly */
1585                                         
1586                                         r = BIO_nwrite0(io1, &dataptr);
1587                                         assert(r > 0);
1588                                         if (r < (int)num)
1589                                                 num = r;
1590                                         r = BIO_read(io2, dataptr, (int)num);
1591                                         if (r != (int)num) /* can't happen */
1592                                                 {
1593                                                 fprintf(stderr, "ERROR: BIO_read could not read "
1594                                                         "BIO_ctrl_pending() bytes");
1595                                                 goto err;
1596                                                 }
1597                                         progress = 1;
1598                                         r = BIO_nwrite(io1, &dataptr, (int)num);
1599                                         if (r != (int)num) /* can't happen */
1600                                                 {
1601                                                 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
1602                                                         "BIO_nwrite0() bytes");
1603                                                 goto err;
1604                                                 }
1605                                         
1606                                         if (debug)
1607                                                 printf((io2 == client_io) ?
1608                                                         "C->S relaying: %d bytes\n" :
1609                                                         "S->C relaying: %d bytes\n",
1610                                                         (int)num);
1611                                         }
1612                         } /* no loop, BIO_ctrl_get_read_request now returns 0 anyway */
1613
1614                         if (!progress && !prev_progress)
1615                                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0)
1616                                         {
1617                                         fprintf(stderr, "ERROR: got stuck\n");
1618                                         if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0)
1619                                                 {
1620                                                 fprintf(stderr, "This can happen for SSL2 because "
1621                                                         "CLIENT-FINISHED and SERVER-VERIFY are written \n"
1622                                                         "concurrently ...");
1623                                                 if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
1624                                                         && strncmp("2SSV", SSL_state_string(s_ssl), 4) == 0)
1625                                                         {
1626                                                         fprintf(stderr, " ok.\n");
1627                                                         goto end;
1628                                                         }
1629                                                 }
1630                                         fprintf(stderr, " ERROR.\n");
1631                                         goto err;
1632                                         }
1633                         prev_progress = progress;
1634                         }
1635                 }
1636         while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
1637
1638         if (verbose)
1639                 print_details(c_ssl, "DONE via BIO pair: ");
1640 #ifndef OPENSSL_NO_NPN
1641         if (verify_npn(c_ssl, s_ssl) < 0)
1642                 {
1643                 ret = 1;
1644                 goto end;
1645                 }
1646 #endif
1647 end:
1648         ret = 0;
1649
1650  err:
1651         ERR_print_errors(bio_err);
1652         
1653         if (server)
1654                 BIO_free(server);
1655         if (server_io)
1656                 BIO_free(server_io);
1657         if (client)
1658                 BIO_free(client);
1659         if (client_io)
1660                 BIO_free(client_io);
1661         if (s_ssl_bio)
1662                 BIO_free(s_ssl_bio);
1663         if (c_ssl_bio)
1664                 BIO_free(c_ssl_bio);
1665
1666         return ret;
1667         }
1668
1669
1670 #define W_READ  1
1671 #define W_WRITE 2
1672 #define C_DONE  1
1673 #define S_DONE  2
1674
1675 int doit(SSL *s_ssl, SSL *c_ssl, long count)
1676         {
1677         MS_STATIC char cbuf[1024*8],sbuf[1024*8];
1678         long cw_num=count,cr_num=count;
1679         long sw_num=count,sr_num=count;
1680         int ret=1;
1681         BIO *c_to_s=NULL;
1682         BIO *s_to_c=NULL;
1683         BIO *c_bio=NULL;
1684         BIO *s_bio=NULL;
1685         int c_r,c_w,s_r,s_w;
1686         int i,j;
1687         int done=0;
1688         int c_write,s_write;
1689         int do_server=0,do_client=0;
1690
1691         memset(cbuf,0,sizeof(cbuf));
1692         memset(sbuf,0,sizeof(sbuf));
1693
1694         c_to_s=BIO_new(BIO_s_mem());
1695         s_to_c=BIO_new(BIO_s_mem());
1696         if ((s_to_c == NULL) || (c_to_s == NULL))
1697                 {
1698                 ERR_print_errors(bio_err);
1699                 goto err;
1700                 }
1701
1702         c_bio=BIO_new(BIO_f_ssl());
1703         s_bio=BIO_new(BIO_f_ssl());
1704         if ((c_bio == NULL) || (s_bio == NULL))
1705                 {
1706                 ERR_print_errors(bio_err);
1707                 goto err;
1708                 }
1709
1710         SSL_set_connect_state(c_ssl);
1711         SSL_set_bio(c_ssl,s_to_c,c_to_s);
1712         BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
1713
1714         SSL_set_accept_state(s_ssl);
1715         SSL_set_bio(s_ssl,c_to_s,s_to_c);
1716         BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
1717
1718         c_r=0; s_r=1;
1719         c_w=1; s_w=0;
1720         c_write=1,s_write=0;
1721
1722         /* We can always do writes */
1723         for (;;)
1724                 {
1725                 do_server=0;
1726                 do_client=0;
1727
1728                 i=(int)BIO_pending(s_bio);
1729                 if ((i && s_r) || s_w) do_server=1;
1730
1731                 i=(int)BIO_pending(c_bio);
1732                 if ((i && c_r) || c_w) do_client=1;
1733
1734                 if (do_server && debug)
1735                         {
1736                         if (SSL_in_init(s_ssl))
1737                                 printf("server waiting in SSL_accept - %s\n",
1738                                         SSL_state_string_long(s_ssl));
1739 /*                      else if (s_write)
1740                                 printf("server:SSL_write()\n");
1741                         else
1742                                 printf("server:SSL_read()\n"); */
1743                         }
1744
1745                 if (do_client && debug)
1746                         {
1747                         if (SSL_in_init(c_ssl))
1748                                 printf("client waiting in SSL_connect - %s\n",
1749                                         SSL_state_string_long(c_ssl));
1750 /*                      else if (c_write)
1751                                 printf("client:SSL_write()\n");
1752                         else
1753                                 printf("client:SSL_read()\n"); */
1754                         }
1755
1756                 if (!do_client && !do_server)
1757                         {
1758                         fprintf(stdout,"ERROR IN STARTUP\n");
1759                         ERR_print_errors(bio_err);
1760                         break;
1761                         }
1762                 if (do_client && !(done & C_DONE))
1763                         {
1764                         if (c_write)
1765                                 {
1766                                 j = (cw_num > (long)sizeof(cbuf)) ?
1767                                         (int)sizeof(cbuf) : (int)cw_num;
1768                                 i=BIO_write(c_bio,cbuf,j);
1769                                 if (i < 0)
1770                                         {
1771                                         c_r=0;
1772                                         c_w=0;
1773                                         if (BIO_should_retry(c_bio))
1774                                                 {
1775                                                 if (BIO_should_read(c_bio))
1776                                                         c_r=1;
1777                                                 if (BIO_should_write(c_bio))
1778                                                         c_w=1;
1779                                                 }
1780                                         else
1781                                                 {
1782                                                 fprintf(stderr,"ERROR in CLIENT\n");
1783                                                 ERR_print_errors(bio_err);
1784                                                 goto err;
1785                                                 }
1786                                         }
1787                                 else if (i == 0)
1788                                         {
1789                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1790                                         goto err;
1791                                         }
1792                                 else
1793                                         {
1794                                         if (debug)
1795                                                 printf("client wrote %d\n",i);
1796                                         /* ok */
1797                                         s_r=1;
1798                                         c_write=0;
1799                                         cw_num-=i;
1800                                         }
1801                                 }
1802                         else
1803                                 {
1804                                 i=BIO_read(c_bio,cbuf,sizeof(cbuf));
1805                                 if (i < 0)
1806                                         {
1807                                         c_r=0;
1808                                         c_w=0;
1809                                         if (BIO_should_retry(c_bio))
1810                                                 {
1811                                                 if (BIO_should_read(c_bio))
1812                                                         c_r=1;
1813                                                 if (BIO_should_write(c_bio))
1814                                                         c_w=1;
1815                                                 }
1816                                         else
1817                                                 {
1818                                                 fprintf(stderr,"ERROR in CLIENT\n");
1819                                                 ERR_print_errors(bio_err);
1820                                                 goto err;
1821                                                 }
1822                                         }
1823                                 else if (i == 0)
1824                                         {
1825                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1826                                         goto err;
1827                                         }
1828                                 else
1829                                         {
1830                                         if (debug)
1831                                                 printf("client read %d\n",i);
1832                                         cr_num-=i;
1833                                         if (sw_num > 0)
1834                                                 {
1835                                                 s_write=1;
1836                                                 s_w=1;
1837                                                 }
1838                                         if (cr_num <= 0)
1839                                                 {
1840                                                 s_write=1;
1841                                                 s_w=1;
1842                                                 done=S_DONE|C_DONE;
1843                                                 }
1844                                         }
1845                                 }
1846                         }
1847
1848                 if (do_server && !(done & S_DONE))
1849                         {
1850                         if (!s_write)
1851                                 {
1852                                 i=BIO_read(s_bio,sbuf,sizeof(cbuf));
1853                                 if (i < 0)
1854                                         {
1855                                         s_r=0;
1856                                         s_w=0;
1857                                         if (BIO_should_retry(s_bio))
1858                                                 {
1859                                                 if (BIO_should_read(s_bio))
1860                                                         s_r=1;
1861                                                 if (BIO_should_write(s_bio))
1862                                                         s_w=1;
1863                                                 }
1864                                         else
1865                                                 {
1866                                                 fprintf(stderr,"ERROR in SERVER\n");
1867                                                 ERR_print_errors(bio_err);
1868                                                 goto err;
1869                                                 }
1870                                         }
1871                                 else if (i == 0)
1872                                         {
1873                                         ERR_print_errors(bio_err);
1874                                         fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_read\n");
1875                                         goto err;
1876                                         }
1877                                 else
1878                                         {
1879                                         if (debug)
1880                                                 printf("server read %d\n",i);
1881                                         sr_num-=i;
1882                                         if (cw_num > 0)
1883                                                 {
1884                                                 c_write=1;
1885                                                 c_w=1;
1886                                                 }
1887                                         if (sr_num <= 0)
1888                                                 {
1889                                                 s_write=1;
1890                                                 s_w=1;
1891                                                 c_write=0;
1892                                                 }
1893                                         }
1894                                 }
1895                         else
1896                                 {
1897                                 j = (sw_num > (long)sizeof(sbuf)) ?
1898                                         (int)sizeof(sbuf) : (int)sw_num;
1899                                 i=BIO_write(s_bio,sbuf,j);
1900                                 if (i < 0)
1901                                         {
1902                                         s_r=0;
1903                                         s_w=0;
1904                                         if (BIO_should_retry(s_bio))
1905                                                 {
1906                                                 if (BIO_should_read(s_bio))
1907                                                         s_r=1;
1908                                                 if (BIO_should_write(s_bio))
1909                                                         s_w=1;
1910                                                 }
1911                                         else
1912                                                 {
1913                                                 fprintf(stderr,"ERROR in SERVER\n");
1914                                                 ERR_print_errors(bio_err);
1915                                                 goto err;
1916                                                 }
1917                                         }
1918                                 else if (i == 0)
1919                                         {
1920                                         ERR_print_errors(bio_err);
1921                                         fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_write\n");
1922                                         goto err;
1923                                         }
1924                                 else
1925                                         {
1926                                         if (debug)
1927                                                 printf("server wrote %d\n",i);
1928                                         sw_num-=i;
1929                                         s_write=0;
1930                                         c_r=1;
1931                                         if (sw_num <= 0)
1932                                                 done|=S_DONE;
1933                                         }
1934                                 }
1935                         }
1936
1937                 if ((done & S_DONE) && (done & C_DONE)) break;
1938                 }
1939
1940         if (verbose)
1941                 print_details(c_ssl, "DONE: ");
1942 #ifndef OPENSSL_NO_NPN
1943         if (verify_npn(c_ssl, s_ssl) < 0)
1944                 {
1945                 ret = 1;
1946                 goto err;
1947                 }
1948 #endif
1949         ret=0;
1950 err:
1951         /* We have to set the BIO's to NULL otherwise they will be
1952          * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and
1953          * again when c_ssl is SSL_free()ed.
1954          * This is a hack required because s_ssl and c_ssl are sharing the same
1955          * BIO structure and SSL_set_bio() and SSL_free() automatically
1956          * BIO_free non NULL entries.
1957          * You should not normally do this or be required to do this */
1958         if (s_ssl != NULL)
1959                 {
1960                 s_ssl->rbio=NULL;
1961                 s_ssl->wbio=NULL;
1962                 }
1963         if (c_ssl != NULL)
1964                 {
1965                 c_ssl->rbio=NULL;
1966                 c_ssl->wbio=NULL;
1967                 }
1968
1969         if (c_to_s != NULL) BIO_free(c_to_s);
1970         if (s_to_c != NULL) BIO_free(s_to_c);
1971         if (c_bio != NULL) BIO_free_all(c_bio);
1972         if (s_bio != NULL) BIO_free_all(s_bio);
1973         return(ret);
1974         }
1975
1976 static int get_proxy_auth_ex_data_idx(void)
1977         {
1978         static volatile int idx = -1;
1979         if (idx < 0)
1980                 {
1981                 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
1982                 if (idx < 0)
1983                         {
1984                         idx = X509_STORE_CTX_get_ex_new_index(0,
1985                                 "SSLtest for verify callback", NULL,NULL,NULL);
1986                         }
1987                 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
1988                 }
1989         return idx;
1990         }
1991
1992 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
1993         {
1994         char *s,buf[256];
1995
1996         s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),buf,
1997                             sizeof buf);
1998         if (s != NULL)
1999                 {
2000                 if (ok)
2001                         fprintf(stderr,"depth=%d %s\n",
2002                                 ctx->error_depth,buf);
2003                 else
2004                         {
2005                         fprintf(stderr,"depth=%d error=%d %s\n",
2006                                 ctx->error_depth,ctx->error,buf);
2007                         }
2008                 }
2009
2010         if (ok == 0)
2011                 {
2012                 fprintf(stderr,"Error string: %s\n",
2013                         X509_verify_cert_error_string(ctx->error));
2014                 switch (ctx->error)
2015                         {
2016                 case X509_V_ERR_CERT_NOT_YET_VALID:
2017                 case X509_V_ERR_CERT_HAS_EXPIRED:
2018                 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2019                         fprintf(stderr,"  ... ignored.\n");
2020                         ok=1;
2021                         }
2022                 }
2023
2024         if (ok == 1)
2025                 {
2026                 X509 *xs = ctx->current_cert;
2027 #if 0
2028                 X509 *xi = ctx->current_issuer;
2029 #endif
2030
2031                 if (xs->ex_flags & EXFLAG_PROXY)
2032                         {
2033                         unsigned int *letters =
2034                                 X509_STORE_CTX_get_ex_data(ctx,
2035                                         get_proxy_auth_ex_data_idx());
2036
2037                         if (letters)
2038                                 {
2039                                 int found_any = 0;
2040                                 int i;
2041                                 PROXY_CERT_INFO_EXTENSION *pci =
2042                                         X509_get_ext_d2i(xs, NID_proxyCertInfo,
2043                                                 NULL, NULL);
2044
2045                                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage))
2046                                         {
2047                                 case NID_Independent:
2048                                         /* Completely meaningless in this
2049                                            program, as there's no way to
2050                                            grant explicit rights to a
2051                                            specific PrC.  Basically, using
2052                                            id-ppl-Independent is the perfect
2053                                            way to grant no rights at all. */
2054                                         fprintf(stderr, "  Independent proxy certificate");
2055                                         for (i = 0; i < 26; i++)
2056                                                 letters[i] = 0;
2057                                         break;
2058                                 case NID_id_ppl_inheritAll:
2059                                         /* This is basically a NOP, we
2060                                            simply let the current rights
2061                                            stand as they are. */
2062                                         fprintf(stderr, "  Proxy certificate inherits all");
2063                                         break;
2064                                 default:
2065                                         s = (char *)
2066                                                 pci->proxyPolicy->policy->data;
2067                                         i = pci->proxyPolicy->policy->length;
2068
2069                                         /* The algorithm works as follows:
2070                                            it is assumed that previous
2071                                            iterations or the initial granted
2072                                            rights has already set some elements
2073                                            of `letters'.  What we need to do is
2074                                            to clear those that weren't granted
2075                                            by the current PrC as well.  The
2076                                            easiest way to do this is to add 1
2077                                            to all the elements whose letters
2078                                            are given with the current policy.
2079                                            That way, all elements that are set
2080                                            by the current policy and were
2081                                            already set by earlier policies and
2082                                            through the original grant of rights
2083                                            will get the value 2 or higher.
2084                                            The last thing to do is to sweep
2085                                            through `letters' and keep the
2086                                            elements having the value 2 as set,
2087                                            and clear all the others. */
2088
2089                                         fprintf(stderr, "  Certificate proxy rights = %*.*s", i, i, s);
2090                                         while(i-- > 0)
2091                                                 {
2092                                                 int c = *s++;
2093                                                 if (isascii(c) && isalpha(c))
2094                                                         {
2095                                                         if (islower(c))
2096                                                                 c = toupper(c);
2097                                                         letters[c - 'A']++;
2098                                                         }
2099                                                 }
2100                                         for (i = 0; i < 26; i++)
2101                                                 if (letters[i] < 2)
2102                                                         letters[i] = 0;
2103                                                 else
2104                                                         letters[i] = 1;
2105                                         }
2106
2107                                 found_any = 0;
2108                                 fprintf(stderr,
2109                                         ", resulting proxy rights = ");
2110                                 for(i = 0; i < 26; i++)
2111                                         if (letters[i])
2112                                                 {
2113                                                 fprintf(stderr, "%c", i + 'A');
2114                                                 found_any = 1;
2115                                                 }
2116                                 if (!found_any)
2117                                         fprintf(stderr, "none");
2118                                 fprintf(stderr, "\n");
2119
2120                                 PROXY_CERT_INFO_EXTENSION_free(pci);
2121                                 }
2122                         }
2123                 }
2124
2125         return(ok);
2126         }
2127
2128 static void process_proxy_debug(int indent, const char *format, ...)
2129         {
2130         static const char indentation[] =
2131                 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2132                 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"; /* That's 80 > */
2133         char my_format[256];
2134         va_list args;
2135
2136         BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2137                 indent, indent, indentation, format);
2138
2139         va_start(args, format);
2140         vfprintf(stderr, my_format, args);
2141         va_end(args);
2142         }
2143 /* Priority levels:
2144    0    [!]var, ()
2145    1    & ^
2146    2    |
2147 */
2148 static int process_proxy_cond_adders(unsigned int letters[26],
2149         const char *cond, const char **cond_end, int *pos, int indent);
2150 static int process_proxy_cond_val(unsigned int letters[26],
2151         const char *cond, const char **cond_end, int *pos, int indent)
2152         {
2153         int c;
2154         int ok = 1;
2155         int negate = 0;
2156
2157         while(isspace((int)*cond))
2158                 {
2159                 cond++; (*pos)++;
2160                 }
2161         c = *cond;
2162
2163         if (debug)
2164                 process_proxy_debug(indent,
2165                         "Start process_proxy_cond_val at position %d: %s\n",
2166                         *pos, cond);
2167
2168         while(c == '!')
2169                 {
2170                 negate = !negate;
2171                 cond++; (*pos)++;
2172                 while(isspace((int)*cond))
2173                         {
2174                         cond++; (*pos)++;
2175                         }
2176                 c = *cond;
2177                 }
2178
2179         if (c == '(')
2180                 {
2181                 cond++; (*pos)++;
2182                 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2183                         indent + 1);
2184                 cond = *cond_end;
2185                 if (ok < 0)
2186                         goto end;
2187                 while(isspace((int)*cond))
2188                         {
2189                         cond++; (*pos)++;
2190                         }
2191                 c = *cond;
2192                 if (c != ')')
2193                         {
2194                         fprintf(stderr,
2195                                 "Weird condition character in position %d: "
2196                                 "%c\n", *pos, c);
2197                         ok = -1;
2198                         goto end;
2199                         }
2200                 cond++; (*pos)++;
2201                 }
2202         else if (isascii(c) && isalpha(c))
2203                 {
2204                 if (islower(c))
2205                         c = toupper(c);
2206                 ok = letters[c - 'A'];
2207                 cond++; (*pos)++;
2208                 }
2209         else
2210                 {
2211                 fprintf(stderr,
2212                         "Weird condition character in position %d: "
2213                         "%c\n", *pos, c);
2214                 ok = -1;
2215                 goto end;
2216                 }
2217  end:
2218         *cond_end = cond;
2219         if (ok >= 0 && negate)
2220                 ok = !ok;
2221
2222         if (debug)
2223                 process_proxy_debug(indent,
2224                         "End process_proxy_cond_val at position %d: %s, returning %d\n",
2225                         *pos, cond, ok);
2226
2227         return ok;
2228         }
2229 static int process_proxy_cond_multipliers(unsigned int letters[26],
2230         const char *cond, const char **cond_end, int *pos, int indent)
2231         {
2232         int ok;
2233         char c;
2234
2235         if (debug)
2236                 process_proxy_debug(indent,
2237                         "Start process_proxy_cond_multipliers at position %d: %s\n",
2238                         *pos, cond);
2239
2240         ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2241         cond = *cond_end;
2242         if (ok < 0)
2243                 goto end;
2244
2245         while(ok >= 0)
2246                 {
2247                 while(isspace((int)*cond))
2248                         {
2249                         cond++; (*pos)++;
2250                         }
2251                 c = *cond;
2252
2253                 switch(c)
2254                         {
2255                 case '&':
2256                 case '^':
2257                         {
2258                         int save_ok = ok;
2259
2260                         cond++; (*pos)++;
2261                         ok = process_proxy_cond_val(letters,
2262                                 cond, cond_end, pos, indent + 1);
2263                         cond = *cond_end;
2264                         if (ok < 0)
2265                                 break;
2266
2267                         switch(c)
2268                                 {
2269                         case '&':
2270                                 ok &= save_ok;
2271                                 break;
2272                         case '^':
2273                                 ok ^= save_ok;
2274                                 break;
2275                         default:
2276                                 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2277                                         " STOPPING\n");
2278                                 EXIT(1);
2279                                 }
2280                         }
2281                         break;
2282                 default:
2283                         goto end;
2284                         }
2285                 }
2286  end:
2287         if (debug)
2288                 process_proxy_debug(indent,
2289                         "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2290                         *pos, cond, ok);
2291
2292         *cond_end = cond;
2293         return ok;
2294         }
2295 static int process_proxy_cond_adders(unsigned int letters[26],
2296         const char *cond, const char **cond_end, int *pos, int indent)
2297         {
2298         int ok;
2299         char c;
2300
2301         if (debug)
2302                 process_proxy_debug(indent,
2303                         "Start process_proxy_cond_adders at position %d: %s\n",
2304                         *pos, cond);
2305
2306         ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2307                 indent + 1);
2308         cond = *cond_end;
2309         if (ok < 0)
2310                 goto end;
2311
2312         while(ok >= 0)
2313                 {
2314                 while(isspace((int)*cond))
2315                         {
2316                         cond++; (*pos)++;
2317                         }
2318                 c = *cond;
2319
2320                 switch(c)
2321                         {
2322                 case '|':
2323                         {
2324                         int save_ok = ok;
2325
2326                         cond++; (*pos)++;
2327                         ok = process_proxy_cond_multipliers(letters,
2328                                 cond, cond_end, pos, indent + 1);
2329                         cond = *cond_end;
2330                         if (ok < 0)
2331                                 break;
2332
2333                         switch(c)
2334                                 {
2335                         case '|':
2336                                 ok |= save_ok;
2337                                 break;
2338                         default:
2339                                 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2340                                         " STOPPING\n");
2341                                 EXIT(1);
2342                                 }
2343                         }
2344                         break;
2345                 default:
2346                         goto end;
2347                         }
2348                 }
2349  end:
2350         if (debug)
2351                 process_proxy_debug(indent,
2352                         "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2353                         *pos, cond, ok);
2354
2355         *cond_end = cond;
2356         return ok;
2357         }
2358
2359 static int process_proxy_cond(unsigned int letters[26],
2360         const char *cond, const char **cond_end)
2361         {
2362         int pos = 1;
2363         return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2364         }
2365
2366 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2367         {
2368         int ok=1;
2369         struct app_verify_arg *cb_arg = arg;
2370         unsigned int letters[26]; /* only used with proxy_auth */
2371
2372         if (cb_arg->app_verify)
2373                 {
2374                 char *s = NULL,buf[256];
2375
2376                 fprintf(stderr, "In app_verify_callback, allowing cert. ");
2377                 fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2378                 fprintf(stderr, "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2379                         (void *)ctx, (void *)ctx->cert);
2380                 if (ctx->cert)
2381                         s=X509_NAME_oneline(X509_get_subject_name(ctx->cert),buf,256);
2382                 if (s != NULL)
2383                         {
2384                         fprintf(stderr,"cert depth=%d %s\n",ctx->error_depth,buf);
2385                         }
2386                 return(1);
2387                 }
2388         if (cb_arg->proxy_auth)
2389                 {
2390                 int found_any = 0, i;
2391                 char *sp;
2392
2393                 for(i = 0; i < 26; i++)
2394                         letters[i] = 0;
2395                 for(sp = cb_arg->proxy_auth; *sp; sp++)
2396                         {
2397                         int c = *sp;
2398                         if (isascii(c) && isalpha(c))
2399                                 {
2400                                 if (islower(c))
2401                                         c = toupper(c);
2402                                 letters[c - 'A'] = 1;
2403                                 }
2404                         }
2405
2406                 fprintf(stderr,
2407                         "  Initial proxy rights = ");
2408                 for(i = 0; i < 26; i++)
2409                         if (letters[i])
2410                                 {
2411                                 fprintf(stderr, "%c", i + 'A');
2412                                 found_any = 1;
2413                                 }
2414                 if (!found_any)
2415                         fprintf(stderr, "none");
2416                 fprintf(stderr, "\n");
2417
2418                 X509_STORE_CTX_set_ex_data(ctx,
2419                         get_proxy_auth_ex_data_idx(),letters);
2420                 }
2421         if (cb_arg->allow_proxy_certs)
2422                 {
2423                 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2424                 }
2425
2426 #ifndef OPENSSL_NO_X509_VERIFY
2427         ok = X509_verify_cert(ctx);
2428 #endif
2429
2430         if (cb_arg->proxy_auth)
2431                 {
2432                 if (ok > 0)
2433                         {
2434                         const char *cond_end = NULL;
2435
2436                         ok = process_proxy_cond(letters,
2437                                 cb_arg->proxy_cond, &cond_end);
2438
2439                         if (ok < 0)
2440                                 EXIT(3);
2441                         if (*cond_end)
2442                                 {
2443                                 fprintf(stderr, "Stopped processing condition before it's end.\n");
2444                                 ok = 0;
2445                                 }
2446                         if (!ok)
2447                                 fprintf(stderr, "Proxy rights check with condition '%s' proved invalid\n",
2448                                         cb_arg->proxy_cond);
2449                         else
2450                                 fprintf(stderr, "Proxy rights check with condition '%s' proved valid\n",
2451                                         cb_arg->proxy_cond);
2452                         }
2453                 }
2454         return(ok);
2455         }
2456
2457 #ifndef OPENSSL_NO_RSA
2458 static RSA *rsa_tmp=NULL;
2459
2460 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2461         {
2462         BIGNUM *bn = NULL;
2463         if (rsa_tmp == NULL)
2464                 {
2465                 bn = BN_new();
2466                 rsa_tmp = RSA_new();
2467                 if(!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4))
2468                         {
2469                         BIO_printf(bio_err, "Memory error...");
2470                         goto end;
2471                         }
2472                 BIO_printf(bio_err,"Generating temp (%d bit) RSA key...",keylength);
2473                 (void)BIO_flush(bio_err);
2474                 if(!RSA_generate_key_ex(rsa_tmp,keylength,bn,NULL))
2475                         {
2476                         BIO_printf(bio_err, "Error generating key.");
2477                         RSA_free(rsa_tmp);
2478                         rsa_tmp = NULL;
2479                         }
2480 end:
2481                 BIO_printf(bio_err,"\n");
2482                 (void)BIO_flush(bio_err);
2483                 }
2484         if(bn) BN_free(bn);
2485         return(rsa_tmp);
2486         }
2487
2488 static void free_tmp_rsa(void)
2489         {
2490         if (rsa_tmp != NULL)
2491                 {
2492                 RSA_free(rsa_tmp);
2493                 rsa_tmp = NULL;
2494                 }
2495         }
2496 #endif
2497
2498 #ifndef OPENSSL_NO_DH
2499 /* These DH parameters have been generated as follows:
2500  *    $ openssl dhparam -C -noout 512
2501  *    $ openssl dhparam -C -noout 1024
2502  *    $ openssl dhparam -C -noout -dsaparam 1024
2503  * (The third function has been renamed to avoid name conflicts.)
2504  */
2505 static DH *get_dh512()
2506         {
2507         static unsigned char dh512_p[]={
2508                 0xCB,0xC8,0xE1,0x86,0xD0,0x1F,0x94,0x17,0xA6,0x99,0xF0,0xC6,
2509                 0x1F,0x0D,0xAC,0xB6,0x25,0x3E,0x06,0x39,0xCA,0x72,0x04,0xB0,
2510                 0x6E,0xDA,0xC0,0x61,0xE6,0x7A,0x77,0x25,0xE8,0x3B,0xB9,0x5F,
2511                 0x9A,0xB6,0xB5,0xFE,0x99,0x0B,0xA1,0x93,0x4E,0x35,0x33,0xB8,
2512                 0xE1,0xF1,0x13,0x4F,0x59,0x1A,0xD2,0x57,0xC0,0x26,0x21,0x33,
2513                 0x02,0xC5,0xAE,0x23,
2514                 };
2515         static unsigned char dh512_g[]={
2516                 0x02,
2517                 };
2518         DH *dh;
2519
2520         if ((dh=DH_new()) == NULL) return(NULL);
2521         dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
2522         dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
2523         if ((dh->p == NULL) || (dh->g == NULL))
2524                 { DH_free(dh); return(NULL); }
2525         return(dh);
2526         }
2527
2528 static DH *get_dh1024()
2529         {
2530         static unsigned char dh1024_p[]={
2531                 0xF8,0x81,0x89,0x7D,0x14,0x24,0xC5,0xD1,0xE6,0xF7,0xBF,0x3A,
2532                 0xE4,0x90,0xF4,0xFC,0x73,0xFB,0x34,0xB5,0xFA,0x4C,0x56,0xA2,
2533                 0xEA,0xA7,0xE9,0xC0,0xC0,0xCE,0x89,0xE1,0xFA,0x63,0x3F,0xB0,
2534                 0x6B,0x32,0x66,0xF1,0xD1,0x7B,0xB0,0x00,0x8F,0xCA,0x87,0xC2,
2535                 0xAE,0x98,0x89,0x26,0x17,0xC2,0x05,0xD2,0xEC,0x08,0xD0,0x8C,
2536                 0xFF,0x17,0x52,0x8C,0xC5,0x07,0x93,0x03,0xB1,0xF6,0x2F,0xB8,
2537                 0x1C,0x52,0x47,0x27,0x1B,0xDB,0xD1,0x8D,0x9D,0x69,0x1D,0x52,
2538                 0x4B,0x32,0x81,0xAA,0x7F,0x00,0xC8,0xDC,0xE6,0xD9,0xCC,0xC1,
2539                 0x11,0x2D,0x37,0x34,0x6C,0xEA,0x02,0x97,0x4B,0x0E,0xBB,0xB1,
2540                 0x71,0x33,0x09,0x15,0xFD,0xDD,0x23,0x87,0x07,0x5E,0x89,0xAB,
2541                 0x6B,0x7C,0x5F,0xEC,0xA6,0x24,0xDC,0x53,
2542                 };
2543         static unsigned char dh1024_g[]={
2544                 0x02,
2545                 };
2546         DH *dh;
2547
2548         if ((dh=DH_new()) == NULL) return(NULL);
2549         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
2550         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
2551         if ((dh->p == NULL) || (dh->g == NULL))
2552                 { DH_free(dh); return(NULL); }
2553         return(dh);
2554         }
2555
2556 static DH *get_dh1024dsa()
2557         {
2558         static unsigned char dh1024_p[]={
2559                 0xC8,0x00,0xF7,0x08,0x07,0x89,0x4D,0x90,0x53,0xF3,0xD5,0x00,
2560                 0x21,0x1B,0xF7,0x31,0xA6,0xA2,0xDA,0x23,0x9A,0xC7,0x87,0x19,
2561                 0x3B,0x47,0xB6,0x8C,0x04,0x6F,0xFF,0xC6,0x9B,0xB8,0x65,0xD2,
2562                 0xC2,0x5F,0x31,0x83,0x4A,0xA7,0x5F,0x2F,0x88,0x38,0xB6,0x55,
2563                 0xCF,0xD9,0x87,0x6D,0x6F,0x9F,0xDA,0xAC,0xA6,0x48,0xAF,0xFC,
2564                 0x33,0x84,0x37,0x5B,0x82,0x4A,0x31,0x5D,0xE7,0xBD,0x52,0x97,
2565                 0xA1,0x77,0xBF,0x10,0x9E,0x37,0xEA,0x64,0xFA,0xCA,0x28,0x8D,
2566                 0x9D,0x3B,0xD2,0x6E,0x09,0x5C,0x68,0xC7,0x45,0x90,0xFD,0xBB,
2567                 0x70,0xC9,0x3A,0xBB,0xDF,0xD4,0x21,0x0F,0xC4,0x6A,0x3C,0xF6,
2568                 0x61,0xCF,0x3F,0xD6,0x13,0xF1,0x5F,0xBC,0xCF,0xBC,0x26,0x9E,
2569                 0xBC,0x0B,0xBD,0xAB,0x5D,0xC9,0x54,0x39,
2570                 };
2571         static unsigned char dh1024_g[]={
2572                 0x3B,0x40,0x86,0xE7,0xF3,0x6C,0xDE,0x67,0x1C,0xCC,0x80,0x05,
2573                 0x5A,0xDF,0xFE,0xBD,0x20,0x27,0x74,0x6C,0x24,0xC9,0x03,0xF3,
2574                 0xE1,0x8D,0xC3,0x7D,0x98,0x27,0x40,0x08,0xB8,0x8C,0x6A,0xE9,
2575                 0xBB,0x1A,0x3A,0xD6,0x86,0x83,0x5E,0x72,0x41,0xCE,0x85,0x3C,
2576                 0xD2,0xB3,0xFC,0x13,0xCE,0x37,0x81,0x9E,0x4C,0x1C,0x7B,0x65,
2577                 0xD3,0xE6,0xA6,0x00,0xF5,0x5A,0x95,0x43,0x5E,0x81,0xCF,0x60,
2578                 0xA2,0x23,0xFC,0x36,0xA7,0x5D,0x7A,0x4C,0x06,0x91,0x6E,0xF6,
2579                 0x57,0xEE,0x36,0xCB,0x06,0xEA,0xF5,0x3D,0x95,0x49,0xCB,0xA7,
2580                 0xDD,0x81,0xDF,0x80,0x09,0x4A,0x97,0x4D,0xA8,0x22,0x72,0xA1,
2581                 0x7F,0xC4,0x70,0x56,0x70,0xE8,0x20,0x10,0x18,0x8F,0x2E,0x60,
2582                 0x07,0xE7,0x68,0x1A,0x82,0x5D,0x32,0xA2,
2583                 };
2584         DH *dh;
2585
2586         if ((dh=DH_new()) == NULL) return(NULL);
2587         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
2588         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
2589         if ((dh->p == NULL) || (dh->g == NULL))
2590                 { DH_free(dh); return(NULL); }
2591         dh->length = 160;
2592         return(dh);
2593         }
2594 #endif
2595
2596 #ifndef OPENSSL_NO_PSK
2597 /* convert the PSK key (psk_key) in ascii to binary (psk) */
2598 static int psk_key2bn(const char *pskkey, unsigned char *psk,
2599         unsigned int max_psk_len)
2600         {
2601         int ret;
2602         BIGNUM *bn = NULL;
2603
2604         ret = BN_hex2bn(&bn, pskkey);
2605         if (!ret)
2606                 {
2607                 BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey); 
2608                 if (bn)
2609                         BN_free(bn);
2610                 return 0;
2611                 }
2612         if (BN_num_bytes(bn) > (int)max_psk_len)
2613                 {
2614                 BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
2615                         max_psk_len, BN_num_bytes(bn));
2616                 BN_free(bn);
2617                 return 0;
2618                 }
2619         ret = BN_bn2bin(bn, psk);
2620         BN_free(bn);
2621         return ret;
2622         }
2623
2624 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
2625         unsigned int max_identity_len, unsigned char *psk,
2626         unsigned int max_psk_len)
2627         {
2628         int ret;
2629         unsigned int psk_len = 0;
2630
2631         ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
2632         if (ret < 0)
2633                 goto out_err;
2634         if (debug)
2635                 fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
2636         ret = psk_key2bn(psk_key, psk, max_psk_len);
2637         if (ret < 0)
2638                 goto out_err;
2639         psk_len = ret;
2640 out_err:
2641         return psk_len;
2642         }
2643
2644 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
2645         unsigned char *psk, unsigned int max_psk_len)
2646         {
2647         unsigned int psk_len=0;
2648
2649         if (strcmp(identity, "Client_identity") != 0)
2650                 {
2651                 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
2652                 return 0;
2653                 }
2654         psk_len=psk_key2bn(psk_key, psk, max_psk_len);
2655         return psk_len;
2656         }
2657 #endif
2658
2659 static int do_test_cipherlist(void)
2660         {
2661         int i = 0;
2662         const SSL_METHOD *meth;
2663         const SSL_CIPHER *ci, *tci = NULL;
2664
2665 #ifndef OPENSSL_NO_SSL2
2666         fprintf(stderr, "testing SSLv2 cipher list order: ");
2667         meth = SSLv2_method();
2668         while ((ci = meth->get_cipher(i++)) != NULL)
2669                 {
2670                 if (tci != NULL)
2671                         if (ci->id >= tci->id)
2672                                 {
2673                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2674                                 return 0;
2675                                 }
2676                 tci = ci;
2677                 }
2678         fprintf(stderr, "ok\n");
2679 #endif
2680 #ifndef OPENSSL_NO_SSL3
2681         fprintf(stderr, "testing SSLv3 cipher list order: ");
2682         meth = SSLv3_method();
2683         tci = NULL;
2684         while ((ci = meth->get_cipher(i++)) != NULL)
2685                 {
2686                 if (tci != NULL)
2687                         if (ci->id >= tci->id)
2688                                 {
2689                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2690                                 return 0;
2691                                 }
2692                 tci = ci;
2693                 }
2694         fprintf(stderr, "ok\n");
2695 #endif
2696 #ifndef OPENSSL_NO_TLS1
2697         fprintf(stderr, "testing TLSv1 cipher list order: ");
2698         meth = TLSv1_method();
2699         tci = NULL;
2700         while ((ci = meth->get_cipher(i++)) != NULL)
2701                 {
2702                 if (tci != NULL)
2703                         if (ci->id >= tci->id)
2704                                 {
2705                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2706                                 return 0;
2707                                 }
2708                 tci = ci;
2709                 }
2710         fprintf(stderr, "ok\n");
2711 #endif
2712
2713         return 1;
2714         }