/*

 * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.

 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved

 * Copyright 2005 Nokia. All rights reserved.

 *

 * Licensed under the OpenSSL license (the "License").  You may not use

 * this file except in compliance with the License.  You can obtain a copy

 * in the file LICENSE in the source distribution or at

 * https://www.openssl.org/source/license.html

 */

#include "e_os.h"

/* Or gethostname won't be declared properly on Linux and GNU platforms. */

#ifndef _BSD_SOURCE

# define _BSD_SOURCE 1

#endif

#ifndef _DEFAULT_SOURCE

# define _DEFAULT_SOURCE 1

#endif

#include <assert.h>

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include "internal/nelem.h"

#ifdef OPENSSL_SYS_VMS

/*

 * Or isascii won't be declared properly on VMS (at least with DECompHP C).

 */

# define _XOPEN_SOURCE 500

#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>

#include <openssl/err.h>

#include <openssl/rand.h>

#ifndef OPENSSL_NO_RSA

# include <openssl/rsa.h>

#endif

#ifndef OPENSSL_NO_DSA

# include <openssl/dsa.h>

#endif

#ifndef OPENSSL_NO_DH

# include <openssl/dh.h>

#endif

#include <openssl/bn.h>

#ifndef OPENSSL_NO_CT

# include <openssl/ct.h>

#endif

/*

 * Or gethostname won't be declared properly

 * on Compaq platforms (at least with DEC C).

 * Do not try to put it earlier, or IPv6 includes

 * get screwed...

 */

#define _XOPEN_SOURCE_EXTENDED  1

#ifdef OPENSSL_SYS_WINDOWS

# include <winsock.h>

#else

# include OPENSSL_UNISTD

#endif

static SSL_CTX *s_ctx = NULL;

static SSL_CTX *s_ctx2 = NULL;

/*

 * There is really no standard for this, so let's assign something

 * only for this test

 */

#define COMP_ZLIB       1

static int verify_callback(int ok, X509_STORE_CTX *ctx);

static int app_verify_callback(X509_STORE_CTX *ctx, void *arg);

#define APP_CALLBACK_STRING "Test Callback Argument"

struct app_verify_arg {

    char *string;

    int app_verify;

};

#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;

#ifndef OPENSSL_NO_NEXTPROTONEG

/* Note that this code assumes that this is only a one element list: */

static const char NEXT_PROTO_STRING[] = "\x09testproto";

static int npn_client = 0;

static int npn_server = 0;

static int npn_server_reject = 0;

static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen,

                         const unsigned char *in, unsigned int inlen,

                         void *arg)

{

    /*

     * This callback only returns the protocol string, rather than a length

     * prefixed set. We assume that NEXT_PROTO_STRING is a one element list

     * and remove the first byte to chop off the length prefix.

     */

    *out = (unsigned char *)NEXT_PROTO_STRING + 1;

    *outlen = sizeof(NEXT_PROTO_STRING) - 2;

    return SSL_TLSEXT_ERR_OK;

}

static int cb_server_npn(SSL *s, const unsigned char **data,

                         unsigned int *len, void *arg)

{

    *data = (const unsigned char *)NEXT_PROTO_STRING;

    *len = sizeof(NEXT_PROTO_STRING) - 1;

    return SSL_TLSEXT_ERR_OK;

}

static int cb_server_rejects_npn(SSL *s, const unsigned char **data,

                                 unsigned int *len, void *arg)

{

    return SSL_TLSEXT_ERR_NOACK;

}

static int verify_npn(SSL *client, SSL *server)

{

    const unsigned char *client_s;

    unsigned client_len;

    const unsigned char *server_s;

    unsigned server_len;

    SSL_get0_next_proto_negotiated(client, &client_s, &client_len);

    SSL_get0_next_proto_negotiated(server, &server_s, &server_len);

    if (client_len) {

        BIO_printf(bio_stdout, "Client NPN: ");

        BIO_write(bio_stdout, client_s, client_len);

        BIO_printf(bio_stdout, "\n");

    }

    if (server_len) {

        BIO_printf(bio_stdout, "Server NPN: ");

        BIO_write(bio_stdout, server_s, server_len);

        BIO_printf(bio_stdout, "\n");

    }

    /*

     * If an NPN string was returned, it must be the protocol that we

     * expected to negotiate.

     */

    if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||

                       memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))

        return -1;

    if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||

                       memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))

        return -1;

    if (!npn_client && client_len)

        return -1;

    if (!npn_server && server_len)

        return -1;

    if (npn_server_reject && server_len)

        return -1;

    if (npn_client && npn_server && (!client_len || !server_len))

        return -1;

    return 0;

}

