SBE70LC/user_settings.h

/* user_settings_template.h
 *
 * Copyright (C) 2006-2023 wolfSSL Inc.
 *
 * This file is part of wolfSSL.
 *
 * wolfSSL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * wolfSSL is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
 */
 
#ifndef WOLFSSL_USER_SETTINGS_H
#define WOLFSSL_USER_SETTINGS_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <predef.h>
 
/* =========================================================================
 * CRYPTO PROFILE SELECTION
 * =========================================================================
 * Uncomment ONE of the following to select a crypto profile.
 * Default (none selected): Full compatibility - TLS 1.2+1.3, all ciphers
 *
 * CRYPTO_PROFILE_AESGCM   - TLS 1.3 only, AES-GCM ciphers only
 *                            HW accelerated on SAME70, smallest footprint
 *
 * CRYPTO_PROFILE_CHACHA   - TLS 1.3 only, ChaCha20-Poly1305
 *                            Constant-time, no HW AES dependency
 *
 * CRYPTO_PROFILE_MINIMAL  - Bare minimum for constrained applications
 *                            WARNING: Limited cipher support
 * ========================================================================= */
// #define CRYPTO_PROFILE_AESGCM
// #define CRYPTO_PROFILE_CHACHA
// #define CRYPTO_PROFILE_MINIMAL
 
#define TARGET_EMBEDDED
 
/* ------------------------------------------------------------------------- */
/* Platform */
/* ------------------------------------------------------------------------- */
#define WOLFSSL_GENERAL_ALIGNMENT 4
 
/* ------------------------------------------------------------------------- */
/* SAME70 Hardware Crypto Acceleration                                       */
/* Enables AES-GCM offload to the SAME70 AES peripheral.                    */
/* ------------------------------------------------------------------------- */
#define WOLFSSL_SAME70_CRYPTO  /* AES-GCM hardware acceleration */
#define SIZEOF_LONG_LONG 8
#define WOLFSSL_W64_WRAPPER
 
/* Enable SSH KDF / extKeyUsage SSH bits used by the NetBurner SSH library */
#define WOLFSSL_WOLFSSH
 
/* Keep PQ off by default until size/perf measured */
#define NO_MLKEM
 
#if 0
    #define NO_64BIT /* disable use of 64-bit variables */
#endif
 
#ifdef TARGET_EMBEDDED
    /* disable mutex locking */
    // #define SINGLE_THREADED
 
    /* reduce stack use. For variables over 100 bytes allocate from heap */
    #define WOLFSSL_SMALL_STACK
 
    /* disable the built-in socket support and use the IO callbacks.
     * Set with wolfSSL_CTX_SetIORecv/wolfSSL_CTX_SetIOSend
     */
    #define WOLFSSL_USER_IO
#endif
 
#define WOLFSSL_32BIT_MILLI_TIME
 
/* ------------------------------------------------------------------------- */
/* Math Configuration */
/* ------------------------------------------------------------------------- */
#define ULLONG_MAX 18446744073709551615ULL
#define SP_WORD_SIZE 32
 
#undef USE_FAST_MATH
#if 0
    /* fast math (tfmc.) (stack based and timing resistant) */
    #define USE_FAST_MATH
    #define TFM_TIMING_RESISTANT
#else
    /* normal heap based integer.c (not timing resistant) */
#endif
 
