luna - wolfssl/IDE/STM32Cube/wolfssl

   1/* wolfssl_example.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#include "wolfssl_example.h"
  23
  24/* force certificate test buffers to be included via headers */
  25#undef  USE_CERT_BUFFERS_2048
  26#define USE_CERT_BUFFERS_2048
  27#undef  USE_CERT_BUFFERS_256
  28#define USE_CERT_BUFFERS_256
  29#include <wolfssl/certs_test.h>
  30
  31#include <wolfssl/wolfcrypt/hash.h> /* WC_MAX_DIGEST_SIZE */
  32
  33#ifndef SINGLE_THREADED
  34    #include <cmsis_os.h>
  35
  36    #ifdef WOLFSSL_DEBUG_MEMORY
  37        /* for memory debugging */
  38        #include <task.h>
  39    #endif
  40#endif
  41
  42#include <stdio.h>
  43#include <string.h>
  44
  45/*****************************************************************************
  46 * Configuration
  47 ****************************************************************************/
  48
  49
  50#if (!defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER)) && \
  51    !defined(WOLFCRYPT_ONLY) && !defined(SINGLE_THREADED)
  52    #define ENABLE_TLS_BENCH
  53#endif
  54
  55#if !defined(WOLFCRYPT_ONLY) && defined(WOLFSSL_TLS13) && !defined(NO_TLS_UART_TEST)
  56    #define ENABLE_TLS_UART
  57#endif
  58
  59/* Defaults for configuration parameters */
  60#define BENCH_DEFAULT_HOST   "localhost"
  61#define BENCH_DEFAULT_PORT   11112
  62#define BENCH_RUNTIME_SEC    20
  63#define BENCH_SHOW_PEER_INFO 1
  64#define TEST_PACKET_SIZE     (2 * 1024)  /* TLS packet size */
  65#ifdef BENCH_EMBEDDED
  66#define TEST_MAX_SIZE        (4 * 1024)
  67#else
  68#define TEST_MAX_SIZE        (32 * 1024) /* Total bytes to benchmark */
  69#endif
  70/* Must be large enough to handle max packet size - TLS header MAX_MSG_EXTRA + MAX DIGEST */
  71#define MEM_BUFFER_SZ        (TEST_PACKET_SIZE + 38 + WC_MAX_DIGEST_SIZE)
  72/* make sure memory buffer size is large enough */
  73#if MEM_BUFFER_SZ < 2048
  74    #undef  MEM_BUFFER_SZ
  75    #define MEM_BUFFER_SZ 2048
  76#endif
  77#define SHOW_VERBOSE         0 /* 0=tab del (minimal), 1=info, 2=debug, 3=debug w/wolf logs */
  78#ifndef WOLFSSL_CIPHER_LIST_MAX_SIZE
  79#define WOLFSSL_CIPHER_LIST_MAX_SIZE 2048
  80#endif
  81#if 0
  82    /* define this to test only a specific cipher suite(s) (colon separated) */
  83    #define TEST_CIPHER_SUITE "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256"
  84#endif
  85#if 0
  86    /* use non-blocking mode for read/write IO */
  87    #define BENCH_USE_NONBLOCK
  88#endif
  89#ifndef RECV_WAIT_TIMEOUT
  90    #define RECV_WAIT_TIMEOUT 10000
  91#endif
  92
  93/*****************************************************************************
  94 * Private types/enumerations/variables
  95 ****************************************************************************/
  96
  97#ifdef WOLFSSL_STATIC_MEMORY
  98    #if 1 /* on-chip RAM */
  99        #define RAM_STATIC
 100    #else /* external RAM */
 101        /* requires .ld to be updated with ".extram" section */
 102        #define RAM_STATIC __attribute__ ((section (".extram")))
 103    #endif
 104    #define WOLF_GEN_MEM         (20*1024)
 105    #define WOLF_TLS_GEN_MEM     (90*1024)
 106    #define WOLF_TLS_IO_POOL_MEM (35*1024)
 107
 108    RAM_STATIC static byte gWolfMem[WOLF_GEN_MEM];
 109    RAM_STATIC static byte gWolfCTXCli[WOLF_TLS_GEN_MEM];
 110    RAM_STATIC static byte gWolfIOCli[WOLF_TLS_IO_POOL_MEM];
 111    RAM_STATIC static byte gWolfCTXSrv[WOLF_TLS_GEN_MEM];
 112    RAM_STATIC static byte gWolfIOSrv[WOLF_TLS_IO_POOL_MEM];
 113
 114    WOLFSSL_HEAP_HINT* HEAP_HINT = NULL;
 115#endif /* WOLFSSL_STATIC_MEMORY */
 116
 117
 118/* This sets which UART to use for the console.  It is something you will have
 119 * to configure in STMCubeIDE and then change here. */
 120#ifndef HAL_CONSOLE_UART
 121#define HAL_CONSOLE_UART huart4
 122#endif
 123extern UART_HandleTypeDef HAL_CONSOLE_UART;
 124
 125/*****************************************************************************
 126 * Public types/enumerations/variables
 127 ****************************************************************************/
 128typedef struct func_args {
 129    int argc;
 130    char** argv;
 131    int return_code;
 132} func_args;
 133
 134const char menu1[] = "\n"
 135        "\tt. wolfCrypt Test\n"
 136        "\tb. wolfCrypt Benchmark\n"
 137    #ifdef ENABLE_TLS_BENCH
 138        "\tl. wolfSSL TLS Bench\n"
 139    #endif
 140        "\te. Show Cipher List\n"
 141    #ifdef ENABLE_TLS_UART
 142        "\ts. Run TLS 1.3 Server over UART\n"
 143        "\tc. Run TLS 1.3 Client over UART\n"
 144    #endif
 145    ;
 146
 147static void PrintMemStats(void);
 148double current_time(void);
 149
 150
 151#ifdef ENABLE_TLS_BENCH
 152
 153static const char* kShutdown = "shutdown";
 154
 155static const char* kTestStr =
 156"Biodiesel cupidatat marfa, cliche aute put a bird on it incididunt elit\n"
 157"polaroid. Sunt tattooed bespoke reprehenderit. Sint twee organic id\n"
 158"marfa. Commodo veniam ad esse gastropub. 3 wolf moon sartorial vero,\n"
 159"plaid delectus biodiesel squid +1 vice. Post-ironic keffiyeh leggings\n"
 160"selfies cray fap hoodie, forage anim. Carles cupidatat shoreditch, VHS\n"
 161"small batch meggings kogi dolore food truck bespoke gastropub.\n"
 162"\n"
 163"Terry richardson adipisicing actually typewriter tumblr, twee whatever\n"
 164"four loko you probably haven't heard of them high life. Messenger bag\n"
 165"whatever tattooed deep v mlkshk. Brooklyn pinterest assumenda chillwave\n"
 166"et, banksy ullamco messenger bag umami pariatur direct trade forage.\n"
 167"Typewriter culpa try-hard, pariatur sint brooklyn meggings. Gentrify\n"
 168"food truck next level, tousled irony non semiotics PBR ethical anim cred\n"
 169"readymade. Mumblecore brunch lomo odd future, portland organic terry\n"
 170"richardson elit leggings adipisicing ennui raw denim banjo hella. Godard\n"
 171"mixtape polaroid, pork belly readymade organic cray typewriter helvetica\n"
 172"four loko whatever street art yr farm-to-table.\n"
 173"\n"
 174"Vinyl keytar vice tofu. Locavore you probably haven't heard of them pug\n"
 175"pickled, hella tonx labore truffaut DIY mlkshk elit cosby sweater sint\n"
 176"et mumblecore. Elit swag semiotics, reprehenderit DIY sartorial nisi ugh\n"
 177"nesciunt pug pork belly wayfarers selfies delectus. Ethical hoodie\n"
 178"seitan fingerstache kale chips. Terry richardson artisan williamsburg,\n"
 179"eiusmod fanny pack irony tonx ennui lo-fi incididunt tofu YOLO\n"
 180"readymade. 8-bit sed ethnic beard officia. Pour-over iphone DIY butcher,\n"
 181"ethnic art party qui letterpress nisi proident jean shorts mlkshk\n"
 182"locavore.\n"
 183"\n"
 184"Narwhal flexitarian letterpress, do gluten-free voluptate next level\n"
 185"banh mi tonx incididunt carles DIY. Odd future nulla 8-bit beard ut\n"
 186"cillum pickled velit, YOLO officia you probably haven't heard of them\n"
 187"trust fund gastropub. Nisi adipisicing tattooed, Austin mlkshk 90's\n"
 188"small batch american apparel. Put a bird on it cosby sweater before they\n"
 189"sold out pork belly kogi hella. Street art mollit sustainable polaroid,\n"
 190"DIY ethnic ea pug beard dreamcatcher cosby sweater magna scenester nisi.\n"
 191"Sed pork belly skateboard mollit, labore proident eiusmod. Sriracha\n"
 192"excepteur cosby sweater, anim deserunt laborum eu aliquip ethical et\n"
 193"neutra PBR selvage.\n"
 194"\n"
 195"Raw denim pork belly truffaut, irony plaid sustainable put a bird on it\n"
 196"next level jean shorts exercitation. Hashtag keytar whatever, nihil\n"
 197"authentic aliquip disrupt laborum. Tattooed selfies deserunt trust fund\n"
 198"wayfarers. 3 wolf moon synth church-key sartorial, gastropub leggings\n"
 199"tattooed. Labore high life commodo, meggings raw denim fingerstache pug\n"
 200"trust fund leggings seitan forage. Nostrud ullamco duis, reprehenderit\n"
 201"incididunt flannel sustainable helvetica pork belly pug banksy you\n"
 202"probably haven't heard of them nesciunt farm-to-table. Disrupt nostrud\n"
 203"mollit magna, sriracha sartorial helvetica.\n"
 204"\n"
 205"Nulla kogi reprehenderit, skateboard sustainable duis adipisicing viral\n"
 206"ad fanny pack salvia. Fanny pack trust fund you probably haven't heard\n"
 207"of them YOLO vice nihil. Keffiyeh cray lo-fi pinterest cardigan aliqua,\n"
 208"reprehenderit aute. Culpa tousled williamsburg, marfa lomo actually anim\n"
 209"skateboard. Iphone aliqua ugh, semiotics pariatur vero readymade\n"
 210"organic. Marfa squid nulla, in laborum disrupt laboris irure gastropub.\n"
 211"Veniam sunt food truck leggings, sint vinyl fap.\n"
 212"\n"
 213"Hella dolore pork belly, truffaut carles you probably haven't heard of\n"
 214"them PBR helvetica in sapiente. Fashion axe ugh bushwick american\n"
 215"apparel. Fingerstache sed iphone, jean shorts blue bottle nisi bushwick\n"
 216"flexitarian officia veniam plaid bespoke fap YOLO lo-fi. Blog\n"
 217"letterpress mumblecore, food truck id cray brooklyn cillum ad sed.\n"
 218"Assumenda chambray wayfarers vinyl mixtape sustainable. VHS vinyl\n"
 219"delectus, culpa williamsburg polaroid cliche swag church-key synth kogi\n"
 220"magna pop-up literally. Swag thundercats ennui shoreditch vegan\n"
 221"pitchfork neutra truffaut etsy, sed single-origin coffee craft beer.\n"
 222"\n"
 223"Odio letterpress brooklyn elit. Nulla single-origin coffee in occaecat\n"
 224"meggings. Irony meggings 8-bit, chillwave lo-fi adipisicing cred\n"
 225"dreamcatcher veniam. Put a bird on it irony umami, trust fund bushwick\n"
 226"locavore kale chips. Sriracha swag thundercats, chillwave disrupt\n"
 227"tousled beard mollit mustache leggings portland next level. Nihil esse\n"
 228"est, skateboard art party etsy thundercats sed dreamcatcher ut iphone\n"
 229"swag consectetur et. Irure skateboard banjo, nulla deserunt messenger\n"
 230"bag dolor terry richardson sapiente.\n";
 231
 232#if !defined(NO_DH)
 233#define MIN_DHKEY_BITS      1024
 234
 235/* dh2048 p */
 236static const unsigned char p[] =
 237{
 238    0xb0, 0xa1, 0x08, 0x06, 0x9c, 0x08, 0x13, 0xba, 0x59, 0x06, 0x3c, 0xbc, 0x30,
 239    0xd5, 0xf5, 0x00, 0xc1, 0x4f, 0x44, 0xa7, 0xd6, 0xef, 0x4a, 0xc6, 0x25, 0x27,
 240    0x1c, 0xe8, 0xd2, 0x96, 0x53, 0x0a, 0x5c, 0x91, 0xdd, 0xa2, 0xc2, 0x94, 0x84,
 241    0xbf, 0x7d, 0xb2, 0x44, 0x9f, 0x9b, 0xd2, 0xc1, 0x8a, 0xc5, 0xbe, 0x72, 0x5c,
 242    0xa7, 0xe7, 0x91, 0xe6, 0xd4, 0x9f, 0x73, 0x07, 0x85, 0x5b, 0x66, 0x48, 0xc7,
 243    0x70, 0xfa, 0xb4, 0xee, 0x02, 0xc9, 0x3d, 0x9a, 0x4a, 0xda, 0x3d, 0xc1, 0x46,
 244    0x3e, 0x19, 0x69, 0xd1, 0x17, 0x46, 0x07, 0xa3, 0x4d, 0x9f, 0x2b, 0x96, 0x17,
 245    0x39, 0x6d, 0x30, 0x8d, 0x2a, 0xf3, 0x94, 0xd3, 0x75, 0xcf, 0xa0, 0x75, 0xe6,
 246    0xf2, 0x92, 0x1f, 0x1a, 0x70, 0x05, 0xaa, 0x04, 0x83, 0x57, 0x30, 0xfb, 0xda,
 247    0x76, 0x93, 0x38, 0x50, 0xe8, 0x27, 0xfd, 0x63, 0xee, 0x3c, 0xe5, 0xb7, 0xc8,
 248    0x09, 0xae, 0x6f, 0x50, 0x35, 0x8e, 0x84, 0xce, 0x4a, 0x00, 0xe9, 0x12, 0x7e,
 249    0x5a, 0x31, 0xd7, 0x33, 0xfc, 0x21, 0x13, 0x76, 0xcc, 0x16, 0x30, 0xdb, 0x0c,
 250    0xfc, 0xc5, 0x62, 0xa7, 0x35, 0xb8, 0xef, 0xb7, 0xb0, 0xac, 0xc0, 0x36, 0xf6,
 251    0xd9, 0xc9, 0x46, 0x48, 0xf9, 0x40, 0x90, 0x00, 0x2b, 0x1b, 0xaa, 0x6c, 0xe3,
 252    0x1a, 0xc3, 0x0b, 0x03, 0x9e, 0x1b, 0xc2, 0x46, 0xe4, 0x48, 0x4e, 0x22, 0x73,
 253    0x6f, 0xc3, 0x5f, 0xd4, 0x9a, 0xd6, 0x30, 0x07, 0x48, 0xd6, 0x8c, 0x90, 0xab,
 254    0xd4, 0xf6, 0xf1, 0xe3, 0x48, 0xd3, 0x58, 0x4b, 0xa6, 0xb9, 0xcd, 0x29, 0xbf,
 255    0x68, 0x1f, 0x08, 0x4b, 0x63, 0x86, 0x2f, 0x5c, 0x6b, 0xd6, 0xb6, 0x06, 0x65,
 256    0xf7, 0xa6, 0xdc, 0x00, 0x67, 0x6b, 0xbb, 0xc3, 0xa9, 0x41, 0x83, 0xfb, 0xc7,
 257    0xfa, 0xc8, 0xe2, 0x1e, 0x7e, 0xaf, 0x00, 0x3f, 0x93
 258};
 259
 260/* dh2048 g */
 261static const unsigned char g[] =
 262{
 263    0x02,
 264};
 265#endif /* !NO_DH */
 266
 267typedef struct {
 268    unsigned char buf[MEM_BUFFER_SZ];
 269    int write_bytes;
 270    int write_idx;
 271    int read_bytes;
 272    int read_idx;
 273} memBuf_t;
 274
 275typedef struct {
 276    double connTime;
 277    double rxTime;
 278    double txTime;
 279    int connCount;
 280    int rxTotal;
 281    int txTotal;
 282} stats_t;
 283
 284typedef struct {
 285    int ret;
 286
 287    osThreadId_t threadId;
 288#ifdef CMSIS_OS2_H_
 289    osSemaphoreId_t mutex;
 290#else
 291    osThreadDef_t threadDef;
 292    osSemaphoreDef_t mutexDef;
 293    osSemaphoreId mutex;
 294#endif
 295
 296    byte shutdown:1;
 297    byte done:1;
 298} side_t;
 299
 300typedef struct {
 301    const char* cipher;
 302    const char* host;
 303    word32 port;
 304    int packetSize; /* The data payload size in the packet */
 305    int maxSize;
 306    int runTimeSec;
 307    int showPeerInfo;
 308    int showVerbose;
 309    int doShutdown;
 310
 311    side_t client;
 312    side_t server;
 313
 314    /* client messages to server in memory */
 315    memBuf_t to_server;
 316
 317    /* server messages to client in memory */
 318    memBuf_t to_client;
 319
 320    /* server */
 321    stats_t server_stats;
 322
 323    /* client */
 324    stats_t client_stats;
 325} info_t;
 326
 327
 328/*****************************************************************************
 329 * Private functions
 330 ****************************************************************************/
 331static double gettime_secs(int reset)
 332{
 333    return current_time();
 334}
 335
 336static void PrintTlsStats(stats_t* wcStat, const char* desc, const char* cipher, int verbose)
 337{
 338    const char* formatStr;
 339
 340    if (verbose) {
 341        formatStr = "wolfSSL %s Benchmark on %s:\n"
 342               "\tTotal       : %9d bytes\n"
 343               "\tNum Conns   : %9d\n"
 344               "\tRx Total    : %9.3f ms\n"
 345               "\tTx Total    : %9.3f ms\n"
 346               "\tRx          : %9.3f MB/s\n"
 347               "\tTx          : %9.3f MB/s\n"
 348               "\tConnect     : %9.3f ms\n"
 349               "\tConnect Avg : %9.3f ms\n";
 350    }
 351    else {
 352        formatStr = "%-6s  %-33s  %11d  %9d  %9.3f  %9.3f  %9.3f  %9.3f  %17.3f  %15.3f\n";
 353    }
 354
 355    printf(formatStr,
 356           desc,
 357           cipher,
 358           wcStat->txTotal + wcStat->rxTotal,
 359           wcStat->connCount,
 360           wcStat->rxTime * 1000,
 361           wcStat->txTime * 1000,
 362           wcStat->rxTotal / wcStat->rxTime / 1024 / 1024,
 363           wcStat->txTotal / wcStat->txTime / 1024 / 1024,
 364           wcStat->connTime * 1000,
 365           wcStat->connTime * 1000 / wcStat->connCount);
 366}
 367#endif /* ENABLE_TLS_BENCH */
 368
 369
 370#if defined(ENABLE_TLS_BENCH) || defined(ENABLE_TLS_UART)
 371#if defined(KEEP_PEER_CERT) || defined(KEEP_OUR_CERT)
 372static const char* client_showx509_msg[] = {
 373    "issuer",
 374    "subject",
 375    "altname",
 376    "serial number",
 377    NULL
 378};
 379
 380static void ShowX509(WOLFSSL_X509* x509, const char* hdr)
 381{
 382    char* altName;
 383    char* issuer;
 384    char* subject;
 385    byte  serial[32];
 386    int   ret;
 387    int   sz = sizeof(serial);
 388    const char** words = client_showx509_msg;
 389
 390    if (x509 == NULL) {
 391        printf("%s No Cert\n", hdr);
 392        return;
 393    }
 394
 395    issuer  = wolfSSL_X509_NAME_oneline(
 396                                      wolfSSL_X509_get_issuer_name(x509), 0, 0);
 397    subject = wolfSSL_X509_NAME_oneline(
 398                                     wolfSSL_X509_get_subject_name(x509), 0, 0);
 399
 400    printf("%s\n %s : %s\n %s: %s\n", hdr, words[0], issuer, words[1], subject);
 401
 402    while ( (altName = wolfSSL_X509_get_next_altname(x509)) != NULL)
 403        printf(" %s = %s\n", words[2], altName);
 404
 405    ret = wolfSSL_X509_get_serial_number(x509, serial, &sz);
 406    if (ret == WOLFSSL_SUCCESS) {
 407        int  i;
 408        int  strLen;
 409        char serialMsg[80];
 410
 411        /* testsuite has multiple threads writing to stdout, get output
 412           message ready to write once */
 413        strLen = sprintf(serialMsg, " %s", words[3]);
 414        for (i = 0; i < sz; i++)
 415            sprintf(serialMsg + strLen + (i*3), ":%02x ", serial[i]);
 416        printf("%s\n", serialMsg);
 417    }
 418
 419    XFREE(subject, 0, DYNAMIC_TYPE_OPENSSL);
 420    XFREE(issuer,  0, DYNAMIC_TYPE_OPENSSL);
 421
 422#if defined(OPENSSL_EXTRA)
 423    {
 424        WOLFSSL_BIO* bio;
 425        char buf[256]; /* should be size of ASN_NAME_MAX */
 426        int  textSz;
 427
 428        /* print out domain component if certificate has it */
 429        textSz = wolfSSL_X509_NAME_get_text_by_NID(
 430                wolfSSL_X509_get_subject_name(x509), NID_domainComponent,
 431                buf, sizeof(buf));
 432        if (textSz > 0) {
 433            printf("Domain Component = %s\n", buf);
 434        }
 435
 436        bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file());
 437        if (bio != NULL) {
 438            wolfSSL_BIO_set_fp(bio, stdout, BIO_NOCLOSE);
 439            wolfSSL_X509_print(bio, x509);
 440            wolfSSL_BIO_free(bio);
 441        }
 442    }
 443#endif /* OPENSSL_EXTRA */
 444}
 445#endif /* KEEP_PEER_CERT || KEEP_OUR_CERT */
 446
 447
 448static const char* client_showpeer_msg[] = {
 449    "SSL version is",
 450    "SSL cipher suite is",
 451    "SSL curve name is",
 452    "SSL DH size is",
 453    "SSL reused session",
 454    "Alternate cert chain used",
 455    "peer's cert info:",
 456    NULL
 457};
 458
 459static void ShowPeer(WOLFSSL* ssl)
 460{
 461    WOLFSSL_CIPHER* cipher;
 462    const char** words = client_showpeer_msg;
 463#if defined(HAVE_ECC) || !defined(NO_DH)
 464    const char *name;
 465#endif
 466#ifndef NO_DH
 467    int bits;
 468#endif
 469#ifdef KEEP_PEER_CERT
 470    WOLFSSL_X509* peer = wolfSSL_get_peer_certificate(ssl);
 471    if (peer)
 472        ShowX509(peer, words[6]);
 473    else
 474        printf("peer has no cert!\n");
 475    wolfSSL_FreeX509(peer);
 476#endif
 477#if defined(KEEP_OUR_CERT) && \
 478    (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL))
 479    ShowX509(wolfSSL_get_certificate(ssl), "our cert info:");
 480    printf("Peer verify result = %lu\n", wolfSSL_get_verify_result(ssl));
 481#endif /* SHOW_CERTS && KEEP_OUR_CERT */
 482    printf("%s %s\n", words[0], wolfSSL_get_version(ssl));
 483
 484    cipher = wolfSSL_get_current_cipher(ssl);
 485    printf("%s %s\n", words[1], wolfSSL_CIPHER_get_name(cipher));
 486#if defined(HAVE_ECC) || !defined(NO_DH)
 487    if ((name = wolfSSL_get_curve_name(ssl)) != NULL)
 488        printf("%s %s\n", words[2], name);
 489#endif
 490#ifndef NO_DH
 491    else if ((bits = wolfSSL_GetDhKey_Sz(ssl)) > 0)
 492        printf("%s %d bits\n", words[3], bits);
 493#endif
 494    if (wolfSSL_session_reused(ssl))
 495        printf("%s\n", words[4]);
 496#ifdef WOLFSSL_ALT_CERT_CHAINS
 497    if (wolfSSL_is_peer_alt_cert_chain(ssl))
 498        printf("%s\n", words[5]);
 499#endif
 500
 501  (void)ssl;
 502}
 503#endif /* ENABLE_TLS_BENCH || ENABLE_TLS_UART */
 504
 505#ifdef ENABLE_TLS_BENCH
 506
 507/* server send callback */
 508static int ServerMemSend(info_t* info, char* buf, int sz)
 509{
 510#ifdef CMSIS_OS2_H_
 511    osSemaphoreAcquire(info->client.mutex, osWaitForever);
 512#else
 513    osSemaphoreWait(info->client.mutex, osWaitForever);
 514#endif
 515
 516#ifndef BENCH_USE_NONBLOCK
 517    /* check for overflow */
 518    if (info->to_client.write_idx + sz > MEM_BUFFER_SZ) {
 519        osSemaphoreRelease(info->client.mutex);
 520        printf("ServerMemSend overflow\n");
 521        return -1;
 522    }
 523#else
 524    if (info->to_client.write_idx + sz > MEM_BUFFER_SZ)
 525        sz = MEM_BUFFER_SZ - info->to_client.write_idx;
 526#endif
 527
 528    if (info->showVerbose >= 2)
 529        printf("Server Send: %d\n", sz);
 530    XMEMCPY(&info->to_client.buf[info->to_client.write_idx], buf, sz);
 531    info->to_client.write_idx += sz;
 532    info->to_client.write_bytes += sz;
 533
 534#ifdef CMSIS_OS2_H_
 535    osThreadFlagsSet(info->client.threadId, 1);
 536#else
 537    osSignalSet(info->client.threadId, 1);
 538#endif
 539    osSemaphoreRelease(info->client.mutex);
 540
 541#ifdef BENCH_USE_NONBLOCK
 542    if (sz == 0)
 543        return WOLFSSL_CBIO_ERR_WANT_WRITE;
 544#endif
 545    return sz;
 546}
 547
 548/* server recv callback */
 549static int ServerMemRecv(info_t* info, char* buf, int sz)
 550{
 551#ifdef CMSIS_OS2_H_
 552    osSemaphoreAcquire(info->server.mutex, osWaitForever);
 553#else
 554    osSemaphoreWait(info->server.mutex, osWaitForever);
 555#endif
 556
 557#ifndef BENCH_USE_NONBLOCK
 558    while (info->to_server.write_idx - info->to_server.read_idx < sz &&
 559            !info->client.done) {
 560        osSemaphoreRelease(info->server.mutex);
 561#ifdef CMSIS_OS2_H_
 562        if (osThreadFlagsWait(1, osFlagsWaitAny, RECV_WAIT_TIMEOUT) == osFlagsErrorTimeout) {
 563            printf("Server Recv: Timeout!\n");
 564            return WOLFSSL_CBIO_ERR_TIMEOUT;
 565        }
 566        osSemaphoreAcquire(info->server.mutex, osWaitForever);
 567#else
 568        if (osSignalWait(1, RECV_WAIT_TIMEOUT).status == osEventTimeout) {
 569            printf("Server Recv: Timeout!\n");
 570            return WOLFSSL_CBIO_ERR_TIMEOUT;
 571        }
 572        osSemaphoreWait(info->server.mutex, osWaitForever);
 573#endif
 574    }
 575#else
 576    if (info->to_server.write_idx - info->to_server.read_idx < sz)
 577        sz = info->to_server.write_idx - info->to_server.read_idx;
 578#endif
 579
 580    XMEMCPY(buf, &info->to_server.buf[info->to_server.read_idx], sz);
 581    info->to_server.read_idx += sz;
 582    info->to_server.read_bytes += sz;
 583
 584    /* if the rx has caught up with pending then reset buffer positions */
 585    if (info->to_server.read_bytes == info->to_server.write_bytes) {
 586        info->to_server.read_bytes = info->to_server.read_idx = 0;
 587        info->to_server.write_bytes = info->to_server.write_idx = 0;
 588    }
 589    if (info->showVerbose >= 2)
 590        printf("Server Recv: %d\n", sz);
 591
 592    osSemaphoreRelease(info->server.mutex);
 593
 594
 595#ifdef BENCH_USE_NONBLOCK
 596    if (sz == 0)
 597        return WOLFSSL_CBIO_ERR_WANT_READ;
 598#endif
 599    return sz;
 600}
 601
 602/* client send callback */
 603static int ClientMemSend(info_t* info, char* buf, int sz)
 604{
 605#ifdef CMSIS_OS2_H_
 606    osSemaphoreAcquire(info->server.mutex, osWaitForever);
 607#else
 608    osSemaphoreWait(info->server.mutex, osWaitForever);
 609#endif
 610
 611#ifndef BENCH_USE_NONBLOCK
 612    /* check for overflow */
 613    if (info->to_server.write_idx + sz > MEM_BUFFER_SZ) {
 614        printf("ClientMemSend overflow %d %d %d\n",
 615            info->to_server.write_idx, sz, MEM_BUFFER_SZ);
 616        osSemaphoreRelease(info->server.mutex);
 617        return -1;
 618    }
 619#else
 620    if (info->to_server.write_idx + sz > MEM_BUFFER_SZ)
 621        sz = MEM_BUFFER_SZ - info->to_server.write_idx;
 622#endif
 623
 624    if (info->showVerbose >= 2)
 625        printf("Client Send: %d\n", sz);
 626    XMEMCPY(&info->to_server.buf[info->to_server.write_idx], buf, sz);
 627    info->to_server.write_idx += sz;
 628    info->to_server.write_bytes += sz;
 629
 630#ifdef CMSIS_OS2_H_
 631    osThreadFlagsSet(info->server.threadId, 1);
 632#else
 633    osSignalSet(info->server.threadId, 1);
 634#endif
 635    osSemaphoreRelease(info->server.mutex);
 636
 637#ifdef BENCH_USE_NONBLOCK
 638    if (sz == 0)
 639        return WOLFSSL_CBIO_ERR_WANT_WRITE;
 640#endif
 641    return sz;
 642}
 643
 644/* client recv callback */
 645static int ClientMemRecv(info_t* info, char* buf, int sz)
 646{
 647#ifdef CMSIS_OS2_H_
 648    osSemaphoreAcquire(info->client.mutex, osWaitForever);
 649#else
 650    osSemaphoreWait(info->client.mutex, osWaitForever);
 651#endif
 652
 653#ifndef BENCH_USE_NONBLOCK
 654    while (info->to_client.write_idx - info->to_client.read_idx < sz &&
 655            !info->server.done) {
 656        osSemaphoreRelease(info->client.mutex);
 657#ifdef CMSIS_OS2_H_
 658        if (osThreadFlagsWait(1, osFlagsWaitAny, RECV_WAIT_TIMEOUT) == osFlagsErrorTimeout) {
 659            printf("Client Recv: Timeout!\n");
 660            return WOLFSSL_CBIO_ERR_TIMEOUT;
 661        }
 662        osSemaphoreAcquire(info->client.mutex, osWaitForever);
 663#else
 664        if (osSignalWait(1, RECV_WAIT_TIMEOUT).status == osEventTimeout) {
 665            printf("Client Recv: Timeout!\n");
 666            return WOLFSSL_CBIO_ERR_TIMEOUT;
 667        }
 668        osSemaphoreWait(info->client.mutex, osWaitForever);
 669#endif
 670    }
 671#else
 672    if (info->to_client.write_idx - info->to_client.read_idx < sz)
 673        sz = info->to_client.write_idx - info->to_client.read_idx;
 674#endif
 675
 676    XMEMCPY(buf, &info->to_client.buf[info->to_client.read_idx], sz);
 677    info->to_client.read_idx += sz;
 678    info->to_client.read_bytes += sz;
 679
 680    /* if the rx has caught up with pending then reset buffer positions */
 681    if (info->to_client.read_bytes == info->to_client.write_bytes) {
 682        info->to_client.read_bytes = info->to_client.read_idx = 0;
 683        info->to_client.write_bytes = info->to_client.write_idx = 0;
 684    }
 685    if (info->showVerbose >= 2)
 686        printf("Client Recv: %d\n", sz);
 687
 688    osSemaphoreRelease(info->client.mutex);
 689
 690#ifdef BENCH_USE_NONBLOCK
 691    if (sz == 0)
 692        return WOLFSSL_CBIO_ERR_WANT_READ;
 693#endif
 694    return sz;
 695}
 696
 697static int ServerSend(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 698{
 699    info_t* info = (info_t*)ctx;
 700    (void)ssl;
 701
 702    return ServerMemSend(info, buf, sz);
 703}
 704static int ServerRecv(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 705{
 706    info_t* info = (info_t*)ctx;
 707    (void)ssl;
 708    return ServerMemRecv(info, buf, sz);
 709}
 710
 711static int ClientSend(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 712{
 713    info_t* info = (info_t*)ctx;
 714    (void)ssl;
 715    return ClientMemSend(info, buf, sz);
 716}
 717static int ClientRecv(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 718{
 719    info_t* info = (info_t*)ctx;
 720    (void)ssl;
 721    return ClientMemRecv(info, buf, sz);
 722}
 723
 724
 725static int bench_tls_client(info_t* info)
 726{
 727    byte *writeBuf = NULL, *readBuf = NULL;
 728    double start, total = 0;
 729    int ret = 0, readBufSz;
 730    WOLFSSL_CTX* cli_ctx = NULL;
 731    WOLFSSL* cli_ssl = NULL;
 732    int haveShownPeerInfo = 0;
 733    int tls13 = XSTRNCMP(info->cipher, "TLS13", 5) == 0;
 734    int total_sz;
 735
 736    total = gettime_secs(0);
 737
 738    /* set up client */
 739#ifdef WOLFSSL_TLS13
 740    if (tls13) {
 741    #ifdef WOLFSSL_STATIC_MEMORY
 742        ret = wolfSSL_CTX_load_static_memory(&cli_ctx, wolfTLSv1_3_client_method_ex,
 743            gWolfCTXCli, sizeof(gWolfCTXCli), WOLFMEM_GENERAL , 10);
 744    #else
 745        cli_ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method());
 746    #endif
 747    }
 748#endif
 749    if (!tls13) {
 750#if !defined(WOLFSSL_TLS13)
 751    #ifdef WOLFSSL_STATIC_MEMORY
 752        ret = wolfSSL_CTX_load_static_memory(&cli_ctx, wolfSSLv23_client_method_ex,
 753            gWolfCTXCli, sizeof(gWolfCTXCli), WOLFMEM_GENERAL , 10);
 754    #else
 755        cli_ctx = wolfSSL_CTX_new(wolfSSLv23_client_method());
 756    #endif
 757#elif !defined(WOLFSSL_NO_TLS12)
 758    #ifdef WOLFSSL_STATIC_MEMORY
 759        ret = wolfSSL_CTX_load_static_memory(&cli_ctx, wolfTLSv1_2_client_method_ex,
 760            gWolfCTXCli, sizeof(gWolfCTXCli), WOLFMEM_GENERAL , 10);
 761    #else
 762        cli_ctx = wolfSSL_CTX_new(wolfTLSv1_2_client_method());
 763    #endif
 764#endif
 765    }
 766
 767    if (cli_ctx == NULL || ret != 0) {
 768        printf("error creating ctx: ret %d\n", ret);
 769        ret = MEMORY_E; goto exit;
 770    }
 771
 772#ifdef WOLFSSL_STATIC_MEMORY
 773    ret = wolfSSL_CTX_load_static_memory(&cli_ctx, 0, gWolfIOCli, sizeof(gWolfIOCli),
 774        WOLFMEM_IO_POOL, 10 );
 775#endif
 776
 777#ifndef NO_CERTS
 778#ifdef HAVE_ECC
 779    if (XSTRSTR(info->cipher, "ECDSA")) {
 780        ret = wolfSSL_CTX_load_verify_buffer(cli_ctx, ca_ecc_cert_der_256,
 781            sizeof_ca_ecc_cert_der_256, WOLFSSL_FILETYPE_ASN1);
 782    }
 783    else
 784#endif
 785    {
 786        ret = wolfSSL_CTX_load_verify_buffer(cli_ctx, ca_cert_der_2048,
 787            sizeof_ca_cert_der_2048, WOLFSSL_FILETYPE_ASN1);
 788    }
 789    if (ret != WOLFSSL_SUCCESS) {
 790        printf("error loading CA\n");
 791        goto exit;
 792    }
 793#endif /* !NO_CERTS */
 794
 795    wolfSSL_CTX_SetIOSend(cli_ctx, ClientSend);
 796    wolfSSL_CTX_SetIORecv(cli_ctx, ClientRecv);
 797
 798    /* set cipher suite */
 799    ret = wolfSSL_CTX_set_cipher_list(cli_ctx, info->cipher);
 800    if (ret != WOLFSSL_SUCCESS) {
 801        printf("error setting cipher suite\n");
 802        goto exit;
 803    }
 804
 805#ifndef NO_DH
 806    ret = wolfSSL_CTX_SetMinDhKey_Sz(cli_ctx, MIN_DHKEY_BITS);
 807    if (ret != WOLFSSL_SUCCESS) {
 808        printf("Error setting minimum DH key size\n");
 809        goto exit;
 810    }
 811#endif /* !NO_DH */
 812
 813    /* Allocate and initialize a packet sized buffer */
 814    writeBuf = (unsigned char*)XMALLOC(info->packetSize, NULL,
 815        DYNAMIC_TYPE_TMP_BUFFER);
 816    if (writeBuf == NULL) {
 817        printf("failed to allocate write memory\n");
 818        ret = MEMORY_E; goto exit;
 819    }
 820
 821    /* Allocate read buffer */
 822    readBufSz = info->packetSize;
 823    readBuf = (unsigned char*)XMALLOC(readBufSz, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 824    if (readBuf == NULL) {
 825        printf("failed to allocate read memory\n");
 826        ret = MEMORY_E; goto exit;
 827    }
 828
 829    /* BENCHMARK CONNECTIONS LOOP */
 830    while (!info->client.shutdown) {
 831        int writeSz = info->packetSize;
 832    #ifdef BENCH_USE_NONBLOCK
 833        int err;
 834    #endif
 835
 836        cli_ssl = wolfSSL_new(cli_ctx);
 837        if (cli_ssl == NULL) {
 838            printf("error creating client object\n");
 839            ret = MEMORY_E; goto exit;
 840        }
 841
 842        wolfSSL_SetIOReadCtx(cli_ssl, info);
 843        wolfSSL_SetIOWriteCtx(cli_ssl, info);
 844
 845        /* perform connect */
 846        start = gettime_secs(1);
 847    #ifndef BENCH_USE_NONBLOCK
 848        ret = wolfSSL_connect(cli_ssl);
 849    #else
 850        do
 851        {
 852            ret = wolfSSL_connect(cli_ssl);
 853            err = wolfSSL_get_error(cli_ssl, ret);
 854        }
 855        while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
 856    #endif
 857        start = gettime_secs(0) - start;
 858        if (ret != WOLFSSL_SUCCESS) {
 859            ret = wolfSSL_get_error(cli_ssl, ret);
 860            printf("error %d connecting client\n", ret);
 861            goto exit;
 862        }
 863        info->client_stats.connTime += start;
 864        info->client_stats.connCount++;
 865
 866        if ((info->showPeerInfo) && (!haveShownPeerInfo)) {
 867            haveShownPeerInfo = 1;
 868            ShowPeer(cli_ssl);
 869        }
 870
 871        /* check for run time completion and issue shutdown */
 872        if (gettime_secs(0) - total >= info->runTimeSec) {
 873            info->client.shutdown = 1;
 874
 875            writeSz = (int)XSTRLEN(kShutdown) + 1;
 876            XMEMCPY(writeBuf, kShutdown, writeSz); /* include null term */
 877            if (info->showVerbose) {
 878                printf("Sending shutdown\n");
 879            }
 880
 881            ret = wolfSSL_write(cli_ssl, writeBuf, writeSz);
 882            if (ret < 0) {
 883                ret = wolfSSL_get_error(cli_ssl, ret);
 884                printf("error %d on client write\n", ret);
 885                goto exit;
 886            }
 887        }
 888        else {
 889            XMEMSET(writeBuf, 0, info->packetSize);
 890            XSTRNCPY((char*)writeBuf, kTestStr, info->packetSize);
 891        }
 892
 893        /* write / read echo loop */
 894        ret = 0;
 895        total_sz = 0;
 896        while (ret == 0 && total_sz < info->maxSize && !info->client.shutdown) {
 897            /* write test message to server */
 898            start = gettime_secs(1);
 899        #ifndef BENCH_USE_NONBLOCK
 900            ret = wolfSSL_write(cli_ssl, writeBuf, writeSz);
 901        #else
 902            do {
 903                ret = wolfSSL_write(cli_ssl, writeBuf, writeSz);
 904                err = wolfSSL_get_error(cli_ssl, ret);
 905            }
 906            while (err == WOLFSSL_ERROR_WANT_WRITE);
 907        #endif
 908            info->client_stats.txTime += gettime_secs(0) - start;
 909            if (ret < 0) {
 910                ret = wolfSSL_get_error(cli_ssl, ret);
 911                printf("error %d on client write\n", ret);
 912                goto exit;
 913            }
 914            info->client_stats.txTotal += ret;
 915            total_sz += ret;
 916
 917            /* read echo of message from server */
 918            XMEMSET(readBuf, 0, readBufSz);
 919            start = gettime_secs(1);
 920        #ifndef BENCH_USE_NONBLOCK
 921            ret = wolfSSL_read(cli_ssl, readBuf, readBufSz);
 922        #else
 923            do {
 924                ret = wolfSSL_read(cli_ssl, readBuf, readBufSz);
 925                err = wolfSSL_get_error(cli_ssl, ret);
 926            }
 927            while (err == WOLFSSL_ERROR_WANT_READ);
 928        #endif
 929            info->client_stats.rxTime += gettime_secs(0) - start;
 930            if (ret < 0) {
 931                ret = wolfSSL_get_error(cli_ssl, ret);
 932                printf("error %d on client read\n", ret);
 933                goto exit;
 934            }
 935            info->client_stats.rxTotal += ret;
 936            ret = 0; /* reset return code */
 937
 938            /* validate echo */
 939            if (XMEMCMP((char*)writeBuf, (char*)readBuf, writeSz) != 0) {
 940                printf("echo check failed!\n");
 941                goto exit;
 942            }
 943        }
 944
 945        wolfSSL_free(cli_ssl);
 946        cli_ssl = NULL;
 947    }
 948
 949exit:
 950
 951    if (ret != 0 && ret != WOLFSSL_SUCCESS) {
 952        info->doShutdown = 1;
 953        printf("Client Error: %d (%s)\n", ret,
 954            wolfSSL_ERR_reason_error_string(ret));
 955    }
 956
 957    /* cleanup */
 958    if (cli_ssl != NULL)
 959        wolfSSL_free(cli_ssl);
 960    if (cli_ctx != NULL)
 961        wolfSSL_CTX_free(cli_ctx);
 962    XFREE(readBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 963    XFREE(writeBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 964    info->client.ret = ret;
 965
 966    return ret;
 967}
 968
 969#ifdef CMSIS_OS2_H_
 970static void client_thread(void* args)
 971#else
 972static void client_thread(const void* args)
 973#endif
 974{
 975    int ret;
 976    info_t* info = (info_t*)args;
 977
 978#ifdef CMSIS_OS2_H_
 979    info->client.threadId = osThreadGetId();
 980#endif
 981    do {
 982        ret = bench_tls_client(info);
 983
 984        /* signal server */
 985        if (!info->server.done && info->server.threadId != 0) {
 986#ifdef CMSIS_OS2_H_
 987            osThreadFlagsSet(info->server.threadId, 1);
 988#else
 989            osSignalSet(info->server.threadId, 1);
 990#endif
 991        }
 992        info->client.ret = ret;
 993        info->client.done = 1;
 994        osThreadSuspend(info->client.threadId);
 995
 996        if (info->doShutdown)
 997            info->server.done = 1;
 998    } while (!info->doShutdown);
 999
1000    osThreadTerminate(info->client.threadId);
1001    info->client.threadId = NULL;
1002}
1003
1004static int bench_tls_server(info_t* info)
1005{
1006    byte *readBuf = NULL;
1007    double start;
1008    int ret = 0, len = 0, readBufSz;
1009    WOLFSSL_CTX* srv_ctx = NULL;
1010    WOLFSSL* srv_ssl = NULL;
1011    int tls13 = XSTRNCMP(info->cipher, "TLS13", 5) == 0;
1012    int total_sz;
1013
1014    /* set up server */
1015#ifdef WOLFSSL_TLS13
1016    if (tls13) {
1017    #ifdef WOLFSSL_STATIC_MEMORY
1018        ret = wolfSSL_CTX_load_static_memory(&srv_ctx, wolfTLSv1_3_server_method_ex,
1019            gWolfCTXSrv, sizeof(gWolfCTXSrv), WOLFMEM_GENERAL , 10);
1020    #else
1021        srv_ctx = wolfSSL_CTX_new(wolfTLSv1_3_server_method());
1022    #endif
1023    }
1024#endif
1025    if (!tls13) {
1026#if !defined(WOLFSSL_TLS13)
1027    #ifdef WOLFSSL_STATIC_MEMORY
1028        ret = wolfSSL_CTX_load_static_memory(&srv_ctx, wolfSSLv23_server_method_ex,
1029            gWolfCTXSrv, sizeof(gWolfCTXSrv), WOLFMEM_GENERAL , 10);
1030    #else
1031        srv_ctx = wolfSSL_CTX_new(wolfSSLv23_server_method());
1032    #endif
1033#elif !defined(WOLFSSL_NO_TLS12)
1034    #ifdef WOLFSSL_STATIC_MEMORY
1035        ret = wolfSSL_CTX_load_static_memory(&srv_ctx, wolfTLSv1_2_server_method_ex,
1036            gWolfCTXSrv, sizeof(gWolfCTXSrv), WOLFMEM_GENERAL , 10);
1037    #else
1038        srv_ctx = wolfSSL_CTX_new(wolfTLSv1_2_server_method());
1039    #endif
1040#endif
1041    }
1042
1043    if (srv_ctx == NULL || ret != 0) {
1044        printf("error creating server ctx: ret %d\n", ret);
1045        ret = MEMORY_E; goto exit;
1046    }
1047
1048#ifdef WOLFSSL_STATIC_MEMORY
1049    ret = wolfSSL_CTX_load_static_memory(&srv_ctx, 0, gWolfIOSrv, sizeof(gWolfIOSrv),
1050        WOLFMEM_IO_POOL, 10 );
1051#endif
1052
1053#ifndef NO_CERTS
1054#ifdef HAVE_ECC
1055    if (XSTRSTR(info->cipher, "ECDSA")) {
1056        ret = wolfSSL_CTX_use_PrivateKey_buffer(srv_ctx, ecc_key_der_256,
1057            sizeof_ecc_key_der_256, WOLFSSL_FILETYPE_ASN1);
1058    }
1059    else
1060#endif
1061    {
1062        ret = wolfSSL_CTX_use_PrivateKey_buffer(srv_ctx, server_key_der_2048,
1063            sizeof_server_key_der_2048, WOLFSSL_FILETYPE_ASN1);
1064    }
1065    if (ret != WOLFSSL_SUCCESS) {
1066        printf("error loading server key\n");
1067        goto exit;
1068    }
1069
1070#ifdef HAVE_ECC
1071    if (XSTRSTR(info->cipher, "ECDSA")) {
1072        ret = wolfSSL_CTX_use_certificate_buffer(srv_ctx, serv_ecc_der_256,
1073            sizeof_serv_ecc_der_256, WOLFSSL_FILETYPE_ASN1);
1074    }
1075    else
1076#endif
1077    {
1078        ret = wolfSSL_CTX_use_certificate_buffer(srv_ctx, server_cert_der_2048,
1079            sizeof_server_cert_der_2048, WOLFSSL_FILETYPE_ASN1);
1080    }
1081    if (ret != WOLFSSL_SUCCESS) {
1082        printf("error loading server cert\n");
1083        goto exit;
1084    }
1085#endif /* !NO_CERTS */
1086
1087    wolfSSL_CTX_SetIOSend(srv_ctx, ServerSend);
1088    wolfSSL_CTX_SetIORecv(srv_ctx, ServerRecv);
1089
1090    /* set cipher suite */
1091    ret = wolfSSL_CTX_set_cipher_list(srv_ctx, info->cipher);
1092    if (ret != WOLFSSL_SUCCESS) {
1093        printf("error setting cipher suite\n");
1094        goto exit;
1095    }
1096
1097#ifndef NO_DH
1098    ret = wolfSSL_CTX_SetMinDhKey_Sz(srv_ctx, MIN_DHKEY_BITS);
1099    if (ret != WOLFSSL_SUCCESS) {
1100        printf("Error setting minimum DH key size\n");
1101        goto exit;
1102    }
1103#endif
1104
1105    /* Allocate read buffer */
1106    readBufSz = info->packetSize;
1107    readBuf = (unsigned char*)XMALLOC(readBufSz, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1108    if (readBuf == NULL) {
1109        printf("failed to allocate read memory\n");
1110        ret = MEMORY_E; goto exit;
1111    }
1112
1113    /* BENCHMARK CONNECTIONS LOOP */
1114    while (!info->server.shutdown) {
1115    #ifdef BENCH_USE_NONBLOCK
1116        int err;
1117    #endif
1118
1119    #ifdef BENCH_USE_NONBLOCK
1120        if (ret == -2) {
1121            osDelay(0);
1122            continue;
1123        }
1124    #endif
1125
1126        srv_ssl = wolfSSL_new(srv_ctx);
1127        if (srv_ssl == NULL) {
1128            printf("error creating server object\n");
1129            ret = MEMORY_E; goto exit;
1130        }
1131
1132        wolfSSL_SetIOReadCtx(srv_ssl, info);
1133        wolfSSL_SetIOWriteCtx(srv_ssl, info);
1134
1135    #ifndef NO_DH
1136        wolfSSL_SetTmpDH(srv_ssl, p, sizeof(p), g, sizeof(g));
1137    #endif
1138
1139        /* accept TLS connection */
1140        start = gettime_secs(1);
1141    #ifndef BENCH_USE_NONBLOCK
1142        ret = wolfSSL_accept(srv_ssl);
1143    #else
1144        do {
1145            ret = wolfSSL_accept(srv_ssl);
1146            err = wolfSSL_get_error(srv_ssl, ret);
1147        }
1148        while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1149    #endif
1150        start = gettime_secs(0) - start;
1151        if (ret != WOLFSSL_SUCCESS) {
1152            ret = wolfSSL_get_error(srv_ssl, ret);
1153            printf("error %d on server accept\n", ret);
1154            goto exit;
1155        }
1156
1157        info->server_stats.connTime += start;
1158        info->server_stats.connCount++;
1159
1160        /* echo loop */
1161        ret = 0;
1162        total_sz = 0;
1163        while (ret == 0 && total_sz < info->maxSize) {
1164            double rxTime;
1165
1166            /* read message from client */
1167            XMEMSET(readBuf, 0, readBufSz);
1168            start = gettime_secs(1);
1169        #ifndef BENCH_USE_NONBLOCK
1170            ret = wolfSSL_read(srv_ssl, readBuf, readBufSz);
1171        #else
1172            do {
1173                ret = wolfSSL_read(srv_ssl, readBuf, readBufSz);
1174                err = wolfSSL_get_error(srv_ssl, ret);
1175            }
1176            while (err == WOLFSSL_ERROR_WANT_READ);
1177        #endif
1178            rxTime = gettime_secs(0) - start;
1179
1180            /* shutdown signals, no more connections for this cipher */
1181            if (XSTRSTR((const char*)readBuf, kShutdown) != NULL) {
1182                info->server.shutdown = 1;
1183                if (info->showVerbose) {
1184                    printf("Server shutdown done\n");
1185                }
1186                ret = 0; /* success */
1187                break;
1188            }
1189
1190            info->server_stats.rxTime += rxTime;
1191            if (ret < 0) {
1192                ret = wolfSSL_get_error(srv_ssl, ret);
1193                printf("error %d on server read\n", ret);
1194                goto exit;
1195            }
1196            info->server_stats.rxTotal += ret;
1197            len = ret;
1198            total_sz += ret;
1199
1200            /* write message back to client */
1201            start = gettime_secs(1);
1202        #ifndef BENCH_USE_NONBLOCK
1203            ret = wolfSSL_write(srv_ssl, readBuf, len);
1204        #else
1205            do {
1206                ret = wolfSSL_write(srv_ssl, readBuf, len);
1207                err = wolfSSL_get_error(srv_ssl, ret);
1208            }
1209            while (err == WOLFSSL_ERROR_WANT_WRITE);
1210        #endif
1211            info->server_stats.txTime += gettime_secs(0) - start;
1212            if (ret < 0) {
1213                ret = wolfSSL_get_error(srv_ssl, ret);
1214                printf("error %d on server write\n", ret);
1215                goto exit;
1216            }
1217            info->server_stats.txTotal += ret;
1218            ret = 0; /* reset return code */
1219        }
1220
1221        wolfSSL_free(srv_ssl);
1222        srv_ssl = NULL;
1223    }
1224
1225exit:
1226
1227    if (ret != 0 && ret != WOLFSSL_SUCCESS) {
1228        info->doShutdown = 1;
1229        printf("Server Error: %d (%s)\n", ret,
1230            wolfSSL_ERR_reason_error_string(ret));
1231    }
1232
1233    /* clean up */
1234    if (srv_ssl != NULL)
1235        wolfSSL_free(srv_ssl);
1236    if (srv_ctx != NULL)
1237        wolfSSL_CTX_free(srv_ctx);
1238    XFREE(readBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1239    info->server.ret = ret;
1240
1241    return ret;
1242}
1243
1244#ifdef CMSIS_OS2_H_
1245static void server_thread(void* args)
1246#else
1247static void server_thread(const void* args)
1248#endif
1249{
1250    int ret;
1251    info_t* info = (info_t*)args;
1252
1253#ifdef CMSIS_OS2_H_
1254    info->server.threadId = osThreadGetId();
1255#endif
1256    do {
1257        ret = bench_tls_server(info);
1258
1259        /* signal client */
1260        if (!info->client.done && info->client.threadId != 0) {
1261#ifdef CMSIS_OS2_H_
1262            osThreadFlagsSet(info->client.threadId, 1);
1263#else
1264            osSignalSet(info->client.threadId, 1);
1265#endif
1266        }
1267        info->server.ret = ret;
1268        info->server.done = 1;
1269        osThreadSuspend(info->server.threadId);
1270
1271        if (info->doShutdown)
1272            info->client.done = 1;
1273    } while (!info->doShutdown);
1274
1275    osThreadTerminate(info->server.threadId);
1276    info->server.threadId = NULL;
1277}
1278
1279#ifdef CMSIS_OS2_H_
1280static const osThreadAttr_t server_thread_attributes = {
1281  .name = "server_thread",
1282  .priority = (osPriority_t) osPriorityNormal,
1283  .stack_size = WOLF_EXAMPLES_STACK
1284};
1285static const osThreadAttr_t client_thread_attributes = {
1286  .name = "client_thread",
1287  .priority = (osPriority_t) osPriorityNormal,
1288  .stack_size = WOLF_EXAMPLES_STACK
1289};
1290#endif
1291
1292int bench_tls(void* args)
1293{
1294    int ret = 0;
1295    info_t *info = NULL;
1296    char *cipher, *next_cipher, *ciphers;
1297
1298    /* Runtime variables */
1299    int argRuntimeSec = BENCH_RUNTIME_SEC;
1300    int argTestPacketSize = TEST_PACKET_SIZE;
1301    int argTestMaxSize = TEST_MAX_SIZE;
1302    int argShowVerbose = SHOW_VERBOSE;
1303    const char* argHost = BENCH_DEFAULT_HOST;
1304    int argPort = BENCH_DEFAULT_PORT;
1305    int argShowPeerInfo = BENCH_SHOW_PEER_INFO;
1306
1307#ifdef DEBUG_WOLFSSL
1308    if (argShowVerbose >= 3) {
1309        wolfSSL_Debugging_ON();
1310    }
1311    else {
1312        wolfSSL_Debugging_OFF();
1313    }
1314#endif
1315
1316#ifdef TEST_CIPHER_SUITE
1317    ciphers = TEST_CIPHER_SUITE;
1318#else
1319    /* Get cipher suite list */
1320    ciphers = (char*)XMALLOC(WOLFSSL_CIPHER_LIST_MAX_SIZE, NULL,
1321        DYNAMIC_TYPE_TMP_BUFFER);
1322    if (ciphers == NULL) {
1323        ret = MEMORY_E; goto exit;
1324    }
1325    wolfSSL_get_ciphers(ciphers, WOLFSSL_CIPHER_LIST_MAX_SIZE);
1326#endif
1327    cipher = ciphers;
1328
1329    /* Allocate test info */
1330    info = (info_t*)XMALLOC(sizeof(info_t), NULL, DYNAMIC_TYPE_TMP_BUFFER);
1331    if (info == NULL) {
1332        ret = MEMORY_E; goto exit;
1333    }
1334    XMEMSET(info, 0, sizeof(info_t));
1335
1336    info->host = argHost;
1337    info->port = argPort;
1338    info->packetSize = argTestPacketSize;
1339    info->runTimeSec = argRuntimeSec;
1340    info->maxSize = argTestMaxSize;
1341    info->showPeerInfo = argShowPeerInfo;
1342    info->showVerbose = argShowVerbose;
1343
1344#ifdef CMSIS_OS2_H_
1345    info->server.mutex = osSemaphoreNew(1, 0, NULL);
1346    info->client.mutex = osSemaphoreNew(1, 0, NULL);
1347#else
1348    info->server.mutex = osSemaphoreCreate(&info->server.mutexDef, 1);
1349    info->client.mutex = osSemaphoreCreate(&info->client.mutexDef, 1);
1350
1351    /* threads */
1352    info->server.threadDef.name = "server_thread";
1353    info->server.threadDef.pthread = server_thread;
1354    info->server.threadDef.tpriority = osPriorityNormal;
1355    info->server.threadDef.stacksize = WOLF_EXAMPLES_STACK;
1356
1357    info->client.threadDef.name = "client_thread";
1358    info->client.threadDef.pthread = client_thread;
1359    info->client.threadDef.tpriority = osPriorityNormal;
1360    info->client.threadDef.stacksize = WOLF_EXAMPLES_STACK;
1361#endif
1362
1363    /* parse by : */
1364    while ((cipher != NULL) && (cipher[0] != '\0')) {
1365        next_cipher = strchr(cipher, ':');
1366        if (next_cipher != NULL) {
1367            cipher[next_cipher - cipher] = '\0';
1368        }
1369
1370        if (argShowVerbose) {
1371            printf("Cipher: %s\n", cipher);
1372        }
1373
1374        /* set cipher suite */
1375        info->cipher = cipher;
1376
1377        /* reset thread info */
1378        info->server.ret = info->client.ret = 0;
1379        info->server.done = info->client.done = 0;
1380        info->server.shutdown = info->client.shutdown = 0;
1381        XMEMSET(&info->server_stats, 0, sizeof(info->server_stats));
1382        XMEMSET(&info->client_stats, 0, sizeof(info->client_stats));
1383        XMEMSET(&info->to_server, 0, sizeof(info->to_server));
1384        XMEMSET(&info->to_client, 0, sizeof(info->to_client));
1385
1386        /* make sure nothing is locking it */
1387        osSemaphoreRelease(info->server.mutex);
1388        osSemaphoreRelease(info->client.mutex);
1389
1390        /* start threads */
1391        if (info->server.threadId == 0) {
1392#ifdef CMSIS_OS2_H_
1393            osThreadNew(server_thread, info, &server_thread_attributes);
1394#else
1395            info->server.threadId = osThreadCreate(&info->server.threadDef, info);
1396#endif
1397        }
1398        else {
1399            osThreadResume(info->server.threadId);
1400        }
1401        if (info->client.threadId == 0) {
1402#ifdef CMSIS_OS2_H_
1403            osThreadNew(client_thread, info, &client_thread_attributes);
1404#else
1405            info->client.threadId = osThreadCreate(&info->client.threadDef, info);
1406#endif
1407        }
1408        else {
1409            osThreadResume(info->client.threadId);
1410        }
1411
1412        /* Wait until threads are marked done */
1413        while (!info->client.done || !info->server.done) {
1414            osThreadYield(); /* Allow other threads to run */
1415        }
1416
1417        if (argShowVerbose) {
1418            /* print results */
1419            PrintTlsStats(&info->server_stats, "Server", info->cipher, 1);
1420            PrintTlsStats(&info->client_stats, "Client", info->cipher, 1);
1421        }
1422
1423        printf("%-6s  %-33s  %11s  %9s  %9s  %9s  %9s  %9s  %17s  %15s\n",
1424            "Side", "Cipher", "Total Bytes", "Num Conns", "Rx ms", "Tx ms",
1425            "Rx MB/s", "Tx MB/s", "Connect Total ms", "Connect Avg ms");
1426        PrintTlsStats(&info->server_stats, "Server", info->cipher, 0);
1427        PrintTlsStats(&info->client_stats, "Client", info->cipher, 0);
1428
1429        PrintMemStats();
1430
1431        /* target next cipher */
1432        cipher = (next_cipher != NULL) ? (next_cipher + 1) : NULL;
1433    } /* while */
1434
1435    /* do thread shutdown */
1436    info->doShutdown = 1;
1437    info->server.done = 0;
1438    info->client.done = 0;
1439    osThreadResume(info->server.threadId);
1440    osThreadResume(info->client.threadId);
1441    /* Wait until threads are marked done */
1442    while (!info->client.done || !info->server.done) {
1443        osThreadYield(); /* Allow other threads to run */
1444    }
1445
1446exit:
1447
1448    /* cleanup thread info */
1449    osSemaphoreDelete(info->server.mutex);
1450    osSemaphoreDelete(info->client.mutex);
1451    XFREE(info, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1452
1453#ifndef TEST_CIPHER_SUITE
1454    /* Free cipher list */
1455    XFREE(ciphers, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1456#endif
1457
1458    /* set return code */
1459    if (args)
1460        ((func_args*)args)->return_code = ret;
1461
1462    return ret;
1463}
1464#endif /* ENABLE_TLS_BENCH */
1465
1466
1467#ifndef WOLFCRYPT_ONLY
1468static void ShowCiphers(void)
1469{
1470    int ret;
1471    char* ciphers = (char*)XMALLOC(WOLFSSL_CIPHER_LIST_MAX_SIZE, NULL,
1472        DYNAMIC_TYPE_TMP_BUFFER);
1473    if (ciphers) {
1474        ret = wolfSSL_get_ciphers(ciphers, WOLFSSL_CIPHER_LIST_MAX_SIZE);
1475        if (ret == WOLFSSL_SUCCESS)
1476            printf("%s\n", ciphers);
1477        XFREE(ciphers, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1478    }
1479}
1480#endif
1481
1482static void PrintMemStats(void)
1483{
1484#ifdef WOLFSSL_DEBUG_MEMORY
1485    printf("\nHeap MinEver %d, Free %d, Stack %lu\n",
1486        xPortGetMinimumEverFreeHeapSize(),
1487        xPortGetFreeHeapSize(),
1488        uxTaskGetStackHighWaterMark(NULL));
1489#endif
1490}
1491
1492
1493#ifdef ENABLE_TLS_UART
1494
1495/* UART DMA IO Routines */
1496#ifndef B115200
1497#define B115200 115200
1498#endif
1499
1500/* Max buffer for a single TLS frame */
1501#ifndef MAX_RECORD_SIZE
1502#define MAX_RECORD_SIZE (16 * 1024)
1503#endif
1504
1505typedef struct {
1506    int curr_index;
1507    int data_len;
1508    char buf[MAX_RECORD_SIZE];
1509} tls13_buf;
1510
1511/* This sets which UART to do the TLS 1.3 connection over.  It is something you
1512 * will have to configure in STMCubeIDE and then change here. */
1513#ifndef TLS_UART
1514#define TLS_UART huart2
1515#endif
1516/* If you get an undefined error here you can optionally disable the TLS
1517 * over UART test using NO_TLS_UART_TEST */
1518extern UART_HandleTypeDef TLS_UART;
1519
1520static int msg_length = 0;
1521
1522void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {
1523   if (huart->Instance == TLS_UART.Instance) {
1524       msg_length = Size;
1525   }
1526}
1527
1528static int uartIORx(WOLFSSL *ssl, char *buf, int sz, void *ctx)
1529{
1530    HAL_StatusTypeDef status;
1531    tls13_buf *tb = ctx;
1532
1533#ifdef DEBUG_UART_IO
1534    printf("UART Read: In %d\n", sz);
1535#endif
1536
1537    if (tb->curr_index + sz <= tb->data_len) {
1538        XMEMCPY(buf, tb->buf + tb->curr_index, sz);
1539        tb->curr_index += sz;
1540#ifdef DEBUG_UART_IO
1541        printf("UART Read1: Out %d\n", sz);
1542#endif
1543        return sz;
1544    }
1545
1546    msg_length = 0;
1547    XMEMSET(tb, 0, sizeof(*tb));
1548
1549    /* Now setup the DMA RX */
1550    /* This requires enabling the UART RX DMA in the STM32Cube tool
1551     * Under Connectivity click on your TLS UART (USART2) and goto DMA Settings
1552     * and Add one for USART2_RX with default options */
1553    status = HAL_UARTEx_ReceiveToIdle_DMA(&TLS_UART, (uint8_t *)tb->buf, MAX_RECORD_SIZE);
1554    if (status != HAL_OK) {
1555        return WOLFSSL_CBIO_ERR_WANT_READ;
1556    }
1557    else {
1558        /* We now go into an infinite loop waiting for msg_length to be set to a
1559         * value other than 0. This will be done when the other side writes to
1560         * UART and then idles. That will trigger HAL_UARTEx_RxEventCallback()
1561         * which will set msg_length to the length of data written.
1562         *
1563         * If you mistakenly get stuck here, please simply reset the board.
1564         */
1565        while (msg_length == 0) {
1566            HAL_Delay(10);
1567        }
1568#ifdef DEBUG_UART_IO
1569        printf("Message received! length = %d\n", msg_length);
1570#endif
1571    }
1572
1573    /* now return the number of bytes requested. */
1574    XMEMCPY(buf, tb->buf, sz);
1575    tb->data_len = msg_length;
1576    tb->curr_index = sz;
1577
1578#ifdef DEBUG_UART_IO
1579    printf("UART Read2: Out %d\n", tb->data_len);
1580#endif
1581
1582    return sz;
1583}
1584
1585static int uartIOTx(WOLFSSL *ssl, char *buf, int sz, void *ctx)
1586{
1587    HAL_StatusTypeDef status;
1588    int ret = sz;
1589    (void)ctx;
1590
1591#ifdef DEBUG_UART_IO
1592    printf("UART Write: In %d\n", sz);
1593#endif
1594
1595    status = HAL_UART_Transmit(&TLS_UART, (uint8_t *)buf, sz, 0xFFFF);
1596    if (status != HAL_OK) {
1597        ret = WOLFSSL_CBIO_ERR_WANT_WRITE;
1598    }
1599
1600#ifdef DEBUG_UART_IO
1601    printf("UART Write: Out %d\n", ret);
1602#endif
1603
1604    return ret;
1605}
1606
1607static void uartReset(void)
1608{
1609    HAL_UART_Abort_IT(&TLS_UART);
1610}
1611
1612/* UART TLS 1.3 client and server */
1613#ifndef NO_WOLFSSL_SERVER
1614static int tls13_uart_server(void)
1615{
1616    int ret = -1, err;
1617    WOLFSSL_CTX* ctx = NULL;
1618    WOLFSSL* ssl = NULL;
1619    byte echoBuffer[100];
1620#ifdef WOLFSSL_SMALL_STACK
1621    tls13_buf* tbuf = (tls13_buf*)XMALLOC(sizeof(*tbuf), NULL,
1622                                          DYNAMIC_TYPE_TMP_BUFFER);
1623    if (tbuf == NULL) {
1624        printf("Memory allocation error\n");
1625        goto done;
1626    }
1627#else
1628    tls13_buf tbuf[1];
1629#endif
1630
1631    XMEMSET(tbuf, 0, sizeof(tls13_buf));
1632
1633    ctx = wolfSSL_CTX_new(wolfTLSv1_3_server_method());
1634    if (ctx == NULL) {
1635        printf("Error creating WOLFSSL_CTX\n");
1636        goto done;
1637    }
1638
1639    /* Register wolfSSL send/recv callbacks */
1640    uartReset();
1641    wolfSSL_CTX_SetIOSend(ctx, uartIOTx);
1642    wolfSSL_CTX_SetIORecv(ctx, uartIORx);
1643
1644    ret = wolfSSL_CTX_use_PrivateKey_buffer(ctx, ecc_key_der_256,
1645        sizeof_ecc_key_der_256, WOLFSSL_FILETYPE_ASN1);
1646    if (ret != WOLFSSL_SUCCESS) {
1647        printf("error loading server private key\n");
1648        goto done;
1649    }
1650
1651    ret = wolfSSL_CTX_use_certificate_buffer(ctx, serv_ecc_der_256,
1652        sizeof_serv_ecc_der_256, WOLFSSL_FILETYPE_ASN1);
1653    if (ret != WOLFSSL_SUCCESS) {
1654        printf("error loading server certificate\n");
1655        goto done;
1656    }
1657
1658    ssl = wolfSSL_new(ctx);
1659    if (ssl == NULL) {
1660        printf("Error creating WOLFSSL\n");
1661        goto done;
1662    }
1663
1664    wolfSSL_SetIOReadCtx(ssl, tbuf);
1665
1666    printf("Waiting for client\n");
1667    do {
1668        ret = wolfSSL_accept(ssl);
1669        err = wolfSSL_get_error(ssl, ret);
1670    } while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1671    if (ret != WOLFSSL_SUCCESS) {
1672        printf("TLS accept error %d\n", err);
1673        goto done;
1674    }
1675    printf("TLS Accept handshake done\n");
1676
1677    /* Waiting for data to echo */
1678    XMEMSET(echoBuffer, 0, sizeof(echoBuffer));
1679    do {
1680        ret = wolfSSL_read(ssl, echoBuffer, sizeof(echoBuffer)-1);
1681        err = wolfSSL_get_error(ssl, ret);
1682    } while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1683    printf("Read (%d): %s\n", err, echoBuffer);
1684
1685    do {
1686        ret = wolfSSL_write(ssl, echoBuffer, XSTRLEN((char*)echoBuffer));
1687        err = wolfSSL_get_error(ssl, ret);
1688    } while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1689    printf("Sent (%d): %s\n", err, echoBuffer);
1690
1691    ret = 0; /* Success */
1692
1693done:
1694    if (ssl) {
1695        wolfSSL_shutdown(ssl);
1696        wolfSSL_free(ssl);
1697    }
1698    if (ctx) {
1699        wolfSSL_CTX_free(ctx);
1700    }
1701
1702#ifdef WOLFSSL_SMALL_STACK
1703    XFREE(tbuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1704#endif
1705
1706    return ret;
1707}
1708#endif
1709
1710#ifdef ENABLE_TLS_UART
1711static int tls13_uart_client(void)
1712{
1713    int ret = -1, err;
1714    WOLFSSL_CTX* ctx = NULL;
1715    WOLFSSL* ssl = NULL;
1716    const char testStr[] = "Testing 1, 2 and 3\r\n";
1717    byte readBuf[100];
1718#ifdef WOLFSSL_SMALL_STACK
1719    tls13_buf* tbuf = (tls13_buf*)XMALLOC(sizeof(*tbuf), NULL,
1720                                            DYNAMIC_TYPE_TMP_BUFFER);
1721    if (tbuf == NULL) {
1722        printf("Memory allocation error\n");
1723        goto done;
1724    }
1725#else
1726    tls13_buf tbuf[1];
1727#endif
1728
1729    XMEMSET(tbuf, 0, sizeof(tls13_buf));
1730
1731    ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method());
1732    if (ctx == NULL) {
1733        printf("Error creating WOLFSSL_CTX\n");
1734        goto done;
1735    }
1736
1737    /* Register wolfSSL send/recv callbacks */
1738    uartReset();
1739    wolfSSL_CTX_SetIOSend(ctx, uartIOTx);
1740    wolfSSL_CTX_SetIORecv(ctx, uartIORx);
1741
1742    /* Load the root certificate. */
1743    wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
1744
1745    ssl = wolfSSL_new(ctx);
1746    if (ssl == NULL) {
1747        printf("Error creating WOLFSSL\n");
1748        goto done;
1749    }
1750
1751    wolfSSL_SetIOReadCtx(ssl, tbuf);
1752
1753#ifdef WOLFSSL_HAVE_MLKEM
1754#ifndef WOLFSSL_NO_ML_KEM
1755    if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ML_KEM_512) != WOLFSSL_SUCCESS) {
1756        printf("wolfSSL_UseKeyShare Error!!");
1757    }
1758#else
1759    if (wolfSSL_UseKeyShare(ssl, WOLFSSL_KYBER_LEVEL1) != WOLFSSL_SUCCESS) {
1760        printf("wolfSSL_UseKeyShare Error!!");
1761    }
1762#endif
1763#endif
1764
1765    do {
1766        ret = wolfSSL_connect(ssl);
1767        err = wolfSSL_get_error(ssl, ret);
1768    } while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1769    if (ret != WOLFSSL_SUCCESS) {
1770        printf("TLS connect error %d\n", err);
1771        goto done;
1772    }
1773
1774    ShowPeer(ssl);
1775
1776    printf("TLS Connect handshake done\n");
1777    printf("Sending test string\n");
1778    do {
1779        ret = wolfSSL_write(ssl, testStr, XSTRLEN(testStr));
1780        err = wolfSSL_get_error(ssl, ret);
1781    } while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1782    printf("Sent (%d): %s\n", err, testStr);
1783
1784    XMEMSET(readBuf, 0, sizeof(readBuf));
1785    do {
1786        ret = wolfSSL_read(ssl, readBuf, sizeof(readBuf)-1);
1787        err = wolfSSL_get_error(ssl, ret);
1788    } while (err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE);
1789    printf("Read (%d): %s\n", err, readBuf);
1790
1791    ret = 0; /* Success */
1792
1793done:
1794    if (ssl) {
1795        wolfSSL_shutdown(ssl);
1796        wolfSSL_free(ssl);
1797    }
1798    if (ctx) {
1799        wolfSSL_CTX_free(ctx);
1800    }
1801#ifdef WOLFSSL_SMALL_STACK
1802    XFREE(tbuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1803#endif
1804
1805    return ret;
1806}
1807#endif
1808#endif /* ENABLE_TLS_UART */
1809
1810
1811/*****************************************************************************
1812 * Public functions
1813 ****************************************************************************/
1814#ifdef HAL_RTC_MODULE_ENABLED
1815extern RTC_HandleTypeDef hrtc;
1816double current_time(void)
1817{
1818    RTC_TimeTypeDef time;
1819    RTC_DateTypeDef date;
1820    uint32_t subsec = 0;
1821
1822    /* must get time and date here due to STM32 HW bug */
1823    HAL_RTC_GetTime(&hrtc, &time, FORMAT_BIN);
1824    HAL_RTC_GetDate(&hrtc, &date, FORMAT_BIN);
1825    /* Not all STM32 RTCs have subseconds in the struct */
1826#ifdef RTC_ALARMSUBSECONDMASK_ALL
1827    subsec = (255 - time.SubSeconds) * 1000 / 255;
1828#endif
1829
1830    (void) date;
1831
1832    /* return seconds.milliseconds */
1833    return ((double) time.Hours * 3600) + ((double) time.Minutes * 60)
1834            + (double) time.Seconds + ((double) subsec / 1000);
1835}
1836#endif /* HAL_RTC_MODULE_ENABLED */
1837
1838#ifdef CMSIS_OS2_H_
1839void wolfCryptDemo(void* argument)
1840#else
1841void wolfCryptDemo(const void* argument)
1842#endif
1843{
1844    HAL_StatusTypeDef halRet;
1845    uint8_t buffer[2];
1846    func_args args;
1847
1848#if 0
1849    wolfSSL_Debugging_ON();
1850#endif
1851
1852    /* initialize wolfSSL */
1853#ifdef WOLFCRYPT_ONLY
1854    wolfCrypt_Init();
1855#else
1856    wolfSSL_Init();
1857#endif
1858
1859#ifdef WOLFSSL_STATIC_MEMORY
1860    if (wc_LoadStaticMemory(&HEAP_HINT, gWolfMem, sizeof(gWolfMem),
1861            WOLFMEM_GENERAL, 10) != 0) {
1862        printf("unable to load static memory");
1863    }
1864#endif
1865
1866    //wolfSSL_SetAllocators(wolfMallocCb, wolfFreeCb, wolfReallocCb);
1867
1868    while (1) {
1869        memset(&args, 0, sizeof(args));
1870        args.return_code = NOT_COMPILED_IN; /* default */
1871
1872        printf("\n\t\t\t\tMENU\n");
1873        printf(menu1);
1874        printf("Please select one of the above options:\n");
1875
1876        do {
1877            halRet = HAL_UART_Receive(&HAL_CONSOLE_UART, buffer, sizeof(buffer), 100);
1878        } while (halRet != HAL_OK || buffer[0] == '\n' || buffer[0] == '\r');
1879
1880        switch (buffer[0]) {
1881        case 't':
1882            printf("Running wolfCrypt Tests...\n");
1883        #ifndef NO_CRYPT_TEST
1884            args.return_code = 0;
1885            wolfcrypt_test(&args);
1886        #else
1887            args.return_code = NOT_COMPILED_IN;
1888        #endif
1889            printf("Crypt Test: Return code %d\n", args.return_code);
1890            break;
1891
1892        case 'b':
1893            printf("Running wolfCrypt Benchmarks...\n");
1894        #ifndef NO_CRYPT_BENCHMARK
1895            args.return_code = 0;
1896            benchmark_test(&args);
1897        #else
1898            args.return_code = NOT_COMPILED_IN;
1899        #endif
1900            printf("Benchmark Test: Return code %d\n", args.return_code);
1901            break;
1902
1903        case 'l':
1904            printf("Running TLS Benchmarks...\n");
1905        #ifdef ENABLE_TLS_BENCH
1906            bench_tls(&args);
1907        #else
1908            args.return_code = NOT_COMPILED_IN;
1909        #endif
1910            printf("TLS Benchmarks: Return code %d\n", args.return_code);
1911            break;
1912
1913        case 'e':
1914        #ifndef WOLFCRYPT_ONLY
1915            ShowCiphers();
1916        #else
1917            printf("Not compiled in\n");
1918        #endif
1919            break;
1920#ifdef ENABLE_TLS_UART
1921        case 's':
1922        #ifndef NO_WOLFSSL_SERVER
1923            printf("Running TLS 1.3 server...\n");
1924            args.return_code = tls13_uart_server();
1925        #else
1926            args.return_code = NOT_COMPILED_IN;
1927        #endif
1928            printf("TLS 1.3 Server: Return code %d\n", args.return_code);
1929            break;
1930
1931        case 'c':
1932        #ifndef NO_WOLFSSL_CLIENT
1933            printf("Running TLS 1.3 client...\n");
1934            args.return_code = tls13_uart_client();
1935        #else
1936            args.return_code = NOT_COMPILED_IN;
1937        #endif
1938            printf("TLS 1.3 Client: Return code %d\n", args.return_code);
1939            break;
1940#endif /* ENABLE_TLS_UART */
1941            /* All other cases go here */
1942        default:
1943            printf("\nSelection out of range\n");
1944            break;
1945        }
1946
1947        PrintMemStats();
1948    }
1949
1950#ifdef WOLFCRYPT_ONLY
1951    wolfCrypt_Cleanup();
1952#else
1953    wolfSSL_Cleanup();
1954#endif
1955}