#endif

static const char *alpn_client;

static char *alpn_server;

static char *alpn_server2;

static const char *alpn_expected;

static unsigned char *alpn_selected;

static const char *server_min_proto;

static const char *server_max_proto;

static const char *client_min_proto;

static const char *client_max_proto;

static const char *should_negotiate;

static const char *sn_client;

static const char *sn_server1;

static const char *sn_server2;

static int sn_expect = 0;

static const char *server_sess_out;

static const char *server_sess_in;

static const char *client_sess_out;

static const char *client_sess_in;

static SSL_SESSION *server_sess;

static SSL_SESSION *client_sess;

static int servername_cb(SSL *s, int *ad, void *arg)

{

    const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);

    if (sn_server2 == NULL) {

        BIO_printf(bio_stdout, "Servername 2 is NULL\n");

        return SSL_TLSEXT_ERR_NOACK;

    }

    if (servername) {

        if (s_ctx2 != NULL && sn_server2 != NULL &&

            !strcasecmp(servername, sn_server2)) {

            BIO_printf(bio_stdout, "Switching server context.\n");

            SSL_set_SSL_CTX(s, s_ctx2);

        }

    }

    return SSL_TLSEXT_ERR_OK;

}

static int verify_servername(SSL *client, SSL *server)

{

    /* just need to see if sn_context is what we expect */

    SSL_CTX* ctx = SSL_get_SSL_CTX(server);

    if (sn_expect == 0)

        return 0;

    if (sn_expect == 1 && ctx == s_ctx)

        return 0;

    if (sn_expect == 2 && ctx == s_ctx2)

        return 0;

    BIO_printf(bio_stdout, "Servername: expected context %d\n", sn_expect);

    if (ctx == s_ctx2)

        BIO_printf(bio_stdout, "Servername: context is 2\n");

    else if (ctx == s_ctx)

        BIO_printf(bio_stdout, "Servername: context is 1\n");

    else

        BIO_printf(bio_stdout, "Servername: context is unknown\n");

    return -1;

}

/*-

 * next_protos_parse parses a comma separated list of strings into a string

 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.

 *   outlen: (output) set to the length of the resulting buffer on success.

 *   in: a NUL terminated string like "abc,def,ghi"

 *

 *   returns: a malloced buffer or NULL on failure.

 */

static unsigned char *next_protos_parse(size_t *outlen,

                                        const char *in)

{

    size_t len;

    unsigned char *out;

    size_t i, start = 0;

    len = strlen(in);

    if (len >= 65535)

        return NULL;

    out = OPENSSL_malloc(strlen(in) + 1);

    if (!out)

        return NULL;

    for (i = 0; i <= len; ++i) {

        if (i == len || in[i] == ',') {

            if (i - start > 255) {

                OPENSSL_free(out);

                return NULL;

            }

            out[start] = (unsigned char)(i - start);

            start = i + 1;

        } else

            out[i + 1] = in[i];

    }

    *outlen = len + 1;

    return out;

}

static int cb_server_alpn(SSL *s, const unsigned char **out,

                          unsigned char *outlen, const unsigned char *in,

                          unsigned int inlen, void *arg)

{

    unsigned char *protos;

    size_t protos_len;

    char* alpn_str = arg;

    protos = next_protos_parse(&protos_len, alpn_str);

    if (protos == NULL) {

        fprintf(stderr, "failed to parser ALPN server protocol string: %s\n",

                alpn_str);

        abort();

    }

    if (SSL_select_next_proto

        ((unsigned char **)out, outlen, protos, protos_len, in,

         inlen) != OPENSSL_NPN_NEGOTIATED) {

        OPENSSL_free(protos);

        return SSL_TLSEXT_ERR_NOACK;

    }

    /*

     * Make a copy of the selected protocol which will be freed in

     * verify_alpn.

     */

    alpn_selected = OPENSSL_malloc(*outlen);

    memcpy(alpn_selected, *out, *outlen);

    *out = alpn_selected;

    OPENSSL_free(protos);

    return SSL_TLSEXT_ERR_OK;

}

