text: /*
   *  SSL client with certificate authentication
   *
   *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
   *  SPDX-License-Identifier: Apache-2.0
   *
   *  Licensed under the Apache License, Version 2.0 (the "License"); you may
   *  not use this file except in compliance with the License.
   *  You may obtain a copy of the License at
   *
   *  http://www.apache.org/licenses/LICENSE-2.0
   *
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   *
   *  This file is part of mbed TLS (https://tls.mbed.org)
   */
  
  #include "Enclave_t.h"
  #include "enc.h"
  #include "Log.h"
  #include "pprint.h"
  
  #if !defined(MBEDTLS_CONFIG_FILE)
  #include "mbedtls/config.h"
  #else
  #include MBEDTLS_CONFIG_FILE
  #endif
  
  #if defined(MBEDTLS_PLATFORM_C)
  #include "mbedtls/platform.h"
  #else
  #include <stdio.h>
  #define mbedtls_printf     printf
  #define mbedtls_fprintf    fprintf
  #define mbedtls_snprintf   snprintf
  #endif
  
  #if !defined(MBEDTLS_ENTROPY_C) || \
      !defined(MBEDTLS_SSL_TLS_C) || !defined(MBEDTLS_SSL_CLI_C) || \
      !defined(MBEDTLS_CTR_DRBG_C)
  #else
  
  
  
  #include "mbedtls/net.h"
  #include "mbedtls/ssl.h"
  #include "mbedtls/entropy.h"
  #include "mbedtls/ctr_drbg.h"
  #include "mbedtls/certs.h"
  #include "mbedtls/x509.h"
  #include "mbedtls/error.h"
  #include "mbedtls/debug.h"
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  
  
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
  #if defined(MBEDTLS_FS_IO)
  #define USAGE_IO \
      "    ca_file=%%s          The single file containing the top-level CA(s) you fully trust\n" \
      "                        default: \"\" (pre-loaded)\n" \
      "    ca_path=%%s          The path containing the top-level CA(s) you fully trust\n" \
      "                        default: \"\" (pre-loaded) (overrides ca_file)\n" \
      "    crt_file=%%s         Your own cert and chain (in bottom to top order, top may be omitted)\n" \
      "                        default: \"\" (pre-loaded)\n" \
      "    key_file=%%s         default: \"\" (pre-loaded)\n"
  #else
  #define USAGE_IO \
      "    No file operations available (MBEDTLS_FS_IO not defined)\n"
  #endif /* MBEDTLS_FS_IO */
  #else
  #define USAGE_IO ""
  #endif /* MBEDTLS_X509_CRT_PARSE_C */
  
  #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
  #define USAGE_PSK                                                   \
      "    psk=%%s              default: \"\" (in hex, without 0x)\n" \
      "    psk_identity=%%s     default: \"Client_identity\"\n"
  #else
  #define USAGE_PSK ""
  #endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
  
  #if defined(MBEDTLS_SSL_SESSION_TICKETS)
  #define USAGE_TICKETS                                       \
      "    tickets=%%d          default: 1 (enabled)\n"
  #else
  #define USAGE_TICKETS ""
  #endif /* MBEDTLS_SSL_SESSION_TICKETS */
  
  #if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
  #define USAGE_TRUNC_HMAC                                    \
      "    trunc_hmac=%%d       default: library default\n"
  #else
  #define USAGE_TRUNC_HMAC ""
  #endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
  
  #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
  #define USAGE_MAX_FRAG_LEN                                      \
      "    max_frag_len=%%d     default: 16384 (tls default)\n"   \
      "                        options: 512, 1024, 2048, 4096\n"
  #else
  #define USAGE_MAX_FRAG_LEN ""
  #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
  
  #if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
  #define USAGE_RECSPLIT \
      "    recsplit=0/1        default: (library default: on)\n"
  #else
  #define USAGE_RECSPLIT
  #endif
  
  #if defined(MBEDTLS_DHM_C)
  #define USAGE_DHMLEN \
      "    dhmlen=%%d           default: (library default: 1024 bits)\n"
  #else
  #define USAGE_DHMLEN
  #endif
  
  #if defined(MBEDTLS_SSL_ALPN)
  #define USAGE_ALPN \
      "    alpn=%%s             default: \"\" (disabled)\n"   \
      "                        example: spdy/1,http/1.1\n"
  #else
  #define USAGE_ALPN ""
  #endif /* MBEDTLS_SSL_ALPN */
  
  #if defined(MBEDTLS_SSL_PROTO_DTLS)
  #define USAGE_DTLS \
      "    dtls=%%d             default: 0 (TLS)\n"                           \
      "    hs_timeout=%%d-%%d    default: (library default: 1000-60000)\n"    \
      "                        range of DTLS handshake timeouts in millisecs\n"
  #else
  #define USAGE_DTLS ""
  #endif
  
  #if defined(MBEDTLS_SSL_FALLBACK_SCSV)
  #define USAGE_FALLBACK \
      "    fallback=0/1        default: (library default: off)\n"
  #else
  #define USAGE_FALLBACK ""
  #endif
  
  #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
  #define USAGE_EMS \
      "    extended_ms=0/1     default: (library default: on)\n"
  #else
  #define USAGE_EMS ""
  #endif
  
  #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
  #define USAGE_ETM \
      "    etm=0/1             default: (library default: on)\n"
  #else
  #define USAGE_ETM ""
  #endif
  
  #if defined(MBEDTLS_SSL_RENEGOTIATION)
  #define USAGE_RENEGO \
      "    renegotiation=%%d    default: 0 (disabled)\n"      \
      "    renegotiate=%%d      default: 0 (disabled)\n"
  #else
  #define USAGE_RENEGO ""
  #endif
  
  #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
  #define USAGE_ECJPAKE \
      "    ecjpake_pw=%%s       default: none (disabled)\n"
  #else
  #define USAGE_ECJPAKE ""
  #endif
  
  #define USAGE \
      "\n usage: ssl_client2 param=<>...\n"                   \
      "\n acceptable parameters:\n"                           \
      "    server_name=%%s      default: localhost\n"         \
      "    server_addr=%%s      default: given by name\n"     \
      "    server_port=%%d      default: 4433\n"              \
      "    request_page=%%s     default: \".\"\n"             \
      "    request_size=%%d     default: about 34 (basic request)\n" \
      "                        (minimum: 0, max: 16384)\n" \
      "    debug_level=%%d      default: 0 (disabled)\n"      \
      "    nbio=%%d             default: 0 (blocking I/O)\n"  \
      "                        options: 1 (non-blocking), 2 (added delays)\n" \
      "    read_timeout=%%d     default: 0 ms (no timeout)\n"    \
      "    max_resend=%%d       default: 0 (no resend on timeout)\n" \
      "\n"                                                    \
      USAGE_DTLS                                              \
      "\n"                                                    \
      "    auth_mode=%%s        default: (library default: none)\n"      \
      "                        options: none, optional, required\n" \
      USAGE_IO                                                \
      "\n"                                                    \
      USAGE_PSK                                               \
      USAGE_ECJPAKE                                           \
      "\n"                                                    \
      "    allow_legacy=%%d     default: (library default: no)\n"      \
      USAGE_RENEGO                                            \
      "    exchanges=%%d        default: 1\n"                 \
      "    reconnect=%%d        default: 0 (disabled)\n"      \
      "    reco_delay=%%d       default: 0 seconds\n"         \
      "    reconnect_hard=%%d   default: 0 (disabled)\n"      \
      USAGE_TICKETS                                           \
      USAGE_MAX_FRAG_LEN                                      \
      USAGE_TRUNC_HMAC                                        \
      USAGE_ALPN                                              \
      USAGE_FALLBACK                                          \
      USAGE_EMS                                               \
      USAGE_ETM                                               \
      USAGE_RECSPLIT                                          \
      USAGE_DHMLEN                                            \
      "\n"                                                    \
      "    arc4=%%d             default: (library default: 0)\n" \
      "    min_version=%%s      default: (library default: tls1)\n"       \
      "    max_version=%%s      default: (library default: tls1_2)\n"     \
      "    force_version=%%s    default: \"\" (none)\n"       \
      "                        options: ssl3, tls1, tls1_1, tls1_2, dtls1, dtls1_2\n" \
      "\n"                                                    \
      "    force_ciphersuite=<name>    default: all enabled\n"\
      " acceptable ciphersuite names:\n"
  
  /*
   * global options
   */
  
  
  
  
  static void my_debug( void *ctx, int level,
                        const char *file, int line,
                        const char *str )
  {
      const char *p, *basename;
      (void)(ctx);
  
      /* Extract basename from file */
      for( p = basename = file; *p != '\0'; p++ )
          if( *p == '/' || *p == '\\' )
              basename = p + 1;
  
      mbedtls_printf("%s:%04d: |%d| %s", basename, line, level, str );
  }
  
  /*
   * Test recv/send functions that make sure each try returns
   * WANT_READ/WANT_WRITE at least once before sucesseding
   */
  static int my_recv( void *ctx, unsigned char *buf, size_t len )
  {
      static int first_try = 1;
      int ret;
  
      if( first_try )
      {
          first_try = 0;
          return( MBEDTLS_ERR_SSL_WANT_READ );
      }
  
      ret = mbedtls_net_recv_ocall( ctx, buf, len );
      if( ret != MBEDTLS_ERR_SSL_WANT_READ )
          first_try = 1; /* Next call will be a new operation */
      return( ret );
  }
  
  static int my_send( void *ctx, const unsigned char *buf, size_t len )
  {
      static int first_try = 1;
      int ret;
  
      if( first_try )
      {
          first_try = 0;
          return( MBEDTLS_ERR_SSL_WANT_WRITE );
      }
  
      ret = mbedtls_net_send_ocall( ctx, buf, len );
      if( ret != MBEDTLS_ERR_SSL_WANT_WRITE )
          first_try = 1; /* Next call will be a new operation */
      return( ret );
  }
  
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
  /*
   * Enabled if debug_level > 1 in code below
   */
  static int my_verify( void *data, mbedtls_x509_crt *crt, int depth, uint32_t *flags )
  {
      char buf[1024];
      ((void) data);
  
      mbedtls_printf( "\nVerify requested for (Depth %d):\n", depth );
      mbedtls_x509_crt_info( buf, sizeof( buf ) - 1, "", crt );
      mbedtls_printf( "%s", buf );
  
      if ( ( *flags ) == 0 )
          mbedtls_printf( "  This certificate has no flags\n" );
      else
      {
          mbedtls_x509_crt_verify_info( buf, sizeof( buf ), "  ! ", *flags );
          mbedtls_printf( "%s\n", buf );
      }
  
      return( 0 );
  }
  #endif /* MBEDTLS_X509_CRT_PARSE_C */
  
  int ssl_client(client_opt_t opt, char* headers[], int n_header, unsigned char* output, int length)
  {
      int ret = 0, len, tail_len, i, written, frags, retry_left;
      mbedtls_net_context server_fd;
      unsigned char buf[MBEDTLS_SSL_MAX_CONTENT_LEN + 1];
  
  #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
      unsigned char psk[MBEDTLS_PSK_MAX_LEN];
      size_t psk_len = 0;
  #endif
  #if defined(MBEDTLS_SSL_ALPN)
      const char *alpn_list[10];
  #endif
      const char *pers = "ssl_client2";
  
      mbedtls_entropy_context entropy;
      mbedtls_ctr_drbg_context ctr_drbg;
      mbedtls_ssl_context ssl;
      mbedtls_ssl_config conf;
      mbedtls_ssl_session saved_session;
  #if defined(MBEDTLS_TIMING_C)
      mbedtls_timing_delay_context timer;
  #endif
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
      uint32_t flags;
      mbedtls_x509_crt cacert;
      mbedtls_x509_crt clicert;
      mbedtls_pk_context pkey;
  #endif
      char *p;
      const int *list;
  
      /*
       * Make sure memory references are valid.
       */
      mbedtls_net_init_ocall( &server_fd );
      mbedtls_ssl_init( &ssl );
      mbedtls_ssl_config_init( &conf );
      memset( &saved_session, 0, sizeof( mbedtls_ssl_session ) );
      mbedtls_ctr_drbg_init( &ctr_drbg );
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
      mbedtls_x509_crt_init( &cacert );
      mbedtls_x509_crt_init( &clicert );
      mbedtls_pk_init( &pkey );
  #endif
  #if defined(MBEDTLS_SSL_ALPN)
      memset( (void * ) alpn_list, 0, sizeof( alpn_list ) );
  #endif
  
  #if defined(MBEDTLS_DEBUG_C)
      mbedtls_debug_set_threshold( opt.debug_level );
  #endif
  
      if( opt.force_ciphersuite[0] > 0 )
      {
          const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
          ciphersuite_info = mbedtls_ssl_ciphersuite_from_id( opt.force_ciphersuite[0] );
  
          if( opt.max_version != -1 &&
              ciphersuite_info->min_minor_ver > opt.max_version )
          {
              mbedtls_printf("forced ciphersuite not allowed with this protocol version\n");
              ret = 2;
              goto usage;
          }
          if( opt.min_version != -1 &&
              ciphersuite_info->max_minor_ver < opt.min_version )
          {
              mbedtls_printf("forced ciphersuite not allowed with this protocol version\n");
              ret = 2;
              goto usage;
          }
  
          /* If the server selects a version that's not supported by
           * this suite, then there will be no common ciphersuite... */
          if( opt.max_version == -1 ||
              opt.max_version > ciphersuite_info->max_minor_ver )
          {
              opt.max_version = ciphersuite_info->max_minor_ver;
          }
          if( opt.min_version < ciphersuite_info->min_minor_ver )
          {
              opt.min_version = ciphersuite_info->min_minor_ver;
              /* DTLS starts with TLS 1.1 */
              if( opt.transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
                  opt.min_version < MBEDTLS_SSL_MINOR_VERSION_2 )
                  opt.min_version = MBEDTLS_SSL_MINOR_VERSION_2;
          }
  
          /* Enable RC4 if needed and not explicitly disabled */
          if( ciphersuite_info->cipher == MBEDTLS_CIPHER_ARC4_128 )
          {
              if( opt.arc4 == MBEDTLS_SSL_ARC4_DISABLED )
              {
                  mbedtls_printf("forced RC4 ciphersuite with RC4 disabled\n");
                  ret = 2;
                  goto usage;
              }
  
              opt.arc4 = MBEDTLS_SSL_ARC4_ENABLED;
          }
      }
  
  #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
      /*
       * Unhexify the pre-shared key if any is given
       */
      if( strlen( opt.psk ) )
      {
          unsigned char c;
          size_t j;
  
          if( strlen( opt.psk ) % 2 != 0 )
          {
              mbedtls_printf("pre-shared key not valid hex\n");
              goto exit;
          }
  
          psk_len = strlen( opt.psk ) / 2;
  
          for( j = 0; j < strlen( opt.psk ); j += 2 )
          {
              c = opt.psk[j];
              if( c >= '0' && c <= '9' )
                  c -= '0';
              else if( c >= 'a' && c <= 'f' )
                  c -= 'a' - 10;
              else if( c >= 'A' && c <= 'F' )
                  c -= 'A' - 10;
              else
              {
                  mbedtls_printf("pre-shared key not valid hex\n");
                  goto exit;
              }
              psk[ j / 2 ] = c << 4;
  
              c = opt.psk[j + 1];
              if( c >= '0' && c <= '9' )
                  c -= '0';
              else if( c >= 'a' && c <= 'f' )
                  c -= 'a' - 10;
              else if( c >= 'A' && c <= 'F' )
                  c -= 'A' - 10;
              else
              {
                  mbedtls_printf("pre-shared key not valid hex\n");
                  goto exit;
              }
              psk[ j / 2 ] |= c;
          }
      }
  #endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */
  
  #if defined(MBEDTLS_SSL_ALPN)
      if( opt.alpn_string != NULL )
      {
          p = (char *) opt.alpn_string;
          i = 0;
  
          /* Leave room for a final NULL in alpn_list */
          while( i < (int) sizeof alpn_list - 1 && *p != '\0' )
          {
              alpn_list[i++] = p;
  
              /* Terminate the current string and move on to next one */
              while( *p != ',' && *p != '\0' )
                  p++;
              if( *p == ',' )
                  *p++ = '\0';
          }
      }
  #endif /* MBEDTLS_SSL_ALPN */
  
      // XXX starting here!
      /*
       * 0. Initialize the RNG and the session data
       */
      LL_LOG("Seeding the random number generator..." );
  
      mbedtls_entropy_init( &entropy );
      if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,
                                 (const unsigned char *) pers,
                                 strlen( pers ) ) ) != 0 )
      {
          LL_CRITICAL(" mbedtls_ctr_drbg_seed returned -%#x", -ret);
          goto exit;
      }
  
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
      /*
       * 1.1. Load the trusted CA
       */
      LL_LOG( "Loading the CA root certificate");
  
  #if defined(MBEDTLS_FS_IO)
      if( strlen( opt.ca_path ) )
          if( strcmp( opt.ca_path, "none" ) == 0 )
              ret = 0;
          else
              ret = mbedtls_x509_crt_parse_path( &cacert, opt.ca_path );
      else if( strlen( opt.ca_file ) )
          if( strcmp( opt.ca_file, "none" ) == 0 )
              ret = 0;
          else
              ret = mbedtls_x509_crt_parse_file( &cacert, opt.ca_file );
      else
  #endif
      // load trusted crts
  #include "ca_bundle.h"
    ret = mbedtls_x509_crt_parse(&cacert,
                                 (const unsigned char *) mozilla_ca_bundle,
                                 sizeof mozilla_ca_bundle);
    if (ret < 0) {
      LL_CRITICAL("  mbedtls_x509_crt_parse returned -%#x", -ret);
      goto exit;
    }
  
    if (ret != 0) {
      LL_CRITICAL("  mbedtls_pk_parse_key returned -%#x", -ret);
      goto exit;
    }
  #endif /* MBEDTLS_X509_CRT_PARSE_C */
  
      /*
       * 2. Start the connection
       */
      if( opt.server_addr == NULL)
          opt.server_addr = opt.server_name;
  
      LL_LOG("connecting to %s:%s:%s...",
              opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM ? "TCP" : "UDP",
              opt.server_addr, opt.server_port );
  
      if( ( ret = mbedtls_net_connect_ocall( &server_fd, opt.server_addr, opt.server_port,
                               opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM ?
                               MBEDTLS_NET_PROTO_TCP : MBEDTLS_NET_PROTO_UDP ) ) != 0 )
      {
          LL_CRITICAL( " mbedtls_net_connect returned -%#x", -ret );
          goto exit;
      }
  
      if( opt.nbio > 0 )
          ret = mbedtls_net_set_nonblock_ocall( &server_fd );
      else
          ret = mbedtls_net_set_block_ocall( &server_fd );
      if( ret != 0 )
      {
          LL_CRITICAL( " net_set_(non)block() returned -%#x", -ret );
          goto exit;
      }
  
      /*
       * 3. Setup stuff
       */
      LL_LOG( "Setting up the SSL/TLS structure..." );
  
      if( ( ret = mbedtls_ssl_config_defaults( &conf,
                      MBEDTLS_SSL_IS_CLIENT,
                      opt.transport,
                      MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 )
      {
          LL_CRITICAL( "mbedtls_ssl_config_defaults returned -%#x", -ret );
          goto exit;
      }
  
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
      if( opt.debug_level > 0 )
          mbedtls_ssl_conf_verify( &conf, my_verify, NULL );
  #endif
  
      if( opt.auth_mode != DFL_AUTH_MODE )
          mbedtls_ssl_conf_authmode( &conf, opt.auth_mode );
  
  #if defined(MBEDTLS_SSL_PROTO_DTLS)
      if( opt.hs_to_min != DFL_HS_TO_MIN || opt.hs_to_max != DFL_HS_TO_MAX )
          mbedtls_ssl_conf_handshake_timeout( &conf, opt.hs_to_min, opt.hs_to_max );
  #endif /* MBEDTLS_SSL_PROTO_DTLS */
  
  #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
      if( ( ret = mbedtls_ssl_conf_max_frag_len( &conf, opt.mfl_code ) ) != 0 )
      {
          mbedtls_printf( "  mbedtls_ssl_conf_max_frag_len returned %d\n\n", ret );
          goto exit;
      }
  #endif
  
  #if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
      if( opt.trunc_hmac != DFL_TRUNC_HMAC )
          mbedtls_ssl_conf_truncated_hmac( &conf, opt.trunc_hmac );
  #endif
  
  #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
      if( opt.extended_ms != DFL_EXTENDED_MS )
          mbedtls_ssl_conf_extended_master_secret( &conf, opt.extended_ms );
  #endif
  
  #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
      if( opt.etm != DFL_ETM )
          mbedtls_ssl_conf_encrypt_then_mac( &conf, opt.etm );
  #endif
  
  #if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
      if( opt.recsplit != DFL_RECSPLIT )
          mbedtls_ssl_conf_cbc_record_splitting( &conf, opt.recsplit
                                      ? MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED
                                      : MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED );
  #endif
  
  #if defined(MBEDTLS_DHM_C)
      if( opt.dhmlen != DFL_DHMLEN )
          mbedtls_ssl_conf_dhm_min_bitlen( &conf, opt.dhmlen );
  #endif
  
  #if defined(MBEDTLS_SSL_ALPN)
      if( opt.alpn_string != NULL )
          if( ( ret = mbedtls_ssl_conf_alpn_protocols( &conf, alpn_list ) ) != 0 )
          {
              mbedtls_printf( "  mbedtls_ssl_conf_alpn_protocols returned %d\n\n", ret );
              goto exit;
          }
  #endif
  
      mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg );
      mbedtls_ssl_conf_dbg( &conf, my_debug, NULL );
  
      mbedtls_ssl_conf_read_timeout( &conf, opt.read_timeout );
  
  #if defined(MBEDTLS_SSL_SESSION_TICKETS)
      mbedtls_ssl_conf_session_tickets( &conf, opt.tickets );
  #endif
  
      if( opt.force_ciphersuite[0] != DFL_FORCE_CIPHER )
          mbedtls_ssl_conf_ciphersuites( &conf, opt.force_ciphersuite );
  
  #if defined(MBEDTLS_ARC4_C)
      if( opt.arc4 != DFL_ARC4 )
          mbedtls_ssl_conf_arc4_support( &conf, opt.arc4 );
  #endif
  
      if( opt.allow_legacy != DFL_ALLOW_LEGACY )
          mbedtls_ssl_conf_legacy_renegotiation( &conf, opt.allow_legacy );
  #if defined(MBEDTLS_SSL_RENEGOTIATION)
      mbedtls_ssl_conf_renegotiation( &conf, opt.renegotiation );
  #endif
  
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
      if( strcmp( opt.ca_path, "none" ) != 0 &&
          strcmp( opt.ca_file, "none" ) != 0 )
      {
          mbedtls_ssl_conf_ca_chain( &conf, &cacert, NULL );
      }
      if( strcmp( opt.crt_file, "none" ) != 0 &&
          strcmp( opt.key_file, "none" ) != 0 )
      {
          if( ( ret = mbedtls_ssl_conf_own_cert( &conf, &clicert, &pkey ) ) != 0 )
          {
              mbedtls_printf( "  mbedtls_ssl_conf_own_cert returned %d\n\n", ret );
              goto exit;
          }
      }
  #endif
  
  #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
      if( ( ret = mbedtls_ssl_conf_psk( &conf, psk, psk_len,
                               (const unsigned char *) opt.psk_identity,
                               strlen( opt.psk_identity ) ) ) != 0 )
      {
          mbedtls_printf( "  mbedtls_ssl_conf_psk returned %d\n\n", ret );
          goto exit;
      }
  #endif
  
      if( opt.min_version != DFL_MIN_VERSION )
          mbedtls_ssl_conf_min_version( &conf, MBEDTLS_SSL_MAJOR_VERSION_3, opt.min_version );
  
      if( opt.max_version != DFL_MAX_VERSION )
          mbedtls_ssl_conf_max_version( &conf, MBEDTLS_SSL_MAJOR_VERSION_3, opt.max_version );
  
  #if defined(MBEDTLS_SSL_FALLBACK_SCSV)
      if( opt.fallback != DFL_FALLBACK )
          mbedtls_ssl_conf_fallback( &conf, opt.fallback );
  #endif
  
      if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 )
      {
          LL_CRITICAL("mbedtls_ssl_setup returned -%#x", -ret );
          goto exit;
      }
  
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
      if( ( ret = mbedtls_ssl_set_hostname( &ssl, opt.server_name ) ) != 0 )
      {
          LL_CRITICAL("mbedtls_ssl_set_hostname returned %d\n\n", ret );
          goto exit;
      }
  #endif
  
  #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
      if( opt.ecjpake_pw != DFL_ECJPAKE_PW )
      {
          if( ( ret = mbedtls_ssl_set_hs_ecjpake_password( &ssl,
                          (const unsigned char *) opt.ecjpake_pw,
                                          strlen( opt.ecjpake_pw ) ) ) != 0 )
          {
              mbedtls_printf( "  mbedtls_ssl_set_hs_ecjpake_password returned %d\n\n", ret );
              goto exit;
          }
      }
  #endif
  
      if( opt.nbio == 2 )
          mbedtls_ssl_set_bio( &ssl, &server_fd, my_send, my_recv, NULL );
      else
          mbedtls_ssl_set_bio( &ssl, &server_fd, mbedtls_net_send_ocall, mbedtls_net_recv_ocall,
                               opt.nbio == 0 ? mbedtls_net_recv_timeout_ocall : NULL );
  
  #if defined(MBEDTLS_TIMING_C)
      mbedtls_ssl_set_timer_cb( &ssl, &timer, mbedtls_timing_set_delay,
                                              mbedtls_timing_get_delay );
  #endif
  
      /*
       * 4. Handshake
       */
      LL_LOG( "Performing the SSL/TLS handshake" );
  
      while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
      {
          if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )
          {
              LL_CRITICAL( "mbedtls_ssl_handshake returned -%#x", -ret );
              if( ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED )
                  LL_CRITICAL(
                      "Unable to verify the server's certificate. "
                      "Either it is invalid,"
                      "or you didn't set ca_file or ca_path "
                      "to an appropriate value."
                      "Alternatively, you may want to use "
                      "auth_mode=optional for testing purposes." );
              goto exit;
          }
      }
  
      LL_LOG( "Hand shake succeeds: [%s, %s]",
              mbedtls_ssl_get_version( &ssl ), mbedtls_ssl_get_ciphersuite( &ssl ) );
  
      if( ( ret = mbedtls_ssl_get_record_expansion( &ssl ) ) >= 0 )
          LL_DEBUG( "Record expansion is [%d]", ret );
      else
          LL_DEBUG( "Record expansion is [unknown (compression)]" );
  
  #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
      LL_LOG( "Maximum fragment length is [%u]",
                      (unsigned int) mbedtls_ssl_get_max_frag_len( &ssl ) );
  #endif
  
  #if defined(MBEDTLS_SSL_ALPN)
      if( opt.alpn_string != NULL )
      {
          const char *alp = mbedtls_ssl_get_alpn_protocol( &ssl );
          mbedtls_printf( "    [ Application Layer Protocol is %s ]\n",
                  alp ? alp : "(none)" );
      }
  #endif
  
      if( opt.reconnect != 0 )
      {
          LL_LOG("  . Saving session for reuse..." );
  
          if( ( ret = mbedtls_ssl_get_session( &ssl, &saved_session ) ) != 0 )
          {
              LL_CRITICAL("mbedtls_ssl_get_session returned -%#x", -ret );
              goto exit;
          }
  
          LL_LOG("ok");
      }
  
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
      /*
       * 5. Verify the server certificate
       */
      LL_LOG( "Verifying peer X.509 certificate..." );
  
      if( ( flags = mbedtls_ssl_get_verify_result( &ssl ) ) != 0 )
      {
          char vrfy_buf[512];
  
          mbedtls_printf( " failed\n" );
  
          mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), "  ! ", flags );
  
          mbedtls_printf( "%s\n", vrfy_buf );
      }
      else
          LL_LOG("X.509 Verifies");
  
      if( mbedtls_ssl_get_peer_cert( &ssl ) != NULL )
      {
          if (opt.debug_level > 0)
          {
              LL_DEBUG( "Peer certificate information");
              mbedtls_x509_crt_info( (char *) buf, sizeof( buf ) - 1, "|-", mbedtls_ssl_get_peer_cert( &ssl ) );
              mbedtls_printf("%s\n", buf);   
          }
  
      }
  #endif /* MBEDTLS_X509_CRT_PARSE_C */
  
  #if defined(MBEDTLS_SSL_RENEGOTIATION)
      if( opt.renegotiate )
      {
          /*
           * Perform renegotiation (this must be done when the server is waiting
           * for input from our side).
           */
          mbedtls_printf( "  . Performing renegotiation..." );
          while( ( ret = mbedtls_ssl_renegotiate( &ssl ) ) != 0 )
          {
              if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
                  ret != MBEDTLS_ERR_SSL_WANT_WRITE )
              {
                  mbedtls_printf( "  mbedtls_ssl_renegotiate returned %d\n\n", ret );
                  goto exit;
              }
          }
          mbedtls_printf( " ok\n" );
      }
  #endif /* MBEDTLS_SSL_RENEGOTIATION */
  
      /*
       * 6. Write the GET request
       */
      retry_left = opt.max_resend;
  
  send_request:
      len = mbedtls_snprintf( (char *) buf, sizeof(buf) - 1, GET_REQUEST,
                      opt.request_page );
  
      if (headers && n_header > 0)
      {
          for (i = 0; i < n_header; i++)
          {
              len += mbedtls_snprintf( (char*)buf + len, sizeof(buf) -1 - len, "%s\r\n", headers[i]);
          }
      }
      tail_len = (int) strlen( GET_REQUEST_END );
  
      /* Add padding to GET request to reach opt.request_size in length */
      if( opt.request_size != DFL_REQUEST_SIZE &&
          len + tail_len < opt.request_size )
      {
          memset( buf + len, 'A', opt.request_size - len - tail_len );
          len += opt.request_size - len - tail_len;
      }
  
      strncpy( (char *) buf + len, GET_REQUEST_END, sizeof(buf) - len - 1 );
      len += tail_len;
  
      /* Truncate if request size is smaller than the "natural" size */
      if( opt.request_size != DFL_REQUEST_SIZE &&
          len > opt.request_size )
      {
          len = opt.request_size;
  
          /* Still end with \r\n unless that's really not possible */
          if( len >= 2 ) buf[len - 2] = '\r';
          if( len >= 1 ) buf[len - 1] = '\n';
      }
  
      if( opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM )
      {
          for( written = 0, frags = 0; written < len; written += ret, frags++ )
          {
              while( ( ret = mbedtls_ssl_write( &ssl, buf + written, len - written ) )
                             <= 0 )
              {
                  if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
                      ret != MBEDTLS_ERR_SSL_WANT_WRITE )
                  {
                      mbedtls_printf( "  mbedtls_ssl_write returned -%#x", -ret );
                      goto exit;
                  }
              }
          }
      }
      else /* Not stream, so datagram */
      {
          do ret = mbedtls_ssl_write( &ssl, buf, len );
          while( ret == MBEDTLS_ERR_SSL_WANT_READ ||
                 ret == MBEDTLS_ERR_SSL_WANT_WRITE );
  
          if( ret < 0 )
          {
              mbedtls_printf( "  mbedtls_ssl_write returned %d\n\n", ret );
              goto exit;
          }
  
          frags = 1;
          written = ret;
      }
  
      buf[written] = '\0';
      LL_LOG("%d bytes written in %d fragments", written, frags);
      LL_LOG("%s", (char*) buf);
  
      mbedtls_debug_print_buf(&ssl, 0, __FILE__, __LINE__, "bytes written: ", buf, written);
  
      /*
       * 7. Read the HTTP response
       */
  
      /*
       * TLS and DTLS need different reading styles (stream vs datagram)
       */
      if( opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM )
      {
          do
          {
              len = length - 1;
              memset( output, 0, length);
              ret = mbedtls_ssl_read( &ssl, output, len );
  
              if( ret == MBEDTLS_ERR_SSL_WANT_READ ||
                  ret == MBEDTLS_ERR_SSL_WANT_WRITE )
                  continue;
  
              if( ret <= 0 )
              {
                  switch( ret )
                  {
                      case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
                          mbedtls_printf( " connection was closed gracefully\n" );
                          ret = 0;
                          goto close_notify;
  
                      case 0:
                      case MBEDTLS_ERR_NET_CONN_RESET:
                          mbedtls_printf( " connection was reset by peer\n" );
                          ret = 0;
                          goto reconnect;
  
                      default:
                          mbedtls_printf( " mbedtls_ssl_read returned -0x%x\n", -ret );
                          goto exit;
                  }
              }
  
              len = ret;
  
              LL_LOG( "get %d bytes ending with %x", len, output[len-1]);
            mbedtls_debug_print_buf(&ssl, 0, __FILE__, __LINE__, "response", output, len);
              // TODO: Add full-fledge HTTP parser here
              // possibly from libcurl
              if( ret > 0 && (output[len-1] == '\n' || output[len-1] == '}'))
              {
                  ret = 0;
                  output[len] = 0;
                  break;
              }
              
  
              output += len;
              length -= len;
          }
  #pragma warning (disable: 4127)
          while( 1 );
  #pragma warning (default: 4127)
      }
      else /* Not stream, so datagram */
      {
          len = sizeof( buf ) - 1;
          memset( buf, 0, sizeof( buf ) );
  
          do ret = mbedtls_ssl_read( &ssl, buf, len );
          while( ret == MBEDTLS_ERR_SSL_WANT_READ ||
                 ret == MBEDTLS_ERR_SSL_WANT_WRITE );
  
          if( ret <= 0 )
          {
              switch( ret )
              {
                  case MBEDTLS_ERR_SSL_TIMEOUT:
                      mbedtls_printf( " timeout\n" );
                      if( retry_left-- > 0 )
                          goto send_request;
                      goto exit;
  
                  case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
                      mbedtls_printf( " connection was closed gracefully\n" );
                      ret = 0;
                      goto close_notify;
  
                  default:
                      mbedtls_printf( " mbedtls_ssl_read returned -0x%x\n", -ret );
                      goto exit;
              }
          }
  
          len = ret;
          buf[len] = '\0';
          mbedtls_printf( " %d bytes read\n\n%s", len, (char *) buf );
          ret = 0;
      }
  
      /*
       * 7b. Simulate hard reset and reconnect from same port?
       */
      if( opt.reconnect_hard != 0 )
      {
          opt.reconnect_hard = 0;
  
          mbedtls_printf( "  . Restarting connection from same port..." );
  
          if( ( ret = mbedtls_ssl_session_reset( &ssl ) ) != 0 )
          {
              mbedtls_printf( "  mbedtls_ssl_session_reset returned -%#x", -ret );
              goto exit;
          }
  
          while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
          {
              if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
                  ret != MBEDTLS_ERR_SSL_WANT_WRITE )
              {
                  mbedtls_printf( "  mbedtls_ssl_handshake returned -%#x", -ret );
                  goto exit;
              }
          }
  
          mbedtls_printf( " ok\n" );
  
          goto send_request;
      }
  
      /*
       * 7c. Continue doing data exchanges?
       */
      if( --opt.exchanges > 0 )
          goto send_request;
  
      /*
       * 8. Done, cleanly close the connection
       */
  close_notify:
  
      /* No error checking, the connection might be closed already */
      do ret = mbedtls_ssl_close_notify( &ssl );
      while( ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      ret = 0;
  
      LL_LOG( "closed %s:%s", opt.server_addr, opt.server_port );
  
      /*
       * 9. Reconnect?
       */
  reconnect:
      if( opt.reconnect != 0 )
      {
          --opt.reconnect;
  
          mbedtls_net_free_ocall( &server_fd );
  
  #if defined(MBEDTLS_TIMING_C)
          if( opt.reco_delay > 0 )
              mbedtls_net_usleep( 1000000 * opt.reco_delay );
  #endif
  
          mbedtls_printf( "  . Reconnecting with saved session..." );
  
          if( ( ret = mbedtls_ssl_session_reset( &ssl ) ) != 0 )
          {
              mbedtls_printf( "  mbedtls_ssl_session_reset returned -%#x", -ret );
              goto exit;
          }
  
          if( ( ret = mbedtls_ssl_set_session( &ssl, &saved_session ) ) != 0 )
          {
              mbedtls_printf( "  mbedtls_ssl_conf_session returned %d\n\n", ret );
              goto exit;
          }
  
          if( ( ret = mbedtls_net_connect_ocall( &server_fd, opt.server_addr, opt.server_port,
                                   opt.transport == MBEDTLS_SSL_TRANSPORT_STREAM ?
                                   MBEDTLS_NET_PROTO_TCP : MBEDTLS_NET_PROTO_UDP ) ) != 0 )
          {
              mbedtls_printf( "  mbedtls_net_connect returned -%#x", -ret );
              goto exit;
          }
  
          if( opt.nbio > 0 )
              ret = mbedtls_net_set_nonblock_ocall( &server_fd );
          else
              ret = mbedtls_net_set_block_ocall( &server_fd );
          if( ret != 0 )
          {
              mbedtls_printf( "  net_set_(non)block() returned -%#x",
                      -ret );
              goto exit;
          }
  
          while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
          {
              if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
                  ret != MBEDTLS_ERR_SSL_WANT_WRITE )
              {
                  mbedtls_printf( "  mbedtls_ssl_handshake returned -%#x", -ret );
                  goto exit;
              }
          }
  
          mbedtls_printf( " ok\n" );
  
          goto send_request;
      }
  
      /*
       * Cleanup and exit
       */
  exit:
  #ifdef MBEDTLS_ERROR_C
      if( ret != 0 )
      {
          char error_buf[100];
          mbedtls_strerror( ret, error_buf, 100 );
          LL_CRITICAL("Last error was: -0x%X - %s\n\n", -ret, error_buf );
      }
  #endif
  
      mbedtls_net_free_ocall( &server_fd );
  
  #if defined(MBEDTLS_X509_CRT_PARSE_C)
      mbedtls_x509_crt_free( &clicert );
      mbedtls_x509_crt_free( &cacert );
      mbedtls_pk_free( &pkey );
  #endif
      mbedtls_ssl_session_free( &saved_session );
      mbedtls_ssl_free( &ssl );
      mbedtls_ssl_config_free( &conf );
      mbedtls_ctr_drbg_free( &ctr_drbg );
      mbedtls_entropy_free( &entropy );
  
      // Shell can not handle large exit numbers -> 1 for errors
  
      return( ret );
  
  usage:
      if( ret == 0 )
          ret = 1;
  
      mbedtls_printf( USAGE );
  
      list = mbedtls_ssl_list_ciphersuites();
      while( *list )
      {
          mbedtls_printf(" %-42s", mbedtls_ssl_get_ciphersuite_name( *list ) );
          list++;
          if( !*list )
              break;
          mbedtls_printf(" %s\n", mbedtls_ssl_get_ciphersuite_name( *list ) );
          list++;
      }
      mbedtls_printf("\n");
      goto exit;
  }
  #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_ENTROPY_C && MBEDTLS_SSL_TLS_C &&
            MBEDTLS_SSL_CLI_C && MBEDTLS_NET_C && MBEDTLS_RSA_C &&
            MBEDTLS_CTR_DRBG_C MBEDTLS_TIMING_C */
  