Upgrade chrome's OpenSSL to same version Android ships with.

openssl/ssl/ssltest.c

 /* ssl/ssltest.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 95 matching lines @@
  * This product includes cryptographic software written by Eric Young
  * (eay@cryptsoft.com).  This product includes software written by Tim
  * Hudson (tjh@cryptsoft.com).
  *
  */
 /* ====================================================================
  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  * ECC cipher suite support in OpenSSL originally developed by 
  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
  */
+/* ====================================================================
+ * Copyright 2005 Nokia. All rights reserved.
+ *
+ * The portions of the attached software ("Contribution") is developed by
+ * Nokia Corporation and is licensed pursuant to the OpenSSL open source
+ * license.
+ *
+ * The Contribution, originally written by Mika Kousa and Pasi Eronen of
+ * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
+ * support (see RFC 4279) to OpenSSL.
+ *
+ * No patent licenses or other rights except those expressly stated in
+ * the OpenSSL open source license shall be deemed granted or received
+ * expressly, by implication, estoppel, or otherwise.
+ *
+ * No assurances are provided by Nokia that the Contribution does not
+ * infringe the patent or other intellectual property rights of any third
+ * party or that the license provides you with all the necessary rights
+ * to make use of the Contribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
+ * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
+ * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
+ * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
+ * OTHERWISE.
+ */
 
 #define _BSD_SOURCE 1           /* Or gethostname won't be declared properly
                                    on Linux and GNU platforms. */
 
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 #define USE_SOCKETS
 #include "e_os.h"
 
+#ifdef OPENSSL_SYS_VMS
 #define _XOPEN_SOURCE 500       /* Or isascii won't be declared properly on
                                    VMS (at least with DECompHP C).  */
+#endif
+
 #include <ctype.h>
 
 #include <openssl/bio.h>
 #include <openssl/crypto.h>
 #include <openssl/evp.h>
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
 #include <openssl/ssl.h>
 #ifndef OPENSSL_NO_ENGINE
 #include <openssl/engine.h>
@@ skipping 57 matching lines @@
         char *proxy_auth;
         char *proxy_cond;
         };
 
 #ifndef OPENSSL_NO_DH
 static DH *get_dh512(void);
 static DH *get_dh1024(void);
 static DH *get_dh1024dsa(void);
 #endif
 