static int verify_alpn(SSL *client, SSL *server)

{

    const unsigned char *client_proto, *server_proto;

    unsigned int client_proto_len = 0, server_proto_len = 0;

    SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);

    SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);

    OPENSSL_free(alpn_selected);

    alpn_selected = NULL;

    if (client_proto_len != server_proto_len) {

        BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");

        goto err;

    }

    if (client_proto != NULL &&

        memcmp(client_proto, server_proto, client_proto_len) != 0) {

        BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");

        goto err;

    }

    if (client_proto_len > 0 && alpn_expected == NULL) {

        BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");

        goto err;

    }

    if (alpn_expected != NULL &&

        (client_proto_len != strlen(alpn_expected) ||

         memcmp(client_proto, alpn_expected, client_proto_len) != 0)) {

        BIO_printf(bio_stdout,

                   "ALPN selected protocols not equal to expected protocol: %s\n",

                   alpn_expected);

        goto err;

    }

    return 0;

 err:

    BIO_printf(bio_stdout, "ALPN results: client: '");

    BIO_write(bio_stdout, client_proto, client_proto_len);

    BIO_printf(bio_stdout, "', server: '");

    BIO_write(bio_stdout, server_proto, server_proto_len);

    BIO_printf(bio_stdout, "'\n");

    BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '",

                   alpn_client);

    if (SSL_get_SSL_CTX(server) == s_ctx2) {

        BIO_printf(bio_stdout, "%s'\n",

                   alpn_server2);

    } else {

        BIO_printf(bio_stdout, "%s'\n",

                   alpn_server);

    }

    return -1;

}

/*

 * WARNING : below extension types are *NOT* IETF assigned, and could

 * conflict if these types are reassigned and handled specially by OpenSSL

 * in the future

 */

#define TACK_EXT_TYPE 62208

#define CUSTOM_EXT_TYPE_0 1000

#define CUSTOM_EXT_TYPE_1 1001

#define CUSTOM_EXT_TYPE_2 1002

#define CUSTOM_EXT_TYPE_3 1003

static const char custom_ext_cli_string[] = "abc";

static const char custom_ext_srv_string[] = "defg";

/* These set from cmdline */

static char *serverinfo_file = NULL;

static int serverinfo_sct = 0;

static int serverinfo_tack = 0;

/* These set based on extension callbacks */

static int serverinfo_sct_seen = 0;

static int serverinfo_tack_seen = 0;

static int serverinfo_other_seen = 0;

/* This set from cmdline */

static int custom_ext = 0;

/* This set based on extension callbacks */

static int custom_ext_error = 0;

static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char *in, size_t inlen,

                                   int *al, void *arg)

{

    if (ext_type == TLSEXT_TYPE_signed_certificate_timestamp)

        serverinfo_sct_seen++;

    else if (ext_type == TACK_EXT_TYPE)

        serverinfo_tack_seen++;

    else

        serverinfo_other_seen++;

    return 1;

}

static int verify_serverinfo(void)

{

    if (serverinfo_sct != serverinfo_sct_seen)

        return -1;

    if (serverinfo_tack != serverinfo_tack_seen)

        return -1;

    if (serverinfo_other_seen)

        return -1;

    return 0;

}

/*-

 * Four test cases for custom extensions:

 * 0 - no ClientHello extension or ServerHello response

 * 1 - ClientHello with "abc", no response

 * 2 - ClientHello with "abc", empty response

 * 3 - ClientHello with "abc", "defg" response

 */

static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char **out,

                                   size_t *outlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_0)

        custom_ext_error = 1;

    return 0;                   /* Don't send an extension */

}

static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,

                                     const unsigned char *in,

                                     size_t inlen, int *al, void *arg)

{

    return 1;

}

static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char **out,

                                   size_t *outlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_1)

        custom_ext_error = 1;

    *out = (const unsigned char *)custom_ext_cli_string;

    *outlen = strlen(custom_ext_cli_string);

    return 1;                   /* Send "abc" */

}