/* Wolf Single Precision Math */
#undef WOLFSSL_SP
#if 1
    #define WOLFSSL_SP
    #define WOLFSSL_HAVE_SP_RSA
    #define WOLFSSL_HAVE_SP_DH
    #define WOLFSSL_HAVE_SP_ECC
    //#define WOLFSSL_SP_4096 /* Enable RSA/RH 4096-bit support */
    #define WOLFSSL_SP_384 /* Enable ECC 384-bit SECP384R1 support */
 
    #define WOLFSSL_SP_CACHE_RESISTANT
    // #define WOLFSSL_SP_MATH     /* only SP math - disables integer.c/tfm.c */
    #define WOLFSSL_SP_MATH_ALL /* use SP math for all key sizes and curves */
 
    //#define WOLFSSL_SP_NO_MALLOC
    //#define WOLFSSL_SP_DIV_32 /* do not use 64-bit divides */
 
    #ifdef TARGET_EMBEDDED
        /* use smaller version of code */
        #define WOLFSSL_SP_SMALL
    #else
        /* SP Assembly Speedups - specific to chip type */
        #define WOLFSSL_SP_ASM
    #endif
    //#define WOLFSSL_SP_X86_64
    //#define WOLFSSL_SP_X86
    //#define WOLFSSL_SP_ARM32_ASM
    //#define WOLFSSL_SP_ARM64_ASM
    //#define WOLFSSL_SP_ARM_THUMB_ASM
    #define WOLFSSL_SP_ARM_CORTEX_M_ASM
#endif
 
/* ------------------------------------------------------------------------- */
/* Crypto */
/* ------------------------------------------------------------------------- */
/* RSA */
#undef NO_RSA
#if 1
    #ifdef USE_FAST_MATH
        /* Maximum math bits (Max RSA key bits * 2) */
        #define FP_MAX_BITS 4096
    #endif
 
    /* half as much memory but twice as slow */
    //#define RSA_LOW_MEM
 
    /* Enables blinding mode, to prevent timing attacks */
    #define WC_RSA_BLINDING
 
    /* RSA PSS Support */
    #define WC_RSA_PSS
#else
    #define NO_RSA
#endif
 
/* DH */
#undef  NO_DH
#if !defined(CRYPTO_PROFILE_AESGCM) && !defined(CRYPTO_PROFILE_CHACHA) && !defined(CRYPTO_PROFILE_MINIMAL)
    /* Use table for DH instead of -lm (math) lib dependency */
    #if 1
        #define WOLFSSL_DH_CONST
        #define HAVE_FFDHE_2048
        //#define HAVE_FFDHE_4096
        //#define HAVE_FFDHE_6144
        //#define HAVE_FFDHE_8192
    #endif
#else
    #define NO_DH
#endif
 
/* ECC */
#undef HAVE_ECC
#if 1
    #define HAVE_ECC
 
    /* Manually define enabled curves */
    #define ECC_USER_CURVES
 
    #ifdef ECC_USER_CURVES
        /* Manual Curve Selection */
        // #define HAVE_ECC192
        // #define HAVE_ECC224
        #undef NO_ECC256
        #ifdef ENABLE_ECC384
        #define HAVE_ECC384
        #else
        /* wolfSSL 5.9.1 preferredGroup[] in tls.c gates SECP384R1 on
         * !NO_ECC384 (not on HAVE_ECC384), but TLSX_KeyShare_GenEccKey gates
         * its switch arm on HAVE_ECC384. Without explicit NO_ECC384, TLS 1.3
         * client advertises SECP384R1 then key gen returns BAD_FUNC_ARG. */
        #define NO_ECC384
        #endif
        #ifdef ENABLE_ECC521
        // #define HAVE_ECC521
        #else
        /* Same preferredGroup vs. TLSX_KeyShare_GenEccKey asymmetry as
         * NO_ECC384 above, but for SECP521R1. */
        #define NO_ECC521
        #endif
    #endif
 
    /* Fixed point cache (speeds repeated operations against same private key) */
    #define FP_ECC
    #ifdef FP_ECC
        /* Bits / Entries */
        /* FP_LUT=5: Pre-computes 32 multiples of cached ECC keys.
           Uses ~49KB heap for lookup tables. Faster repeated ECDSA signing. */
        #define FP_ENTRIES  15
        #define FP_LUT      5
    #endif
 
    /* Optional ECC calculation method */
    /* Note: doubles heap usage, but slightly faster */
    #define ECC_SHAMIR
 
    /* Reduces heap usage, but slower */
    // #define ECC_TIMING_RESISTANT
 
    /* Compressed ECC Key Support */
    //#define HAVE_COMP_KEY
 
    /* Use alternate ECC size for ECC math */
    #ifdef USE_FAST_MATH
        /* MAX ECC BITS = ROUND8(MAX ECC) * 2 */
        #if defined(NO_RSA) && defined(NO_DH)
            /* Custom fastmath size if not using RSA/DH */
            #define FP_MAX_BITS     (256 * 2)
        #else
            /* use heap allocation for ECC points */
            #define ALT_ECC_SIZE
 
            /* wolfSSL will compute the FP_MAX_BITS_ECC, but it can be overriden */
            //#define FP_MAX_BITS_ECC (256 * 2)
        #endif
 
        /* Speedups specific to curve */
        #ifndef NO_ECC256
            #define TFM_ECC256
        #endif
    #endif