+
+static char *psk_key=NULL; /* by default PSK is not used */
+#ifndef OPENSSL_NO_PSK
+static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
+        unsigned int max_identity_len, unsigned char *psk,
+        unsigned int max_psk_len);
+static unsigned int psk_server_callback(SSL *ssl, const char *identity, unsigned char *psk,
+        unsigned int max_psk_len);
+#endif
+
 static BIO *bio_err=NULL;
 static BIO *bio_stdout=NULL;
 
 static char *cipher=NULL;
 static int verbose=0;
 static int debug=0;
 #if 0
 /* Not used yet. */
 #ifdef FIONBIO
 static int s_nbio=0;
 #endif
 #endif
 
 static const char rnd_seed[] = "string to make the random number generator think it has entropy";
 
 int doit_biopair(SSL *s_ssl,SSL *c_ssl,long bytes,clock_t *s_time,clock_t *c_time);
 int doit(SSL *s_ssl,SSL *c_ssl,long bytes);
 static int do_test_cipherlist(void);
 static void sv_usage(void)
         {
         fprintf(stderr,"usage: ssltest [args ...]\n");
         fprintf(stderr,"\n");
-#ifdef OPENSSL_FIPS
-        fprintf(stderr,"-F             - run test in FIPS mode\n");
-#endif
         fprintf(stderr," -server_auth  - check server certificate\n");
         fprintf(stderr," -client_auth  - do client authentication\n");
         fprintf(stderr," -proxy        - allow proxy certificates\n");
         fprintf(stderr," -proxy_auth <val> - set proxy policy rights\n");
         fprintf(stderr," -proxy_cond <val> - experssion to test proxy policy rights\n");
         fprintf(stderr," -v            - more output\n");
         fprintf(stderr," -d            - debug output\n");
         fprintf(stderr," -reuse        - use session-id reuse\n");
         fprintf(stderr," -num <val>    - number of connections to perform\n");
         fprintf(stderr," -bytes <val>  - number of bytes to swap between client/server\n");
 #ifndef OPENSSL_NO_DH
         fprintf(stderr," -dhe1024      - use 1024 bit key (safe prime) for DHE\n");
         fprintf(stderr," -dhe1024dsa   - use 1024 bit key (with 160-bit subprime) for DHE\n");
         fprintf(stderr," -no_dhe       - disable DHE\n");
 #endif
 #ifndef OPENSSL_NO_ECDH
         fprintf(stderr," -no_ecdhe     - disable ECDHE\n");
 #endif
+#ifndef OPENSSL_NO_PSK
+        fprintf(stderr," -psk arg      - PSK in hex (without 0x)\n");
+#endif
 #ifndef OPENSSL_NO_SSL2
         fprintf(stderr," -ssl2         - use SSLv2\n");
 #endif
 #ifndef OPENSSL_NO_SSL3
         fprintf(stderr," -ssl3         - use SSLv3\n");
 #endif
 #ifndef OPENSSL_NO_TLS1
         fprintf(stderr," -tls1         - use TLSv1\n");
 #endif
         fprintf(stderr," -CApath arg   - PEM format directory of CA's\n");
         fprintf(stderr," -CAfile arg   - PEM format file of CA's\n");
         fprintf(stderr," -cert arg     - Server certificate file\n");
         fprintf(stderr," -key arg      - Server key file (default: same as -cert)\n");
         fprintf(stderr," -c_cert arg   - Client certificate file\n");
         fprintf(stderr," -c_key arg    - Client key file (default: same as -c_cert)\n");
         fprintf(stderr," -cipher arg   - The cipher list\n");
         fprintf(stderr," -bio_pair     - Use BIO pairs\n");
         fprintf(stderr," -f            - Test even cases that can't work\n");
         fprintf(stderr," -time         - measure processor time used by client and server\n");
         fprintf(stderr," -zlib         - use zlib compression\n");
         fprintf(stderr," -rle          - use rle compression\n");
 #ifndef OPENSSL_NO_ECDH
         fprintf(stderr," -named_curve arg  - Elliptic curve name to use for ephemeral ECDH keys.\n" \
                        "                 Use \"openssl ecparam -list_curves\" for all names\n"  \
                        "                 (default is sect163r2).\n");
 #endif
         fprintf(stderr," -test_cipherlist - verifies the order of the ssl cipher lists\n");
-        fprintf(stderr," -cutthrough       - enable 1-RTT full-handshake for strong ciphers\n");
+        fprintf(stderr," -c_small_records - enable client side use of small SSL record buffers\n");
+        fprintf(stderr," -s_small_records - enable server side use of small SSL record buffers\n");
+        fprintf(stderr," -cutthrough      - enable 1-RTT full-handshake for strong ciphers\n");
         }
 
 static void print_details(SSL *c_ssl, const char *prefix)
         {
-        SSL_CIPHER *ciph;
+        const SSL_CIPHER *ciph;
         X509 *cert;
                 
         ciph=SSL_get_current_cipher(c_ssl);
         BIO_printf(bio_stdout,"%s%s, cipher %s %s",
                 prefix,
                 SSL_get_version(c_ssl),
                 SSL_CIPHER_get_version(ciph),
                 SSL_CIPHER_get_name(ciph));
         cert=SSL_get_peer_certificate(c_ssl);
         if (cert != NULL)
@@ skipping 84 matching lines @@
 
  err:
         if (errstr)
                 {
                 /* we cannot use bio_err here */
                 fprintf(stderr, "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
                         errstr, mode, type, file, line);
                 }
         }
 