static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,

                                     const unsigned char *in,

                                     size_t inlen, int *al, void *arg)

{

    return 1;

}

static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char **out,

                                   size_t *outlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_2)

        custom_ext_error = 1;

    *out = (const unsigned char *)custom_ext_cli_string;

    *outlen = strlen(custom_ext_cli_string);

    return 1;                   /* Send "abc" */

}

static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,

                                     const unsigned char *in,

                                     size_t inlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_2)

        custom_ext_error = 1;

    if (inlen != 0)

        custom_ext_error = 1;   /* Should be empty response */

    return 1;

}

static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char **out,

                                   size_t *outlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_3)

        custom_ext_error = 1;

    *out = (const unsigned char *)custom_ext_cli_string;

    *outlen = strlen(custom_ext_cli_string);

    return 1;                   /* Send "abc" */

}

static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,

                                     const unsigned char *in,

                                     size_t inlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_3)

        custom_ext_error = 1;

    if (inlen != strlen(custom_ext_srv_string))

        custom_ext_error = 1;

    if (memcmp(custom_ext_srv_string, in, inlen) != 0)

        custom_ext_error = 1;   /* Check for "defg" */

    return 1;

}

/*

 * custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback

 * for this extension

 */

static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,

                                     const unsigned char *in,

                                     size_t inlen, int *al, void *arg)

{

    custom_ext_error = 1;

    return 1;

}

/* 'add' callbacks are only called if the 'parse' callback is called */

static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char **out,

                                   size_t *outlen, int *al, void *arg)

{

    /* Error: should not have been called */

    custom_ext_error = 1;

    return 0;                   /* Don't send an extension */

}

static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,

                                     const unsigned char *in,

                                     size_t inlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_1)

        custom_ext_error = 1;

    /* Check for "abc" */

    if (inlen != strlen(custom_ext_cli_string))

        custom_ext_error = 1;

    if (memcmp(in, custom_ext_cli_string, inlen) != 0)

        custom_ext_error = 1;

    return 1;

}

static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char **out,

                                   size_t *outlen, int *al, void *arg)

{

    return 0;                   /* Don't send an extension */

}

static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,

                                     const unsigned char *in,

                                     size_t inlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_2)

        custom_ext_error = 1;

    /* Check for "abc" */

    if (inlen != strlen(custom_ext_cli_string))

        custom_ext_error = 1;

    if (memcmp(in, custom_ext_cli_string, inlen) != 0)

        custom_ext_error = 1;

    return 1;

}

static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char **out,

                                   size_t *outlen, int *al, void *arg)

{

    *out = NULL;

    *outlen = 0;

    return 1;                   /* Send empty extension */

}

static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,

                                     const unsigned char *in,

                                     size_t inlen, int *al, void *arg)

{

    if (ext_type != CUSTOM_EXT_TYPE_3)

        custom_ext_error = 1;

    /* Check for "abc" */

    if (inlen != strlen(custom_ext_cli_string))

        custom_ext_error = 1;

    if (memcmp(in, custom_ext_cli_string, inlen) != 0)

        custom_ext_error = 1;

    return 1;

}

static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,

                                   const unsigned char **out,

                                   size_t *outlen, int *al, void *arg)

{

    *out = (const unsigned char *)custom_ext_srv_string;

    *outlen = strlen(custom_ext_srv_string);

    return 1;                   /* Send "defg" */

}

static char *cipher = NULL;

static char *ciphersuites = NULL;

static int verbose = 0;

static int debug = 0;

int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family,

                   long bytes, clock_t *s_time, clock_t *c_time);

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 void sv_usage(void)