#endif
 
 
/* AES */
#undef NO_AES
#if 1
    #define HAVE_AES_CBC
 
    #define HAVE_AESGCM
 
    /* GCM Method: GCM_TABLE_4BIT, GCM_SMALL, GCM_WORD32 or GCM_TABLE */
    // Listed in order of speed and memory usage
    // #define GCM_TABLE
    // #define GCM_WORD32
    /* 4-bit table: faster GCM at the cost of more memory */
    #define GCM_TABLE_4BIT
    // #define GCM_SMALL
 
    //#define WOLFSSL_AES_DIRECT
    //#define HAVE_AES_ECB
    //#define WOLFSSL_AES_COUNTER
    #define HAVE_AESCCM
#else
    #define NO_AES
#endif
 
 
/* DES3 */
#undef NO_DES3
#if !defined(CRYPTO_PROFILE_AESGCM) && !defined(CRYPTO_PROFILE_CHACHA) && !defined(CRYPTO_PROFILE_MINIMAL)
#else
    #define NO_DES3
#endif
 
/* ChaCha20 / Poly1305 */
#undef HAVE_CHACHA
#undef HAVE_POLY1305
#if !defined(CRYPTO_PROFILE_AESGCM) && !defined(CRYPTO_PROFILE_MINIMAL)
    #define HAVE_CHACHA
    #define HAVE_POLY1305
 
    /* Needed for Poly1305 */
    #define HAVE_ONE_TIME_AUTH
#endif
 
/* Ed25519 / Curve25519 */
#undef HAVE_CURVE25519
#undef HAVE_ED25519
#if !defined(CRYPTO_PROFILE_AESGCM) && !defined(CRYPTO_PROFILE_MINIMAL)
    #define HAVE_CURVE25519
    #define HAVE_ED25519 /* ED25519 Requires SHA512 */
 
    /* Optionally use small math (less flash usage, but much slower) */
    #if 0
        #define CURVED25519_SMALL
    #endif
#endif
 
 
/* ------------------------------------------------------------------------- */
/* Hashing */
/* ------------------------------------------------------------------------- */
/* Sha */
#undef NO_SHA
#if 1
    /* 1k smaller, but 25% slower */
    //#define USE_SLOW_SHA
#else
    #define NO_SHA
#endif
 
/* Sha256 */
#undef NO_SHA256
#if 1
    /* not unrolled - ~2k smaller and ~25% slower */
    //#define USE_SLOW_SHA256
 
    /* Sha224 */
    #if 0
        #define WOLFSSL_SHA224
    #endif
#else
    #define NO_SHA256
#endif
 
/* Sha512 */
#undef WOLFSSL_SHA512
#if 1
    #define WOLFSSL_SHA512
 
    /* Sha384 */
    #undef  WOLFSSL_SHA384
    #if 1
        #define WOLFSSL_SHA384
    #endif
 
    /* over twice as small, but 50% slower */
    //#define USE_SLOW_SHA512
#endif
 
/* Sha3 */
#undef WOLFSSL_SHA3
#if 0
    #define WOLFSSL_SHA3
#endif
 
/* MD5 */
#undef  NO_MD5
#if 0
 
#else
    #define NO_MD5
#endif
 
/* HKDF */
#undef HAVE_HKDF
#if 1
    #define HAVE_HKDF
#endif
 
/* CMAC */
#undef WOLFSSL_CMAC
#if 0
    #define WOLFSSL_CMAC