+#ifdef TLSEXT_TYPE_opaque_prf_input
+struct cb_info_st { void *input; size_t len; int ret; };
+struct cb_info_st co1 = { "C", 1, 1 }; /* try to negotiate oqaque PRF input */
+struct cb_info_st co2 = { "C", 1, 2 }; /* insist on oqaque PRF input */
+struct cb_info_st so1 = { "S", 1, 1 }; /* try to negotiate oqaque PRF input */
+struct cb_info_st so2 = { "S", 1, 2 }; /* insist on oqaque PRF input */
+
+int opaque_prf_input_cb(SSL *ssl, void *peerinput, size_t len, void *arg_)
+        {
+        struct cb_info_st *arg = arg_;
+
+        if (arg == NULL)
+                return 1;
+        
+        if (!SSL_set_tlsext_opaque_prf_input(ssl, arg->input, arg->len))
+                return 0;
+        return arg->ret;
+        }
+#endif
+        int ssl_mode = 0;
+        int c_small_records=0;
+        int s_small_records=0;
+        int cutthrough = 0;
 
 int main(int argc, char *argv[])
         {
         char *CApath=NULL,*CAfile=NULL;
         int badop=0;
         int bio_pair=0;
         int force=0;
         int tls1=0,ssl2=0,ssl3=0,ret=1;
         int client_auth=0;
         int server_auth=0,i;
         struct app_verify_arg app_verify_arg =
                 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
         char *server_cert=TEST_SERVER_CERT;
         char *server_key=NULL;
         char *client_cert=TEST_CLIENT_CERT;
         char *client_key=NULL;
 #ifndef OPENSSL_NO_ECDH
         char *named_curve = NULL;
 #endif
         SSL_CTX *s_ctx=NULL;
         SSL_CTX *c_ctx=NULL;
-        SSL_METHOD *meth=NULL;
+        const SSL_METHOD *meth=NULL;
         SSL *c_ssl,*s_ssl;
         int number=1,reuse=0;
         long bytes=256L;
 #ifndef OPENSSL_NO_DH
         DH *dh;
-        int dhe1024 = 1, dhe1024dsa = 0;
+        int dhe1024 = 0, dhe1024dsa = 0;
 #endif
 #ifndef OPENSSL_NO_ECDH
         EC_KEY *ecdh = NULL;
 #endif
         int no_dhe = 0;
         int no_ecdhe = 0;
+        int no_psk = 0;
         int print_time = 0;
         clock_t s_time = 0, c_time = 0;
         int comp = 0;
 #ifndef OPENSSL_NO_COMP
         COMP_METHOD *cm = NULL;
 #endif
         STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
         int test_cipherlist = 0;
-#ifdef OPENSSL_FIPS
-        int fips_mode=0;
-#endif
-        int ssl_mode = 0;
-        int cutthrough = 0;
 
         verbose = 0;
         debug = 0;
         cipher = 0;
 
-        bio_err=BIO_new_fp(stderr,BIO_NOCLOSE); 
+        bio_err=BIO_new_fp(stderr,BIO_NOCLOSE|BIO_FP_TEXT);     
 
         CRYPTO_set_locking_callback(lock_dbg_cb);
 
         /* enable memory leak checking unless explicitly disabled */
         if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))
                 {
                 CRYPTO_malloc_debug_init();
                 CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
                 }
         else
                 {
                 /* OPENSSL_DEBUG_MEMORY=off */
                 CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
                 }
         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
 
         RAND_seed(rnd_seed, sizeof rnd_seed);
 
