#ifndef WOLFSSL_USER_SETTINGS_H
#define WOLFSSL_USER_SETTINGS_H

/* If TARGET_EMBEDDED is defined then small target settings are used */
#if !(defined(__MACH__) || defined(__FreeBSD__) || defined(__linux__) || defined(_WIN32))
    #define TARGET_EMBEDDED
#endif

/* ------------------------------------------------------------------------- */
/* Platform */
/* ------------------------------------------------------------------------- */
#define WOLFSSL_GENERAL_ALIGNMENT 4
#define SIZEOF_LONG_LONG 8
#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 IO callbacks with wolfSSL_CTX_SetIORecv/wolfSSL_CTX_SetIOSend
     */
    #define WOLFSSL_USER_IO
#endif
/* ------------------------------------------------------------------------- */
/* Math Configuration */
/* ------------------------------------------------------------------------- */
/* Wolf Single Precision Math */
#if 0
......
#elif 1
    /* Fast Math (tfm.c) (stack based and timing resistant) */
    #define USE_FAST_MATH
    #define TFM_TIMING_RESISTANT
#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
#endif

/* ------------------------------------------------------------------------- */
/* Hashing */
/* ------------------------------------------------------------------------- */
/* Sha256 */
#undef NO_SHA256
#if 1
    /* not unrolled - ~2k smaller and ~25% slower */
    #define USE_SLOW_SHA256
#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

    #ifndef WOLFSSL_STATIC_MEMORY
        #define NO_WOLFSSL_MEMORY

/* ------------------------------------------------------------------------- */
/* Custom Standard Lib */
/* ------------------------------------------------------------------------- */
/* Allows override of all standard library functions */
#undef STRING_USER

/* ------------------------------------------------------------------------- */
/* Enable Features */
/* ------------------------------------------------------------------------- */

//#define WOLFSSL_TLS13
//#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 0
    #define SMALL_SESSION_CACHE
#else
    #define NO_SESSION_CACHE
#endif


/* ------------------------------------------------------------------------- */
/* Disable Features */
/* ------------------------------------------------------------------------- */
//#define NO_WOLFSSL_SERVER
//#define NO_WOLFSSL_CLIENT
//#define NO_CRYPT_TEST
//#define NO_CRYPT_BENCHMARK
#define WOLFCRYPT_ONLY

/* do not warm when file is included to be built and not required to be */
#define WOLFSSL_IGNORE_FILE_WARN

/* In-lining of misc.c functions */
/* If defined, must include wolfcrypt/src/misc.c in build */
/* Slower, but about 1k smaller */
//#define NO_INLINE

#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

#include <wolfssl/wolfcrypt/signature.h>
#include <wolfssl/wolfcrypt/rsa.h>
#include <wolfssl/wolfcrypt/asn.h>
#include <wolfcrypt/test/test.h>

/* macros */
/* size in bytes */
#define SIG_BUFF_SIZE 128 //1024bits
#define DATA_SIZE 8
#define KEY_SIZE 1024 //bits
#define WC_RSA_EXPONENT 65537L
#define FOURK_BUF 4096

#define HEAP_HINT NULL

/* const */
const enum wc_HashType hash_type = WC_HASH_TYPE_SHA256;
const enum wc_SignatureType sig_type = WC_SIGNATURE_TYPE_RSA;
const byte data[DATA_SIZE] = "testsig!";

int main() {
    int ret;
    RsaKey pub_rsa;
    word32 idx = 0;

    /**********************************************************/
    /*                     Initializing                       */
    /**********************************************************/
    ret = wc_InitRsaKey(&pub_rsa, NULL);
    if (ret != 0) {
        // error initializing RSA key
    }

    /**********************************************************/
    /*              Key convert from .der file                */
    /**********************************************************/
    /* From text */
    byte pub_rsa_der[FOURK_BUF] = {
            0x30, 0x81, ......};
    ret = wc_RsaPublicKeyDecode(pub_rsa_der, &idx, &pub_rsa, 162);

    /**********************************************************/
    /*                Signature veritication                  */
    /**********************************************************/
    byte sig[SIG_BUFF_SIZE] = {
        0x9C, 0x3D,...... };
    word32 sig_len = 128;
    ret = wc_SignatureVerify(hash_type, sig_type, data, DATA_SIZE, sig, sig_len, &pub_rsa, sizeof(pub_rsa));
    if (ret != 0) {
        // error verification
    }

    /**********************************************************/
    /*                 Release space for key                  */
    /**********************************************************/
    wc_FreeRsaKey(&pub_rsa);
    ret = wc_InitRsaKey(&pub_rsa, HEAP_HINT);
    if (ret != 0) {
        // error initializing RSA key
    }
}

.\obj\ciphers.axf: Error: L6218E: Undefined symbol time (referred from asn.o).

if (ret == MP_EXPTMOD_E) {
            /* This can happen due to incorrectly set FP_MAX_BITS or missing XREALLOC */
            WOLFSSL_MSG("RSA_FUNCTION MP_EXPTMOD_E: memory/config problem");
        }

    /* idea to add global alloc override by Moises Guimaraes  */
    /* default to libc stuff */
    /* XREALLOC is used once in normal math lib, not in fast math lib */
    /* XFREE on some embedded systems doesn't like free(0) so test  */
    #if defined(HAVE_IO_POOL)
        WOLFSSL_API void* XMALLOC(size_t n, void* heap, int type);
        WOLFSSL_API void* XREALLOC(void *p, size_t n, void* heap, int type);
        WOLFSSL_API void XFREE(void *p, void* heap, int type);

static int RsaFunctionSync(......){
        ......
        case RSA_PUBLIC_DECRYPT:
            if (mp_exptmod_nct(tmp, &key->e, &key->n, tmp) != MP_OKAY)
                ret = MP_EXPTMOD_E;
            break;