#endif
 
 
/* ------------------------------------------------------------------------- */
/* Benchmark / Test */
/* ------------------------------------------------------------------------- */
#ifdef TARGET_EMBEDDED
    /* Use reduced benchmark / test sizes */
    #define BENCH_EMBEDDED
#endif
 
/* Use test buffers from array (not filesystem) */
#ifndef NO_FILESYSTEM
#define USE_CERT_BUFFERS_256
#define USE_CERT_BUFFERS_2048
#endif
 
/* ------------------------------------------------------------------------- */
/* Debugging */
/* To enable, call wolfSSL_Debugging_ON(); where debug output is wanted      */
/* ------------------------------------------------------------------------- */
 
#undef DEBUG_WOLFSSL
#undef NO_ERROR_STRINGS
#if 0
    #define DEBUG_WOLFSSL
#else
    #if 0
        #define NO_ERROR_STRINGS
    #endif
#endif
 
// Prints out the TLS secrets to the console, allowing for decryption of the TLS stream
// #define SHOW_SECRETS
// #define HAVE_SECRET_CALLBACK
 
/* ------------------------------------------------------------------------- */
/* Memory */
/* ------------------------------------------------------------------------- */
 
/* TLS SRAM pool size in KB for NBMalloc allocator */
#define WOLFSSL_TLS_SRAM_KB 32
 
/* Override Memory API's */
#ifdef SSL_CUSTOM_MALLOC
    #define XMALLOC_OVERRIDE
 
    /* prototypes for user heap override functions */
    /* Note: Realloc only required for normal math */
    #include <stddef.h>  /* for size_t */
 
    extern void* NBMalloc(size_t n);
    extern void NBFree(void *p);
    extern void* NBRealloc(void *p, size_t n);
 
    #define XMALLOC(n, h, t)     NBMalloc(n)
    #define XFREE(p, h, t)       NBFree(p)
    #define XREALLOC(p, n, h, t) NBRealloc(p, n)
 
    // Platform specific fastest memory location
    #if SSL_CUSTOM_MALLOC == 1 // Fastest memory on platform
    #define CREATE_MEMORY_ALLOCATOR(name,size) CREATE_MEMORY_ALLOCATOR_SRAM(name,size)
    #define CREATE_MEMORY_BUFFER(name,size) CREATE_MEMORY_BUFFER_SRAM(name,size)
    #elif SSL_CUSTOM_MALLOC == 2
    #define CREATE_MEMORY_ALLOCATOR(name,size) CREATE_MEMORY_ALLOCATOR_TCM(name,size)
    #define CREATE_MEMORY_BUFFER(name,size) CREATE_MEMORY_BUFFER_TCM(name,size)
    #elif SSL_CUSTOM_MALLOC == 3
    #define CREATE_MEMORY_ALLOCATOR(name,size) CREATE_MEMORY_ALLOCATOR_SRAM(name,size)
    #define CREATE_MEMORY_BUFFER(name,size) CREATE_MEMORY_BUFFER_SRAM(name,size)
    #elif SSL_CUSTOM_MALLOC == 4
    #define CREATE_MEMORY_ALLOCATOR(name,size) CREATE_MEMORY_ALLOCATOR_SDRAM(name,size)
    #define CREATE_MEMORY_BUFFER(name,size) CREATE_MEMORY_BUFFER_SDRAM(name,size)
    #endif
#endif
 
#if 0
    /* Static memory requires fast math */
    #define WOLFSSL_STATIC_MEMORY
 
    /* Disable fallback malloc/free */
    #define WOLFSSL_NO_MALLOC
    #if 1
        #define WOLFSSL_MALLOC_CHECK /* trap malloc failure */
    #endif
#endif
 
/* Memory callbacks */
#if 1
    #undef  USE_WOLFSSL_MEMORY
    #define USE_WOLFSSL_MEMORY
 
    /* Use this to measure / print heap usage */
    #if 0
        #define WOLFSSL_TRACK_MEMORY
        #define WOLFSSL_DEBUG_MEMORY
    #endif