-        bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE);
+        bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE|BIO_FP_TEXT);
 
         argc--;
         argv++;
 
         while (argc >= 1)
                 {
-                if(!strcmp(*argv,"-F"))
-                        {
-#ifdef OPENSSL_FIPS
-                        fips_mode=1;
-#else
-                        fprintf(stderr,"not compiled with FIPS support, so exitting without running.\n");
-                        EXIT(0);
-#endif
-                        }
-                else if (strcmp(*argv,"-server_auth") == 0)
+                if      (strcmp(*argv,"-server_auth") == 0)
                         server_auth=1;
                 else if (strcmp(*argv,"-client_auth") == 0)
                         client_auth=1;
                 else if (strcmp(*argv,"-proxy_auth") == 0)
                         {
                         if (--argc < 1) goto bad;
                         app_verify_arg.proxy_auth= *(++argv);
                         }
                 else if (strcmp(*argv,"-proxy_cond") == 0)
                         {
@@ skipping 19 matching lines @@
 #ifndef OPENSSL_NO_DH
                         dhe1024dsa=1;
 #else
                         fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
 #endif
                         }
                 else if (strcmp(*argv,"-no_dhe") == 0)
                         no_dhe=1;
                 else if (strcmp(*argv,"-no_ecdhe") == 0)
                         no_ecdhe=1;
+                else if (strcmp(*argv,"-psk") == 0)
+                        {
+                        if (--argc < 1) goto bad;
+                        psk_key=*(++argv);
+#ifndef OPENSSL_NO_PSK
+                        if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key))
+                                {
+                                BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
+                                goto bad;
+                                }
+#else
+                        no_psk=1;
+#endif
+                        }
                 else if (strcmp(*argv,"-ssl2") == 0)
                         ssl2=1;
                 else if (strcmp(*argv,"-tls1") == 0)
                         tls1=1;
                 else if (strcmp(*argv,"-ssl3") == 0)
                         ssl3=1;
                 else if (strncmp(*argv,"-num",4) == 0)
                         {
                         if (--argc < 1) goto bad;
                         number= atoi(*(++argv));
@@ skipping 88 matching lines @@
                         app_verify_arg.app_verify = 1;
                         }
                 else if (strcmp(*argv,"-proxy") == 0)
                         {
                         app_verify_arg.allow_proxy_certs = 1;
                         }
                 else if (strcmp(*argv,"-test_cipherlist") == 0)
                         {
                         test_cipherlist = 1;
                         }
+                else if (strcmp(*argv, "-c_small_records") == 0)
+                        {
+                        c_small_records = 1;
+                        }
+                else if (strcmp(*argv, "-s_small_records") == 0)
+                        {
+                        s_small_records = 1;
+                        }
                 else if (strcmp(*argv, "-cutthrough") == 0)
                         {
                         cutthrough = 1;
                         }
                 else
                         {
                         fprintf(stderr,"unknown option %s\n",*argv);
                         badop=1;
                         break;
                         }
@@ skipping 18 matching lines @@
 
         if (!ssl2 && !ssl3 && !tls1 && number > 1 && !reuse && !force)
                 {
                 fprintf(stderr, "This case cannot work.  Use -f to perform "
                         "the test anyway (and\n-d to see what happens), "
                         "or add one of -ssl2, -ssl3, -tls1, -reuse\n"
                         "to avoid protocol mismatch.\n");
                 EXIT(1);
                 }
 
-#ifdef OPENSSL_FIPS
-        if(fips_mode)
-                {
-                if(!FIPS_mode_set(1))
-                        {
-                        ERR_load_crypto_strings();
-                        ERR_print_errors(BIO_new_fp(stderr,BIO_NOCLOSE));
-                        EXIT(1);
-                        }
-                else
-                        fprintf(stderr,"*** IN FIPS MODE ***\n");
-                }
-#endif
-
         if (print_time)
                 {
                 if (!bio_pair)
                         {
                         fprintf(stderr, "Using BIO pair (-bio_pair)\n");
                         bio_pair = 1;
                         }
                 if (number < 50 && !force)
                         fprintf(stderr, "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
                 }
@@ skipping 67 matching lines @@
                 {
                 ERR_print_errors(bio_err);
                 goto end;
                 }
 
         if (cipher != NULL)
                 {
                 SSL_CTX_set_cipher_list(c_ctx,cipher);
                 SSL_CTX_set_cipher_list(s_ctx,cipher);
                 }
+
+        ssl_mode = 0;
+        if (c_small_records)
+                {
+                ssl_mode = SSL_CTX_get_mode(c_ctx);
+                ssl_mode |= SSL_MODE_SMALL_BUFFERS;
+                SSL_CTX_set_mode(c_ctx, ssl_mode);
+                }
+        ssl_mode = 0;
+        if (s_small_records)
+                {
+                ssl_mode = SSL_CTX_get_mode(s_ctx);
+                ssl_mode |= SSL_MODE_SMALL_BUFFERS;
+                SSL_CTX_set_mode(s_ctx, ssl_mode);
+                }
         ssl_mode = 0;
         if (cutthrough)
                 {
                 ssl_mode = SSL_CTX_get_mode(c_ctx);
                 ssl_mode = SSL_MODE_HANDSHAKE_CUTTHROUGH;
                 SSL_CTX_set_mode(c_ctx, ssl_mode);
                 }
 
 #ifndef OPENSSL_NO_DH
         if (!no_dhe)
@@ skipping 44 matching lines @@
                 EC_KEY_free(ecdh);
                 }
 #else
         (void)no_ecdhe;
 #endif
 
 #ifndef OPENSSL_NO_RSA
         SSL_CTX_set_tmp_rsa_callback(s_ctx,tmp_rsa_cb);
 #endif
 