{

    fprintf(stderr, "usage: ssltest [args ...]\n");

    fprintf(stderr, "\n");

    fprintf(stderr, " -server_auth  - check server certificate\n");

    fprintf(stderr, " -client_auth  - do client authentication\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,

            " -dhe512       - use 512 bit key for DHE (to test failure)\n");

    fprintf(stderr,

            " -dhe1024      - use 1024 bit key (safe prime) for DHE (default, no-op)\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_EC

    fprintf(stderr, " -no_ecdhe     - disable ECDHE\nTODO(openssl-team): no_ecdhe was broken by auto ecdh. Make this work again.\n");

#endif

#ifndef OPENSSL_NO_PSK

    fprintf(stderr, " -psk arg      - PSK in hex (without 0x)\n");

#endif

#ifndef OPENSSL_NO_SSL3

    fprintf(stderr, " -ssl3         - use SSLv3\n");

#endif

#ifndef OPENSSL_NO_TLS1

    fprintf(stderr, " -tls1         - use TLSv1\n");

#endif

#ifndef OPENSSL_NO_DTLS

    fprintf(stderr, " -dtls         - use DTLS\n");

#ifndef OPENSSL_NO_DTLS1

    fprintf(stderr, " -dtls1        - use DTLSv1\n");

#endif

#ifndef OPENSSL_NO_DTLS1_2

    fprintf(stderr, " -dtls12       - use DTLSv1.2\n");

#endif

#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 TLSv1.2 and below cipher list\n");

    fprintf(stderr, " -ciphersuites arg   - The TLSv1.3 ciphersuites\n");

    fprintf(stderr, " -bio_pair     - Use BIO pairs\n");

    fprintf(stderr, " -ipv4         - Use IPv4 connection on localhost\n");

    fprintf(stderr, " -ipv6         - Use IPv6 connection on localhost\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");

#ifndef OPENSSL_NO_NEXTPROTONEG

    fprintf(stderr, " -npn_client - have client side offer NPN\n");

    fprintf(stderr, " -npn_server - have server side offer NPN\n");

    fprintf(stderr, " -npn_server_reject - have server reject NPN\n");

#endif

    fprintf(stderr, " -serverinfo_file file - have server use this file\n");

    fprintf(stderr, " -serverinfo_sct  - have client offer and expect SCT\n");

    fprintf(stderr,

            " -serverinfo_tack - have client offer and expect TACK\n");

    fprintf(stderr,

            " -custom_ext - try various custom extension callbacks\n");

    fprintf(stderr, " -alpn_client <string> - have client side offer ALPN\n");

    fprintf(stderr, " -alpn_server <string> - have server side offer ALPN\n");

    fprintf(stderr, " -alpn_server1 <string> - alias for -alpn_server\n");

    fprintf(stderr, " -alpn_server2 <string> - have server side context 2 offer ALPN\n");

    fprintf(stderr,

            " -alpn_expected <string> - the ALPN protocol that should be negotiated\n");

    fprintf(stderr, " -server_min_proto <string> - Minimum version the server should support\n");

    fprintf(stderr, " -server_max_proto <string> - Maximum version the server should support\n");

    fprintf(stderr, " -client_min_proto <string> - Minimum version the client should support\n");

    fprintf(stderr, " -client_max_proto <string> - Maximum version the client should support\n");

    fprintf(stderr, " -should_negotiate <string> - The version that should be negotiated, fail-client or fail-server\n");

#ifndef OPENSSL_NO_CT

    fprintf(stderr, " -noct         - no certificate transparency\n");

    fprintf(stderr, " -requestct    - request certificate transparency\n");

    fprintf(stderr, " -requirect    - require certificate transparency\n");

#endif

    fprintf(stderr, " -sn_client <string>  - have client request this servername\n");

    fprintf(stderr, " -sn_server1 <string> - have server context 1 respond to this servername\n");

    fprintf(stderr, " -sn_server2 <string> - have server context 2 respond to this servername\n");

    fprintf(stderr, " -sn_expect1          - expected server 1\n");

    fprintf(stderr, " -sn_expect2          - expected server 2\n");

    fprintf(stderr, " -server_sess_out <file>    - Save the server session to a file\n");

    fprintf(stderr, " -server_sess_in <file>     - Read the server session from a file\n");

    fprintf(stderr, " -client_sess_out <file>    - Save the client session to a file\n");

    fprintf(stderr, " -client_sess_in <file>     - Read the client session from a file\n");

    fprintf(stderr, " -should_reuse <number>     - The expected state of reusing the session\n");

    fprintf(stderr, " -no_ticket    - do not issue TLS session ticket\n");

}

static void print_key_details(BIO *out, EVP_PKEY *key)

{

    int keyid = EVP_PKEY_id(key);

#ifndef OPENSSL_NO_EC

    if (keyid == EVP_PKEY_EC) {

        EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);

        int nid;

        const char *cname;

        nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));

        EC_KEY_free(ec);

        cname = EC_curve_nid2nist(nid);

        if (!cname)

            cname = OBJ_nid2sn(nid);

        BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);

    } else