#else
    #ifndef WOLFSSL_STATIC_MEMORY
        #define NO_WOLFSSL_MEMORY
        /* Otherwise we will use stdlib malloc, free and realloc */
    #endif
#endif
 
 
/* ------------------------------------------------------------------------- */
/* Port */
/* ------------------------------------------------------------------------- */
 
/* Override Current Time */
#if 1
    /* Allows custom "custom_time()" function to be used for benchmark */
    #define WOLFSSL_USER_CURRTIME
    // #define WOLFSSL_GMTIME
    #define USER_TICKS
    #include <time.h>
    extern unsigned long my_time(time_t *timer);
    #define XTIME my_time
#endif
 
 
/* ------------------------------------------------------------------------- */
/* RNG */
/* ------------------------------------------------------------------------- */
 
/* Choose RNG method */
#if 1
    /* Custom Seed Source */
    #if 1
        /* Size of returned HW RNG value */
        #define CUSTOM_RAND_TYPE      unsigned int
        extern unsigned int my_rng_seed_gen(void);
        #undef  CUSTOM_RAND_GENERATE
        #define CUSTOM_RAND_GENERATE  my_rng_seed_gen
    #endif
 
    // NetBurner specific define for enabling hardware random number generation for M7
    #define GATHER_RANDOM_USE_HW
 
    /* Use built-in P-RNG (SHA256 based) with HW RNG */
    /* P-RNG + HW RNG (P-RNG is ~8K) */
    #undef  HAVE_HASHDRBG
    #define HAVE_HASHDRBG
#else
    #undef  WC_NO_HASHDRBG
    #define WC_NO_HASHDRBG
 
    /* Bypass P-RNG and use only HW RNG */
    extern int my_rng_gen_block(unsigned char* output, unsigned int sz);
    #undef  CUSTOM_RAND_GENERATE_BLOCK
    #define CUSTOM_RAND_GENERATE_BLOCK  my_rng_gen_block
#endif
 
 
/* ------------------------------------------------------------------------- */
/* Custom Standard Lib */
/* ------------------------------------------------------------------------- */
/* Allows override of all standard library functions */
#undef STRING_USER
#if 0
    #define STRING_USER
 
    #include <string.h>
 
    #define USE_WOLF_STRSEP
    #define XSTRSEP(s1,d)     wc_strsep((s1),(d))
 
    #define USE_WOLF_STRTOK
    #define XSTRTOK(s1,d,ptr) wc_strtok((s1),(d),(ptr))
 
    #define XSTRNSTR(s1,s2,n) mystrnstr((s1),(s2),(n))
 
    #define XMEMCPY(d,s,l)    memcpy((d),(s),(l))
    #define XMEMSET(b,c,l)    memset((b),(c),(l))
    #define XMEMCMP(s1,s2,n)  memcmp((s1),(s2),(n))
    #define XMEMMOVE(d,s,l)   memmove((d),(s),(l))
 
    #define XSTRLEN(s1)       strlen((s1))
    #define XSTRNCPY(s1,s2,n) strncpy((s1),(s2),(n))
    #define XSTRSTR(s1,s2)    strstr((s1),(s2))
 
    #define XSTRNCMP(s1,s2,n)     strncmp((s1),(s2),(n))
    #define XSTRNCAT(s1,s2,n)     strncat((s1),(s2),(n))
    #define XSTRNCASECMP(s1,s2,n) strncasecmp((s1),(s2),(n))
 
    #define XSNPRINTF snprintf
#endif
 
 
 
/* ------------------------------------------------------------------------- */
/* Enable Features */
/* ------------------------------------------------------------------------- */
 