+#ifdef TLSEXT_TYPE_opaque_prf_input
+        SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
+        SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
+        SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1); /* or &co2 or NULL */
+        SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1); /* or &so2 or NULL */
+#endif
+
         if (!SSL_CTX_use_certificate_file(s_ctx,server_cert,SSL_FILETYPE_PEM))
                 {
                 ERR_print_errors(bio_err);
                 }
         else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
                 (server_key?server_key:server_cert), SSL_FILETYPE_PEM))
                 {
                 ERR_print_errors(bio_err);
                 goto end;
                 }
@@ skipping 31 matching lines @@
                 SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
                         verify_callback);
                 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback, &app_verify_arg);
                 }
         
         {
                 int session_id_context = 0;
                 SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context, sizeof session_id_context);
         }
 
+        /* Use PSK only if PSK key is given */
+        if (psk_key != NULL)
+                {
+                /* no_psk is used to avoid putting psk command to openssl tool */
+                if (no_psk)
+                        {
+                        /* if PSK is not compiled in and psk key is
+                         * given, do nothing and exit successfully */
+                        ret=0;
+                        goto end;
+                        }
+#ifndef OPENSSL_NO_PSK
+                SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
+                SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
+                if (debug)
+                        BIO_printf(bio_err,"setting PSK identity hint to s_ctx\n");
+                if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint"))
+                        {
+                        BIO_printf(bio_err,"error setting PSK identity hint to s_ctx\n");
+                        ERR_print_errors(bio_err);
+                        goto end;
+                        }
+#endif
+                }
+
         c_ssl=SSL_new(c_ctx);
         s_ssl=SSL_new(s_ctx);
 
 #ifndef OPENSSL_NO_KRB5
         if (c_ssl  &&  c_ssl->kssl_ctx)
                 {
                 char    localhost[MAXHOSTNAMELEN+2];
 
                 if (gethostname(localhost, sizeof localhost-1) == 0)
                         {
@@ skipping 56 matching lines @@
         if (bio_stdout != NULL) BIO_free(bio_stdout);
 
 #ifndef OPENSSL_NO_RSA
         free_tmp_rsa();
 #endif
 #ifndef OPENSSL_NO_ENGINE
         ENGINE_cleanup();
 #endif
         CRYPTO_cleanup_all_ex_data();
         ERR_free_strings();
-        ERR_remove_state(0);
+        ERR_remove_thread_state(NULL);
         EVP_cleanup();
         CRYPTO_mem_leaks(bio_err);
         if (bio_err != NULL) BIO_free(bio_err);
         EXIT(ret);
         return ret;
         }
 
 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
         clock_t *s_time, clock_t *c_time)
         {
@@ skipping 392 matching lines @@
         {
         MS_STATIC char cbuf[1024*8],sbuf[1024*8];
         long cw_num=count,cr_num=count;
         long sw_num=count,sr_num=count;
         int ret=1;
         BIO *c_to_s=NULL;
         BIO *s_to_c=NULL;
         BIO *c_bio=NULL;
         BIO *s_bio=NULL;
         int c_r,c_w,s_r,s_w;
-        int c_want,s_want;
         int i,j;
         int done=0;
         int c_write,s_write;
         int do_server=0,do_client=0;
 
         memset(cbuf,0,sizeof(cbuf));
         memset(sbuf,0,sizeof(sbuf));
 
         c_to_s=BIO_new(BIO_s_mem());
         s_to_c=BIO_new(BIO_s_mem());
@@ skipping 14 matching lines @@
         SSL_set_connect_state(c_ssl);
         SSL_set_bio(c_ssl,s_to_c,c_to_s);
         BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
 
         SSL_set_accept_state(s_ssl);
         SSL_set_bio(s_ssl,c_to_s,s_to_c);
         BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
 
         c_r=0; s_r=1;
         c_w=1; s_w=0;
-        c_want=W_WRITE;
-        s_want=0;
         c_write=1,s_write=0;
 
         /* We can always do writes */
         for (;;)
                 {
                 do_server=0;
                 do_client=0;
 
                 i=(int)BIO_pending(s_bio);
                 if ((i && s_r) || s_w) do_server=1;
@@ skipping 680 matching lines @@
 
                 X509_STORE_CTX_set_ex_data(ctx,
                         get_proxy_auth_ex_data_idx(),letters);
                 }
         if (cb_arg->allow_proxy_certs)
                 {
                 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
                 }
 
 #ifndef OPENSSL_NO_X509_VERIFY
+# ifdef OPENSSL_FIPS
+        if(s->version == TLS1_VERSION)
+                FIPS_allow_md5(1);
+# endif
         ok = X509_verify_cert(ctx);
+# ifdef OPENSSL_FIPS
+        if(s->version == TLS1_VERSION)
+                FIPS_allow_md5(0);
+# endif
 #endif
 
         if (cb_arg->proxy_auth)
                 {
                 if (ok > 0)
                         {
                         const char *cond_end = NULL;
 
                         ok = process_proxy_cond(letters,
                                 cb_arg->proxy_cond, &cond_end);
@@ skipping 148 matching lines @@
         if ((dh=DH_new()) == NULL) return(NULL);
         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
         if ((dh->p == NULL) || (dh->g == NULL))
                 { DH_free(dh); return(NULL); }
         dh->length = 160;
         return(dh);
         }
 #endif
 
+#ifndef OPENSSL_NO_PSK
+/* convert the PSK key (psk_key) in ascii to binary (psk) */
+static int psk_key2bn(const char *pskkey, unsigned char *psk,
+        unsigned int max_psk_len)
+        {
+        int ret;
+        BIGNUM *bn = NULL;
+
+        ret = BN_hex2bn(&bn, pskkey);
+        if (!ret)
+                {
+                BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey); 
+                if (bn)
+                        BN_free(bn);
+                return 0;
+                }
+        if (BN_num_bytes(bn) > (int)max_psk_len)
+                {
+                BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
+                        max_psk_len, BN_num_bytes(bn));
+                BN_free(bn);
+                return 0;
+                }
+        ret = BN_bn2bin(bn, psk);
+        BN_free(bn);
+        return ret;
+        }
+
+static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
+        unsigned int max_identity_len, unsigned char *psk,
+        unsigned int max_psk_len)
+        {
+        int ret;
+        unsigned int psk_len = 0;
+
+        ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
+        if (ret < 0)
+                goto out_err;
+        if (debug)
+                fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
+        ret = psk_key2bn(psk_key, psk, max_psk_len);
+        if (ret < 0)
+                goto out_err;
+        psk_len = ret;
+out_err:
+        return psk_len;
+        }
+
+static unsigned int psk_server_callback(SSL *ssl, const char *identity,
+        unsigned char *psk, unsigned int max_psk_len)
+        {
+        unsigned int psk_len=0;
+
+        if (strcmp(identity, "Client_identity") != 0)
+                {
+                BIO_printf(bio_err, "server: PSK error: client identity not found\n");
+                return 0;
+                }
+        psk_len=psk_key2bn(psk_key, psk, max_psk_len);
+        return psk_len;
+        }
+#endif
+
 static int do_test_cipherlist(void)
         {
         int i = 0;
         const SSL_METHOD *meth;
-        SSL_CIPHER *ci, *tci = NULL;
+        const SSL_CIPHER *ci, *tci = NULL;
 
 #ifndef OPENSSL_NO_SSL2
         fprintf(stderr, "testing SSLv2 cipher list order: ");
         meth = SSLv2_method();
         while ((ci = meth->get_cipher(i++)) != NULL)
                 {
                 if (tci != NULL)
                         if (ci->id >= tci->id)
                                 {
                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
@@ skipping 31 matching lines @@
                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
                                 return 0;
                                 }
                 tci = ci;
                 }
         fprintf(stderr, "ok\n");
 #endif
 
         return 1;
         }