#endif

    {

        const char *algname;

        switch (keyid) {

        case EVP_PKEY_RSA:

            algname = "RSA";

            break;

        case EVP_PKEY_DSA:

            algname = "DSA";

            break;

        case EVP_PKEY_DH:

            algname = "DH";

            break;

        default:

            algname = OBJ_nid2sn(keyid);

            break;

        }

        BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);

    }

}

static void print_details(SSL *c_ssl, const char *prefix)

{

    const SSL_CIPHER *ciph;

    int mdnid;

    X509 *cert;

    EVP_PKEY *pkey;

    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) {

        EVP_PKEY* pubkey = X509_get0_pubkey(cert);

        if (pubkey != NULL) {

            BIO_puts(bio_stdout, ", ");

            print_key_details(bio_stdout, pubkey);

        }

        X509_free(cert);

    }

    if (SSL_get_peer_tmp_key(c_ssl, &pkey)) {

        BIO_puts(bio_stdout, ", temp key: ");

        print_key_details(bio_stdout, pkey);

        EVP_PKEY_free(pkey);

    }

    if (SSL_get_peer_signature_nid(c_ssl, &mdnid))

        BIO_printf(bio_stdout, ", digest=%s", OBJ_nid2sn(mdnid));

    BIO_printf(bio_stdout, "\n");

}

/*

 * protocol_from_string - converts a protocol version string to a number

 *

 * Returns -1 on failure or the version on success

 */

static int protocol_from_string(const char *value)

{

    struct protocol_versions {

        const char *name;

        int version;

    };

    static const struct protocol_versions versions[] = {

        {"ssl3", SSL3_VERSION},

        {"tls1", TLS1_VERSION},

        {"tls1.1", TLS1_1_VERSION},

        {"tls1.2", TLS1_2_VERSION},

        {"tls1.3", TLS1_3_VERSION},

        {"dtls1", DTLS1_VERSION},

        {"dtls1.2", DTLS1_2_VERSION}};

    size_t i;

    size_t n = OSSL_NELEM(versions);

    for (i = 0; i < n; i++)

        if (strcmp(versions[i].name, value) == 0)

            return versions[i].version;

    return -1;

}

static SSL_SESSION *read_session(const char *filename)

{

    SSL_SESSION *sess;

    BIO *f = BIO_new_file(filename, "r");

    if (f == NULL) {

        BIO_printf(bio_err, "Can't open session file %s\n", filename);

        ERR_print_errors(bio_err);

        return NULL;

    }

    sess = PEM_read_bio_SSL_SESSION(f, NULL, 0, NULL);

    if (sess == NULL) {

        BIO_printf(bio_err, "Can't parse session file %s\n", filename);

        ERR_print_errors(bio_err);

    }

    BIO_free(f);

    return sess;

}

static int write_session(const char *filename, SSL_SESSION *sess)

{

    BIO *f = BIO_new_file(filename, "w");

    if (sess == NULL) {

        BIO_printf(bio_err, "No session information\n");

        return 0;

    }

    if (f == NULL) {

        BIO_printf(bio_err, "Can't open session file %s\n", filename);

        ERR_print_errors(bio_err);

        return 0;

    }

    PEM_write_bio_SSL_SESSION(f, sess);

    BIO_free(f);

    return 1;

}

/*

 * set_protocol_version - Sets protocol version minimum or maximum

 *

 * Returns 0 on failure and 1 on success

 */

static int set_protocol_version(const char *version, SSL *ssl, int setting)

{

    if (version != NULL) {

        int ver = protocol_from_string(version);

        if (ver < 0) {

            BIO_printf(bio_err, "Error parsing: %s\n", version);

            return 0;

        }

        return SSL_ctrl(ssl, setting, ver, NULL);

    }

    return 1;

}

int main(int argc, char *argv[])

{

    const char *CApath = NULL, *CAfile = NULL;

    int badop = 0;

    enum { BIO_MEM, BIO_PAIR, BIO_IPV4, BIO_IPV6 } bio_type = BIO_MEM;

    int force = 0;