#ifdef SSL_TLS_1_3_SUPPORT // defined in predef.h
#define WOLFSSL_TLS13
/* OPTIMIZATION: 0-RTT for faster TLS 1.3 session resumption */
#define WOLFSSL_EARLY_DATA
#endif
/* Non-default profiles disable TLS 1.2 for smaller footprint */
#if defined(CRYPTO_PROFILE_AESGCM) || defined(CRYPTO_PROFILE_CHACHA) || defined(CRYPTO_PROFILE_MINIMAL)
#define WOLFSSL_NO_TLS12
#endif
#define WOLFSSL_OLD_PRIME_CHECK /* Use faster DH prime checking */
#define HAVE_TLS_EXTENSIONS
#define HAVE_SUPPORTED_CURVES
#define WOLFSSL_BASE64_ENCODE
 
 
#define WOLFSSL_KEY_GEN /* For RSA Key gen only */
#define KEEP_PEER_CERT
//#define HAVE_COMP_KEY
 
/* TLS Session Cache */
#if 1
    #define SMALL_SESSION_CACHE
    #define NO_SESSION_CACHE_REF
#else
    #define NO_SESSION_CACHE
#endif
 
#define HAVE_ONE_TIME_AUTH
#define HAVE_SNI
#define HAVE_SESSION_TICKET
/* OPTIMIZATION: Smaller certificate verification code path */
#define WOLFSSL_SMALL_CERT_VERIFY
 
// Allows WolfSSL to malloc the tls 1.3 ticket nonce, instead of using a static buffer. This supports large ticket nonces
#define WOLFSSL_TICKET_NONCE_MALLOC
 
/* ------------------------------------------------------------------------- */
/* Disable Features */
/* ------------------------------------------------------------------------- */
//#define NO_WOLFSSL_SERVER
//#define NO_WOLFSSL_CLIENT
//#define NO_CRYPT_TEST
//#define NO_CRYPT_BENCHMARK
//#define WOLFCRYPT_ONLY
 
/* In-lining of misc.c functions */
/* If defined, must include wolfcrypt/src/misc.c in build */
/* Slower, but about 1k smaller */
//#define NO_INLINE
 
#define WOLFSSL_NO_SOCK
#define NO_WOLFSSL_DIR
 
#ifdef TARGET_EMBEDDED
    #define NO_FILESYSTEM
    #define NO_WRITEV
    #define NO_MAIN_DRIVER
    #define NO_DEV_RANDOM
#endif
 
#define NO_OLD_TLS
#define NO_PSK
 
#define NO_DSA
// #define NO_RC4
#define NO_MD4
#define NO_PWDBASED
//#define NO_CODING
//#define NO_ASN_TIME
//#define NO_CERTS
//#define NO_SIG_WRAPPER
 
#define NO_HC128
#define NO_RABBIT
 
#define WOLFSSL_IGNORE_FILE_WARN
 
#undef NO_TLS
 
#if !defined(CRYPTO_PROFILE_AESGCM) && !defined(CRYPTO_PROFILE_CHACHA) && !defined(CRYPTO_PROFILE_MINIMAL)
// Settings made for TLS 1.2 backward compatibility
#define WOLFSSL_STATIC_RSA   // Needed to support TLS_RSA_WITH_AES_128_CBC_SHA
#define WOLFSSL_STATIC_DH    // Needed to support TLS_ECDH_ECDSA_WITH_RC4_128_SHA
#endif
#define WOLFSSL_AES_128      // Needed to support TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA256
#define WOLFSSL_AES_256      // Needed to support TLS_RSA_WITH_AES_256_CBC_SHA256
 
#define WOLFSSL_CERT_REQ
#define WOLFSSL_CERT_GEN
#define WOLFSSL_ALT_NAMES
#define WOLFSSL_DER_TO_PEM
#define WOLFSSL_KEY_GEN
#define WOLFSSL_EITHER_SIDE
 
#define ENABLE_ECCKEY_CREATE   // Custom define, maybe should move to predef?
#define ENABLE_RSAKEY_CREATE   // Custom define, maybe should move to predef?
 
    // For wolfSSH
    //#undef WOLFSSH_SFTP
    //#define WOLFSSH_SFTP
 
    //#undef WOLFSSH_SCP
    //#define WOLFSSH_SCP
 
#undef WOLFSSH_USER_IO
#define WOLFSSH_USER_IO
 
#ifdef __cplusplus
}
#endif
 
#endif /* WOLFSSL_USER_SETTINGS_H */