/**
 * @file ax_a71chEngine.c
 * @author NXP Semiconductors
 * @version 1.0
 * @par License
 *
 * Copyright 2017,2020 NXP
 * SPDX-License-Identifier: Apache-2.0
 *
 * @par Description
 * OpenSSL Engine for Embedded Secure Element (A71CH)
 *
 * This engine invokes the API of axHostSw/a71ch that wraps APDU communication
 * with the A71CH secure element.
 *
 * The following operations are supported by this engine:
 * - Random number generation
 * - ECC sign
 * - ECC verify
 * - ECDH compute_key
 *
 * When dealing with an EC key argument whose a public key is used:
 * - In case the key is a 'reference key' -> use the referenced public key
 * - In case the public key is passed by value and it matches the value of a public key
 *   stored in the Secure Element -> delegate the operation to the Secure Element
 * - If none of the two above cases apply; at compile time one can choose between two
 *   strategies:
 *   (1) return a fail
 *   (2) delegate the operation to the OpenSSL SW implementation
 *
 * When dealing with an EC key argument whose private key is used:
 * - In case the key is a 'reference key' -> use the referenced private key
 * - In case the above does not apply; at compile time one can choose between two
 *   strategies:
 *   (1) return a fail
 *   (2) delegate the operation to the OpenSSL SW implementation
 *
 * @note
 *   Compatible with:
 *   - OpenSSL 1.0.2
 *   - OpenSSL 1.1.0
 *
 */

/*
 * This file contains source code form OpenSSL distribution that is covered
 * by the LICENSE-OpenSSL file to be found in the root of this source code
 * distribution tree.
 */

#include "ax_embSeEngine.h"
#include "ax_cryptoIpc.h"
#include <openssl/bn.h>
// #include <openssl/conf.h>
#include <openssl/evp.h>
#include <openssl/ec.h>
#include <openssl/ecdsa.h>
#include <openssl/err.h>
#include <openssl/ec.h>
#include <openssl/crypto.h>
#include <openssl/rand.h>
#include <stdlib.h>
#if !defined(OPENSSL_SYS_MACOSX)
#include <malloc.h>
#endif
#include "ax_api.h"
#include "ax_embSeEngine_Internal.h"
#include "fsl_sscp_a71ch.h"
#include "sm_printf.h"
#include "nxLog_App.h"
#include "nxEnsure.h"

#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
#else
#ifdef OPENSSL_NO_DYNAMIC_ENGINE
#undef OPENSSL_NO_DYNAMIC_ENGINE
#endif
#endif

// <Conditionally activate features at compile time>
#define PRIVATE_KEY_HANDOVER_TO_SW
#define PUBLIC_KEY_HANDOVER_TO_SW
// </Conditionally activate features at compile time>

/* Define ECDH secret key size */
#define ECDH_MAX_LEN        32

#define EMBSE_MAX_ECC_PUBKEY_BUF   (2*96 + 1)  // Corresponds to 768 bit ECC key

/* Maximum Key Index supported by the A70CM SE */
#define EMBSE_A70CM_MAX_PUBLIC_KEY_INDEX 2

/* Logging related defines */
#define EMBSE_MAX_PRINT_BUF_SIZE    (511)

#define LOG_FLOW_MASK 0x01
#define LOG_DBG_MASK  0x02
#define LOG_ERR_MASK  0x04

#define LOG_FLOW_ON 0x01
#define LOG_DBG_ON  0x02
#define LOG_ERR_ON  0x04

// Adjust to the required default log level.
static int EMBSE_LogControl = (LOG_ERR_ON | LOG_DBG_ON | LOG_FLOW_ON);  // Full log
// static int EMBSE_LogControl = (LOG_ERR_ON);  // Only Errors

static axKeyIdentifier_t eccSigningKeys[] = {
    {A71CH_SSI_KEY_PAIR, A71CH_KEY_PAIR_0},
    {A71CH_SSI_KEY_PAIR, A71CH_KEY_PAIR_1},
    {A71CH_SSI_KEY_PAIR, A71CH_KEY_PAIR_2},
    {A71CH_SSI_KEY_PAIR, A71CH_KEY_PAIR_3}
};

static axKeyIdentifier_t eccVerifyKeys[] = {
    {A71CH_SSI_PUBLIC_KEY, A71CH_PUBLIC_KEY_0},
    {A71CH_SSI_PUBLIC_KEY, A71CH_PUBLIC_KEY_1},
    {A71CH_SSI_PUBLIC_KEY, A71CH_PUBLIC_KEY_2}
};

static axKeyIdentifier_t eccDhStaticKeys[] = {
    {A71CH_SSI_KEY_PAIR, A71CH_KEY_PAIR_0},
    {A71CH_SSI_KEY_PAIR, A71CH_KEY_PAIR_1},
    {A71CH_SSI_KEY_PAIR, A71CH_KEY_PAIR_2},
    {A71CH_SSI_KEY_PAIR, A71CH_KEY_PAIR_3}
};

// Locally used utility functions
static U16 getEcKeyReference(const EC_KEY *eckey, axKeyIdentifier_t *validKeys, int nKeys,
                             SST_Identifier_t *ident, SST_Index_t *idx);
static U16 axAdaptSize(U8* pOut, U16 expectedLen, const U8 *pIn, U16 actualLen);
static void EmbSe_Print(int flag, const char * format, ...);
static void EmbSe_PrintPayload(int flag, const U8 *pPayload, U16 nLength, const char *title);
static U16 EmbSe_A70Init(void);

/* engine name */
static const char *embSe_id = OPENSSL_ENGINE_EMBSE_ID;
static const char *embSe_name = "se hardware engine support";

/* Random Num Status, used when Get Rand Status is invoked */
unsigned short gRandStatus = 1;

const int Version1 = 1;  //-> Release Version1.Version2.Version3
const int Version2 = 0;
const int Version3 = 1;

/* ecdsa_method struct definition from */
struct ecdsa_method
{
    const char *name;
    ECDSA_SIG *(*ecdsa_do_sign)(const unsigned char *dgst, int dgst_len,
            const BIGNUM *inv, const BIGNUM *rp, EC_KEY *eckey);
    int (*ecdsa_sign_setup)(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
            BIGNUM **r);
    int (*ecdsa_do_verify)(const unsigned char *dgst, int dgst_len,
            const ECDSA_SIG *sig, EC_KEY *eckey);
#if 0
    int (*init)(EC_KEY *eckey);
    int (*finish)(EC_KEY *eckey);
#endif
    int flags;
    char *app_data;
};

/* ecdh_method struct definition from ech_locl.h*/
struct ecdh_method
{
    const char *name;
    int (*compute_key)(void *key, size_t outlen, const EC_POINT *pub_key, EC_KEY *ecdh,
    void *(*KDF)(const void *in, size_t inlen, void *out, size_t *outlen));
#if 0
    int (*init)(EC_KEY *eckey);
    int (*finish)(EC_KEY *eckey);
#endif
    int flags;
    char *app_data;
};

/* Engine API Declaration */
static int EmbSe_Rand(unsigned char *buf, int num);
static int EmbSe_Rand_Status(void);

static ECDSA_SIG *EmbSe_ECDSA_Do_Sign(const unsigned char *dgst, int dgst_len,
        const BIGNUM *inv, const BIGNUM *rp, EC_KEY *eckey);
static int EmbSe_ECDSA_Sign_Setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
        BIGNUM **r);
static int EmbSe_ECDSA_Do_Verify(const unsigned char *dgst, int dgst_len,
        const ECDSA_SIG *sig, EC_KEY *eckey);

#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
static int EmbSe_Compute_Key(void *sh_secret,
    size_t sec_len,
    const EC_POINT *pub_key,
    EC_KEY *ecdh,
    void *(*KDF)(const void *in, size_t inlen, void *out, size_t *outlen));
#else
static int EmbSe_Simple_Compute_Key(unsigned char **pout,
    size_t *poutlen,
    const EC_POINT *pub_key,
    const EC_KEY *ecdh);
static int EmbSe_Simple_Key_gen(EC_KEY *key);
#endif

/* Fill in implemented Engine methods in respective data structures */
static RAND_METHOD EmbSe_RAND =
{
    NULL,               /* RAND_seed() */
    EmbSe_Rand,         /* RAND_bytes() */
    NULL,               /* RAND_cleanup() */
    NULL,               /* RAND_add() */
    EmbSe_Rand,         /* RAND_pseudo_rand() */
    EmbSe_Rand_Status   /* RAND_status() */
};

#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
static ECDSA_METHOD EmbSe_ECDSA = {
    "e2se_ecdsa",
    *EmbSe_ECDSA_Do_Sign,
    EmbSe_ECDSA_Sign_Setup,
    EmbSe_ECDSA_Do_Verify,
    0,
    NULL
};

static ECDH_METHOD EmbSe_ECDH = {
    "e2se_ecdh",
    *EmbSe_Compute_Key,
    0,
    NULL
};
#else
// Renamed 'ossl_ecdsa_sign' from openssl-1.1.0j/crypto/ec/ecdsa_ossl.c
static int my_ossl_ecdsa_sign(int type, const unsigned char *dgst, int dlen,
                    unsigned char *sig, unsigned int *siglen,
                    const BIGNUM *kinv, const BIGNUM *r, EC_KEY *eckey)
{
    ECDSA_SIG *s;
    int rv = 0;

    ENSURE_OR_GO_EXIT(siglen != NULL);
    RAND_seed(dgst, dlen);
    s = ECDSA_do_sign_ex(dgst, dlen, kinv, r, eckey);
    if (s == NULL) {
        *siglen = 0;
        return 0;
    }
    *siglen = i2d_ECDSA_SIG(s, &sig);
    ECDSA_SIG_free(s);
    rv = 1;
exit:
    return rv;
}

// Renamed 'ossl_ecdsa_verify' from openssl-1.1.0j/crypto/ec/ecdsa_ossl.c
static int my_ossl_ecdsa_verify(int type, const unsigned char *dgst, int dgst_len,
                      const unsigned char *sigbuf, int sig_len, EC_KEY *eckey)
{
    ECDSA_SIG *s;
    const unsigned char *p = sigbuf;
    unsigned char *der = NULL;
    int derlen = -1;
    int ret = -1;

    s = ECDSA_SIG_new();
    if (s == NULL)
        return (ret);
    if (d2i_ECDSA_SIG(&s, &p, sig_len) == NULL)
        goto err;
    /* Ensure signature uses DER and doesn't have trailing garbage */
    derlen = i2d_ECDSA_SIG(s, &der);
    if (derlen != sig_len || memcmp(sigbuf, der, derlen) != 0)
        goto err;
    ret = ECDSA_do_verify(dgst, dgst_len, s, eckey);
 err:
    OPENSSL_clear_free(der, derlen);
    ECDSA_SIG_free(s);
    return (ret);
}

static EC_KEY_METHOD *EmbSe_EC = NULL;
static EC_KEY_METHOD *EmbSe_EC_Default = NULL;
static int setup_ec_key_method(void) {
    EmbSe_EC_Default = (EC_KEY_METHOD *)EC_KEY_get_default_method();
    EmbSe_EC = EC_KEY_METHOD_new(NULL);
    if (EmbSe_EC == NULL) {
        return 0;
    }
    // NOTE: Equivalent of set_name does not exist for OpenSSL 1.1
    // EC_KEY_METHOD_set_name(EmbSe_EC, "e2se_ecdsa");
    EC_KEY_METHOD_set_sign(EmbSe_EC, my_ossl_ecdsa_sign, EmbSe_ECDSA_Sign_Setup, EmbSe_ECDSA_Do_Sign);
    EC_KEY_METHOD_set_verify(EmbSe_EC, my_ossl_ecdsa_verify, EmbSe_ECDSA_Do_Verify);
    EC_KEY_METHOD_set_compute_key(EmbSe_EC, EmbSe_Simple_Compute_Key);
    EC_KEY_METHOD_set_keygen(EmbSe_EC, EmbSe_Simple_Key_gen);
    return 1;
}
#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)

#ifndef OPENSSL_NO_HW

/* The definitions for control commands specific to this engine */
#define EMBSE_LOG_LEVEL   ENGINE_CMD_BASE
#define EMBSE_CMD_SO_PATH (ENGINE_CMD_BASE + 1)

static const ENGINE_CMD_DEFN embSe_cmd_defns[] = {
    {EMBSE_LOG_LEVEL,
        "LOG_LEVEL",
        "Specifies the Log level (Error=0x04; Debug=0x02; Flow=0x01; Or'd combinations possible)",
        ENGINE_CMD_FLAG_NUMERIC},
    {EMBSE_CMD_SO_PATH,
        "SO_PATH",
        "Specifies the path to the 'e2se ssl' shared library (not implemented)",
        ENGINE_CMD_FLAG_STRING},
    {0, NULL, NULL, 0}
};

/* Engine API's for initialization and cleanup */
static int EmbSe_Destroy(ENGINE *e)
{
    AX_UNUSED_ARG(e);
    EmbSe_Print(LOG_FLOW_ON, "EmbSe_Destroy(): Entry\n");
    return 1;
}


/****** ENGINE API's *******/
static int EmbSe_Init(ENGINE *e)
{
    U16 sw = 0;

    AX_UNUSED_ARG(e);
    /* Initialize the Engine Mutex */
    CryptoIpc_MutexInit(AX_CI_TRUE);
    sw = EmbSe_A70Init();
    if (sw != SW_OK)
    {
        EmbSe_Print(LOG_ERR_ON, "Call to EmbSe_A70Init() failed with return code 0x%04X\n", sw);
        return -1;
    }
    EmbSe_Print(LOG_FLOW_ON, "Version: %d.%d.%d\n", Version1, Version2, Version3);
#ifdef __gnu_linux__
    mallopt(M_MMAP_THRESHOLD, 125);
#endif
    /* Engine is ready to use */
    return 1;
}

static int EmbSe_Finish(ENGINE *e)
{
    AX_UNUSED_ARG(e);
    SM_Close(NULL, SMCOM_CLOSE_MODE_STD);
    EmbSe_Print(LOG_FLOW_ON, "EmbSe_Finish(): Entry\n");
    return 1;
}

static int EmbSe_Ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void))
{
    AX_UNUSED_ARG(e);
    /* Values of String Variables are received in p, while values of Numeric ones are in i */
    switch(cmd)
    {
        case EMBSE_LOG_LEVEL:
            EmbSe_Print(LOG_FLOW_ON, "Control Command EMBSE_LOG_LEVEL; requested log level = %ld\n", i);
            if (i < 0x08)
            {
                EMBSE_LogControl = i & 0x07;
            }
            else
            {
                EmbSe_Print(LOG_DBG_ON, "Invalid Control Command value for EMBSE_LOG_LEVEL\n");
            }
            return 1;
        case EMBSE_CMD_SO_PATH:
            EmbSe_Print(LOG_ERR_ON, "Control command EMBSE_CMD_SO_PATH has not been implemented.\n");
            return 0;
        default:
            break;
    }
    return 0;
}

/* This internal function is used by ENGINE_e2se() and possibly by the
 * "dynamic" ENGINE support too */
static int bind_helper(ENGINE *e)
{
    if (!ENGINE_set_id(e, embSe_id) ||
            !ENGINE_set_name(e, embSe_name) ||
            !ENGINE_set_destroy_function(e, &EmbSe_Destroy) ||
            !ENGINE_set_init_function(e, &EmbSe_Init) ||
            !ENGINE_set_finish_function(e, &EmbSe_Finish) ||
            !ENGINE_set_ctrl_function(e, &EmbSe_Ctrl) ||
            !ENGINE_set_cmd_defns(e, &embSe_cmd_defns[0]) ||
            !ENGINE_set_RAND(e, &EmbSe_RAND) ||
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
            !ENGINE_set_ECDSA(e, &EmbSe_ECDSA) ||
            !ENGINE_set_ECDH(e, &EmbSe_ECDH))
#else
        !setup_ec_key_method() ||
        !ENGINE_set_EC(e, EmbSe_EC))
#endif
    {
        return 0;
    }

    return 1;
}

#ifdef OPENSSL_NO_DYNAMIC_ENGINE
static ENGINE *EngineEmbSe(void)
{
    ENGINE *ret = ENGINE_new();
    if (!ret)
    {
        return NULL;
    }
    if (!bind_helper(ret))
    {
        ENGINE_free(ret);
        return NULL;
    }
    return ret;
}

void EngineEmbSe_Load(void)
{
    /* Copied from eng_[openssl|dyn].c */
    ENGINE *toadd = EngineEmbSe();
    if (!toadd) return;
    ENGINE_add(toadd);
    ENGINE_free(toadd);
    ERR_clear_error();
    EmbSe_Print(LOG_FLOW_ON, "EngineEmbSe_Load succeeded!\n");
}
#else
/* This stuff is needed if this ENGINE is being compiled into a self-contained
 * shared-library. */
static int bind_fn(ENGINE *e, const char *id)
{
    if (id && (strcmp(id, embSe_id) != 0))
        return 0;
    if (!bind_helper(e))
        return 0;
    return 1;
}
IMPLEMENT_DYNAMIC_CHECK_FN()
IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
#endif /* OPENSSL_NO_DYNAMIC_ENGINE */
#endif /* !OPENSSL_NO_HW */


#define MAX_RND_CHUNK A71CH_SCP03_MAX_PAYLOAD_SIZE
 /**
 * Implementation of Engine API for Random Number Generation. Invokes Host API RND_GetRandom
 * @param[in,out] buf   buffer to store the generated Random Number
 * @param[in]     num   number of random bytes requested
 * @retval  0 upon failure
 * @retval  1 upon success
 */
static int EmbSe_Rand(unsigned char *buf, int num)
{
    U16 sw = ERR_GENERAL_ERROR;
    int requested = 0;
    int offset = 0;
    int chunk = 0;
    EmbSe_Print(LOG_FLOW_ON, "EmbSe_Rand invoked requesting %d random bytes\n", num);
    memset(buf,0,num);
    CryptoIpc_MutexLock();
    requested = num;
    while (requested > 0)
    {
        if (requested > MAX_RND_CHUNK)
        {
            chunk = MAX_RND_CHUNK;
        }
        else
        {
            chunk = requested;
        }
        sw = A71_GetRandom (buf+offset, chunk);
        if (sw != SW_OK) {
            break;
        }
        offset += chunk;
        requested -= chunk;
    }
    CryptoIpc_MutexUnlock();
    gRandStatus = sw;

    if (sw == SW_OK)
    {
        return 1;
    }
    else
    {
        EmbSe_Print(LOG_ERR_ON, "Call to RND_GetRandom failed with 0x%04X\n", sw);
        return 0;
    }
}

/**
* @function EmbSe_Rand_Status
* @description Engine API to return the status from invocation of RND_GetRandom()
* @param void
* @return value U16 of previous RND_GetRandom() API.
*/
static int EmbSe_Rand_Status(void)
{
     EmbSe_Print(LOG_FLOW_ON, "EmbSe_Rand_Status invoked\n");
     return (int)gRandStatus;
}


// EmbSe RSA API's
/* Size of an SSL signature: MD5+SHA1 */
#define SSL_SIG_LENGTH  36


// EmbSE ECDSA Implementation
// --------------------------
static ECDSA_SIG *EmbSe_ECDSA_Do_Sign(const unsigned char *dgst, int dgst_len,
        const BIGNUM *inv, const BIGNUM *rp, EC_KEY *eckey)
{
    U8 sigDER[256];
    U16 sigDERLen = sizeof(sigDER);
    U16 sw;
    ECDSA_SIG *pSig;
    EC_KEY *dup_eckey = NULL;
    U8 *pp;
    SST_Identifier_t ident;
    SST_Index_t idx;
    U8 dgstBuf[32];
    U16 dgstBufLen = sizeof(dgstBuf);

    sw = getEcKeyReference(eckey, eccSigningKeys, sizeof(eccSigningKeys)/sizeof(axKeyIdentifier_t),
        &ident, &idx);
    if (sw == SW_OK)
    {
        EmbSe_Print(LOG_FLOW_ON, "ECC_Sign(ident=%d, idx=%d; dgstLen=%d)\n", ident, idx, dgst_len);
        axAdaptSize(dgstBuf, dgstBufLen, dgst, dgst_len);
        CryptoIpc_MutexLock();
        sw = A71_EccSign(idx, (const U8*)dgstBuf, dgstBufLen, (U8*)sigDER, (U16*)&sigDERLen);
        CryptoIpc_MutexUnlock();
        if (sw != SW_OK)
        {
            EmbSe_Print(LOG_ERR_ON, "SE signature creation error: 0x%04X.\n", sw);
            return NULL;
        }
        EmbSe_Print(LOG_FLOW_ON, "A71_EccSign called successfully: sigDERLen=%d\n", sigDERLen);

        /* sig is DER encoded. Transform to ECDSA_SIG and return this */
        pp = (U8*)sigDER;
        pSig = ECDSA_SIG_new();

        if (pSig == NULL)
        {
            EmbSe_Print(LOG_ERR_ON, "ECDSA_SIG_new call failed\n");
            return NULL;
        }

        if (d2i_ECDSA_SIG((ECDSA_SIG**)&pSig, (const unsigned char**)&pp, sigDERLen)  == NULL)
        {
            EmbSe_Print(LOG_ERR_ON, "d2i_ECDSA_SIG failed\n");
            return NULL;
        }
        EmbSe_Print(LOG_FLOW_ON, "EmbSe_ECDSA_Do_Sign success.\n");
        return pSig;
    }
    else if (sw == ERR_IDENT_IDX_RANGE)
    {
        EmbSe_Print(LOG_ERR_ON, "Reference Key with identifier or index out of range: 0x%04X.\n", sw);
        return NULL;
    }
    else if (sw == ERR_NO_PRIVATE_KEY)
    {
        EmbSe_Print(LOG_ERR_ON, "Expecting private key (by value or reference): 0x%04X.\n", sw);
        return NULL;
    }
    else if (sw == ERR_PATTERN_COMPARE_FAILED)
    {
#ifdef PRIVATE_KEY_HANDOVER_TO_SW
        // Invoke OpenSSL sign API if no valid key reference is detected
        EmbSe_Print(LOG_FLOW_ON,"No matching key in A71CH. Invoking OpenSSL API: ECDSA_do_sign_ex.\n");
        /* Create a duplicate key */
        dup_eckey = EC_KEY_dup(eckey);
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
        /* Attach OpenSSL's SW method to duplicate key */
        if (!ECDSA_set_method(dup_eckey, ECDSA_OpenSSL())) {
            EmbSe_Print(LOG_ERR_ON, "OpenSSL ECDSA_set_method failure..\n");
            return NULL;
        }
#else
        /* Attach OpenSSL's SW method to duplicate key */
        if (!EC_KEY_set_method(dup_eckey, EC_KEY_OpenSSL())) {
            EmbSe_Print(LOG_ERR_ON, "OpenSSL EC_KEY_set_method failure..\n");
            return NULL;
        }
#endif
        /* Invoke OpenSSL's sign API and return result */
        return ECDSA_do_sign_ex(dgst, dgst_len, inv, rp, dup_eckey);
#else
        EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Sign expected a reference key: 0x%04X.\n", sw);
        return NULL;
#endif
    }
    else
    {
        EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Sign unexpected key type: 0x%04X.\n", sw);
        return NULL;
    }
}

static int EmbSe_ECDSA_Sign_Setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
        BIGNUM **r)
{
    return 1;
}

static int EmbSe_ECDSA_Do_Verify(const unsigned char *dgst, int dgst_len,
        const ECDSA_SIG *sig, EC_KEY *eckey)
{
    U16 sw;
    U8 retval = 0;
    int nRet = 0;
    int i;
    int flagHandleKey = AX_ENGINE_INVOKE_NOTHING;
    EC_KEY *dup_eckey = NULL;
    U8 *pSignatureDER, *pSigTmp;
    U16 sigLen;
    SST_Identifier_t ident;
    SST_Index_t idx;
    size_t pub_key_len;
    const EC_POINT *pub_key_point;
    U8 refPub[EMBSE_MAX_ECC_PUBKEY_BUF];

    EmbSe_Print(LOG_FLOW_ON, "Invoking EmbSe_ECDSA_Do_Verify(..)\n");

    if (!eckey)
    {
        EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Verify: No EC Key provided as input.\n");
        return -1;
    }
    if (!sig)
    {
        EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Verify: No signature provided as input.\n");
        return -1;
    }

    /* Convert ECDSA_SIG to DER and print */
    sigLen = i2d_ECDSA_SIG((ECDSA_SIG*)sig, NULL);
    if (sigLen != 0)
    {
        pSignatureDER = (U8*)OPENSSL_malloc(sigLen);
        pSigTmp = pSignatureDER;
        // The pointer passed as second argument will point past the end of the returned signature
        // upon return. Which explains pointer copy operation before the call.
        i2d_ECDSA_SIG((ECDSA_SIG*)sig, &pSigTmp);
    }
    else
    {
        EmbSe_Print(LOG_ERR_ON, "Call to i2d_ECDSA_SIG failed\n");
        return -1;
    }
    EmbSe_Print(LOG_DBG_ON, "====>SIGNATURE (len=%d)\n", sigLen);
    EmbSe_PrintPayload(LOG_DBG_ON, pSignatureDER, sigLen, "");
    EmbSe_PrintPayload(LOG_DBG_ON, dgst, dgst_len, "====>DIGEST");

    sw = getEcKeyReference(eckey, eccVerifyKeys, sizeof(eccVerifyKeys)/sizeof(axKeyIdentifier_t),
        &ident, &idx);
    if (sw == SW_OK)
    {
        flagHandleKey = AX_ENGINE_INVOKE_SE;
    }
    else if ( (sw == ERR_NO_PRIVATE_KEY) || (sw == ERR_PATTERN_COMPARE_FAILED) )
    {
        // Check whether the public key passed by value matches one of
        // the provisioned public keys.

        /* Extract public key */
        pub_key_point = EC_KEY_get0_public_key(eckey);
        if (!pub_key_point)
        {
            EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Verify: EC Key public key error.\n");
            nRet = -1;
            goto clean_mem_up;
        }
        pub_key_len = EC_POINT_point2oct(EC_KEY_get0_group(eckey), pub_key_point,
                POINT_CONVERSION_UNCOMPRESSED, NULL, 0, NULL);
        if ( (pub_key_len == 0) || (pub_key_len > sizeof(refPub)) )
        {
            EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Verify: Preparation to convert public key into byte array failed.\n");
            nRet = -1;
            goto clean_mem_up;
        }
        if ( EC_POINT_point2oct(EC_KEY_get0_group(eckey), pub_key_point,
                POINT_CONVERSION_UNCOMPRESSED, refPub, pub_key_len, NULL) == 0 )
        {
            EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Verify: Pub key data extraction error.\n");
            nRet = -1;
            goto clean_mem_up;
        }

        EmbSe_PrintPayload(LOG_DBG_ON, refPub, (U16)pub_key_len, "PubKey (Verify)");

        flagHandleKey = AX_ENGINE_INVOKE_OPENSSL_SW;
        // The local data structure eccVerifyKeys must match the storage
        // capability of the attached secure element.
        // Failure to retrieve a key from the secure element will not be
        // considered fatal (the value may not have been provisioned)
        CryptoIpc_MutexLock();
        for (i=0; i<(int)(sizeof(eccVerifyKeys)/sizeof(axKeyIdentifier_t)); i++)
        {
            U8 fetchedPubKey[65];
            U16 fetchedPubKeyLen = sizeof(fetchedPubKey);

            memset(fetchedPubKey, 0, fetchedPubKeyLen);
            idx = eccVerifyKeys[i].idx;

            EmbSe_Print(LOG_DBG_ON, "A71_GetEccPublicKey(0x%02X)\n", (SST_Index_t)idx);
            sw = A71_GetEccPublicKey((SST_Index_t)idx, fetchedPubKey, &fetchedPubKeyLen);
            if (sw == SW_OK)
            {
                if (memcmp(refPub, fetchedPubKey, sizeof(fetchedPubKey)) == 0)
                {
                    // We have a match.
                    flagHandleKey = AX_ENGINE_INVOKE_SE;
                    EmbSe_Print(LOG_FLOW_ON, "EmbSe_ECDSA_Do_Verify: Found matching public key at index 0x%02X\n", idx);
                    break;
                }
            }
        }
        CryptoIpc_MutexUnlock();
    }
    else
    {
        EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Verify: No matching/valid public key\n");
        nRet = -1;
        goto clean_mem_up;
    }

    if (flagHandleKey == AX_ENGINE_INVOKE_SE)
    {
        U8 dgstBuf[32];
        U16 dgstBufLen = sizeof(dgstBuf);

        EmbSe_Print(LOG_FLOW_ON, "ECC_Verify(KeyIdent=%d, KeyIndex=%d, dgst_len=%d, sigLen=%d)\n",
          ident, idx, dgst_len, sigLen);
        axAdaptSize(dgstBuf, dgstBufLen, dgst, dgst_len);
        CryptoIpc_MutexLock();
        sw = A71_EccVerify(idx, dgstBuf, dgstBufLen, pSignatureDER, sigLen, (U8*)&retval);
        CryptoIpc_MutexUnlock();
        if (sw != SW_OK)
        {
            EmbSe_Print(LOG_ERR_ON, "A71_EccVerify returned with Error: 0x%04X\n", sw);
            nRet = -1;
            goto clean_mem_up;
        }
        else
        {
            if (retval == 1)
                EmbSe_Print(LOG_FLOW_ON, "Verification PASS\n");
            else
                EmbSe_Print(LOG_FLOW_ON, "Verification FAIL\n");
        }
        nRet = (int)retval;
    }
    else if (flagHandleKey == AX_ENGINE_INVOKE_OPENSSL_SW)
    {
#ifdef PUBLIC_KEY_HANDOVER_TO_SW
        EmbSe_Print(LOG_FLOW_ON, "No matching key in A71CH. Invoking OpenSSL API: ECDSA_do_verify.\n");
        /* Create a duplicate key */
        dup_eckey = EC_KEY_dup(eckey);
        if (dup_eckey == NULL)
        {
            EmbSe_Print(LOG_ERR_ON, "OpenSSL verify: Failed to duplicate key.\n");
            nRet = -1;
            goto clean_mem_up;
        }
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
        /* Attach OpenSSL's SW methods to duplicate key */
        if (!ECDSA_set_method(dup_eckey, ECDSA_OpenSSL())) {
            EmbSe_Print(LOG_ERR_ON, "OpenSSL ECDSA_set_method failure..\n");
            nRet = -1;
            EC_KEY_free(dup_eckey);
            goto clean_mem_up;
        }
#else
        /* Attach OpenSSL's SW methods to duplicate key */
        if (!EC_KEY_set_method(dup_eckey, EC_KEY_OpenSSL())) {
            EmbSe_Print(LOG_ERR_ON, "OpenSSL EC_KEY_set_method failure..\n");
            nRet = -1;
            EC_KEY_free(dup_eckey);
            goto clean_mem_up;
        }
#endif
        /* Invoke OpenSSL verify and return result */
        nRet = ECDSA_do_verify(dgst, dgst_len, sig, dup_eckey);
        if (nRet == 1)
        {
            EmbSe_Print(LOG_FLOW_ON, "Verification by OpenSSL PASS\n");
        }
        else
        {
            EmbSe_Print(LOG_FLOW_ON, "Verification by OpenSSL FAIL (nRet=%d)\n", nRet);
        }
        EC_KEY_free(dup_eckey);
#else
        EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Verify expected a reference key or a matching stored public key.\n");
        nRet = -1;
        goto clean_mem_up;
#endif
    }
    else
    {
        EmbSe_Print(LOG_ERR_ON, "EmbSe_ECDSA_Do_Verify: unexpected conditional branch (flagHandleKey=%d).\n", flagHandleKey);
        nRet = -1;
        goto clean_mem_up;
    }

clean_mem_up:
    OPENSSL_free(pSignatureDER);

    return nRet;
}

#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
/**
 * Engine API implementation for computing shared secret, based on local private key, remote public key and an
 * optional  KDF(Key Derivation Function).
 *
 * @param[out] sh_secret buffer that will contain the computed shared secret (raw value if KDF is NULL).
 * @param[in]  sec_len   length of computed shared secret.
 * @param[in]  pub_key   public key of remote entity.
 * @param[in]  ecdh      reference to private key object of local entity.
 * @param[in] (*KDF)     reference to a function that implements Key Derivation Function (hash on raw secret)
 *
 * @param: (*KDF)in- Reference to buffer containing the generated shared secret.
 * @param: (*KDF)inlen- Length of the input
 * @param: (*KDF)out - Buffer that returns final output on running KDF
 * @param: (*KDF)outlen - returns length of computed output on running KDF
 * @return: On failure, returns -1; On success returns length of computed secret.
 */
static int EmbSe_Compute_Key(void *sh_secret,
    size_t sec_len,
    const EC_POINT *pub_key,
    EC_KEY *ecdh,
    void *(*KDF)(const void *in, size_t inlen, void *out, size_t *outlen))
#else
static int EmbSe_Simple_Compute_Key(unsigned char **pout,
    size_t *poutlen,
    const EC_POINT *pub_key,
    const EC_KEY *ecdh)
#endif
{
    U16 sw;
    U16 field_size_bits = 0;
    const EC_GROUP *key_group = NULL;
    U8 *pubKeyBuf = NULL;
    U16 pubKeyBufLen = 0;
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
    int ret = -1;
#else
    int ret = 0;
#endif
    U8 *shSecBuf = NULL;
    U16 shSecBufLen = 0;
    SST_Identifier_t ident;
    SST_Index_t idx;

#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
    EmbSe_Print(LOG_FLOW_ON, "EmbSe_Compute_Key invoked (ecdh)\n");
    /* Requested secret length limit check */
    if (sec_len > ECDH_MAX_LEN) {
        EmbSe_Print(LOG_ERR_ON, "Requested secret too long. Try <= %d.\n", ECDH_MAX_LEN);
        return ret;
    }
#else
    EmbSe_Print(LOG_FLOW_ON, "EmbSe_Simple_Compute_Key invoked (ecdh)\n");
#endif
    /* Get the key group */
    key_group = EC_KEY_get0_group(ecdh);
    if (!key_group)
    {
        EmbSe_Print(LOG_ERR_ON, "Unable to extract ECDH key group.\n");
        goto err;
    }
    else
    {/* Calculate length of field element for the key group */
        field_size_bits = (U16)EC_GROUP_get_degree(key_group);
        if (!field_size_bits)
        {
            EmbSe_Print(LOG_ERR_ON, "Unable to extract ECDH key field length.\n");
            goto err;
        }
    }

    /* Extract Public Key Data  */
    /****************************/
    // Check if pub key is on the curve group
    if (!EC_POINT_is_on_curve(key_group, pub_key, NULL))
    {
        EmbSe_Print(LOG_ERR_ON, "ECDH Public key error(incompatible group).\n");
        goto err;
    }
    // Get the size of public key -> pass NULL for buffer
    pubKeyBufLen = (U16) EC_POINT_point2oct(key_group, pub_key, POINT_CONVERSION_UNCOMPRESSED,
                        NULL, pubKeyBufLen, NULL);
    // Allocate memory for public key data & check allocation
    pubKeyBuf = malloc(pubKeyBufLen * sizeof(U8));
    if (!pubKeyBuf)
    {
        EmbSe_Print(LOG_ERR_ON, "malloc failure for ECDH public key data.\n");
        goto err;
    }
    // Get public key data
    if (!EC_POINT_point2oct(key_group, pub_key, POINT_CONVERSION_UNCOMPRESSED, pubKeyBuf, pubKeyBufLen, NULL))
    {
        EmbSe_Print(LOG_ERR_ON, "ECDH public key data error (EC_POINT_point2oct).\n");
        goto err;
    }

    /* Secure Element Call (if applicable) */
    /***************************************/
    shSecBufLen = (U16)(field_size_bits+7)/8;

#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
    shSecBuf = malloc(shSecBufLen * sizeof(U8));
#else
    shSecBuf = OPENSSL_malloc(shSecBufLen * sizeof(U8));
#endif

    sw = getEcKeyReference(ecdh, eccDhStaticKeys, sizeof(eccDhStaticKeys)/sizeof(axKeyIdentifier_t),
        &ident, &idx);
    if (sw == SW_OK)
    {
        EmbSe_Print(LOG_FLOW_ON, "A71_EcdhGetSharedSecret(idx=%d, pubKeyLen=%d, shSecBufLen=%d)\n",
            idx, pubKeyBufLen, shSecBufLen);
        CryptoIpc_MutexLock();
        sw = A71_EcdhGetSharedSecret(idx, pubKeyBuf, pubKeyBufLen, shSecBuf, &shSecBufLen);
        CryptoIpc_MutexUnlock();
        if (sw == SW_OK)
        {
            EmbSe_Print(LOG_FLOW_ON, "A71CH: A71_EcdhGetSharedSecret OK: Status code 0x%04x\n", sw);
        }
        else
        {
            EmbSe_Print(LOG_ERR_ON, "A71CH: A71_EcdhGetSharedSecret Error: Status code 0x%04x\n", sw);
            goto err;
        }
    }
    else if (sw == ERR_IDENT_IDX_RANGE)
    {
        EmbSe_Print(LOG_ERR_ON, "Reference Key with identifier or index out of range: 0x%04X.\n", sw);
        goto err;
    }
    else if (sw == ERR_NO_PRIVATE_KEY)
    {
        EmbSe_Print(LOG_ERR_ON, "Expecting private key (by value or reference): 0x%04X.\n", sw);
        goto err;
    }
    else if (sw == ERR_PATTERN_COMPARE_FAILED)
    {
#ifdef PRIVATE_KEY_HANDOVER_TO_SW
        EC_KEY *dup_ecdh = NULL;
        int ecdh_ret = -1;

        // Delegate to OpenSSL SW implementation
        EmbSe_Print(LOG_FLOW_ON,"No matching key in A71CH. Invoking OpenSSL API: ECDH_compute_key.\n");
        /* Create a duplicate key */
        dup_ecdh = EC_KEY_dup(ecdh);
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
        /* Attach OpenSSL's SW method to duplicate key */
        if (!ECDH_set_method(dup_ecdh, ECDH_OpenSSL())) {
            EmbSe_Print(LOG_ERR_ON, "OpenSSL ECDH_set_method failure.\n");
            goto err;
        }
#else
        /* Attach OpenSSL's SW method to duplicate key */
        if (!EC_KEY_set_method(dup_ecdh, EC_KEY_OpenSSL())) {
            EmbSe_Print(LOG_ERR_ON, "OpenSSL EC_KEY_set_method failure..\n");
            goto err;
        }
#endif
        /* Invoke OpenSSL ECDH_compute_key and return result */
        // int ECDH_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, EC_KEY *ecdh,
        // void *(*KDF)(const void *in, size_t inlen, void *out, size_t *outlen));
        ecdh_ret = ECDH_compute_key(shSecBuf, shSecBufLen, pub_key, dup_ecdh, NULL);
        EC_KEY_free(dup_ecdh);
        if (0 < ecdh_ret)
        {
            EmbSe_Print(LOG_FLOW_ON, "ECDH_compute_key by OpenSSL PASS\n");
            shSecBufLen = (U16)ecdh_ret;
        }
        else
        {
            EmbSe_Print(LOG_ERR_ON, "ECDH_compute_key by OpenSSL FAILS with %d.\n", ecdh_ret);
            goto err;
        }
#else
        EmbSe_Print(LOG_ERR_ON, "EmbSe_Compute_Key expected a reference key: 0x%04X.\n", sw);
        goto err;
#endif
    }
    else
    {
        EmbSe_Print(LOG_ERR_ON, "EmbSe_Compute_Key unexpected key type: 0x%04X.\n", sw);
        goto err;
    }

#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
    /* Finally run the KDF, if provided */
    memset(sh_secret, 0, shSecBufLen);
    if (KDF != 0)
    {
        if (KDF(shSecBuf, shSecBufLen, sh_secret, &sec_len) == NULL)
        {
            EmbSe_Print(LOG_ERR_ON, "KDF failed.\n");
            goto err;
        }
        ret = (int)sec_len;
    }
    else
    {
        /* When KDF=NULL, return raw secret, copy asked length */
        if (sec_len > shSecBufLen)
        {
            sec_len = shSecBufLen;
        }
        memcpy(sh_secret, shSecBuf, sec_len);
        ret = (int)sec_len;
    }
#else
    *pout = shSecBuf;
    *poutlen = shSecBufLen;
    ret = 1;
#endif

    // Never print shared secret
    // EmbSe_PrintPayload(LOG_DBG_ON, sh_secret, sec_len, "Shared Secret: ");

err:
    /* Free all allocated memory */
    if (pubKeyBuf)
        free(pubKeyBuf);
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
    if (shSecBuf)
        free(shSecBuf);
#endif
    return ret;
}

#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
#else
static int EmbSe_Simple_Key_gen(EC_KEY *key)
{
    int(*openssl_Key_gen_sw)(EC_KEY * key) = NULL;
    EC_KEY_METHOD_get_keygen((EC_KEY_METHOD *)EmbSe_EC_Default, &openssl_Key_gen_sw);
    return openssl_Key_gen_sw(key);
}
#endif

/*  Support functions */
/**********************/

/**
 * Initialize communication with Secure Element.
 * Supporting function for Engine Init.
 *
 * @retval ::SW_OK Upon successful execution
 */
static U16 EmbSe_A70Init(void)
{
    U16 connectStatus = 0;
    U8 Atr[64];
    U16 AtrLen = sizeof(Atr);
    SmCommState_t commState;
    sm_printf(DBGOUT, "Connect to A71CH. Chunksize at link layer = %d.\n", MAX_CHUNK_LENGTH_LINK);

#if defined(TDA8029_UART) || defined(SCI2C) || defined(PCSC)|| defined(T1oI2C)
    connectStatus = SM_Connect(NULL, &commState, Atr, &AtrLen);
#elif defined(SMCOM_JRCP_V1) || defined(SMCOM_JRCP_V2)
//  {
//      if (CONF_modules_load_file(NULL, "rjct_server",
//                            CONF_MFLAGS_IGNORE_MISSING_FILE) <= 0)
//      {
//          fprintf(stderr, "FATAL: error loading configuration file\n");
//          ERR_print_errors_fp(stderr);
//      }
//  }
    {
#ifdef SMCOM_JRCP_V2
        commState.connType = kType_SE_Conn_Type_JRCP_V2;
#endif
#ifdef SMCOM_JRCP_V1
        commState.connType = kType_SE_Conn_Type_JRCP_V1;
#endif
        char *rjctServerAddress = NULL;
        rjctServerAddress = getenv("RJCT_SERVER_ADDR");
        if (rjctServerAddress == NULL) {
            connectStatus = SM_RjctConnect(NULL, "127.0.0.1:8050", &commState, Atr, &AtrLen);
        }
        else {
            char szConnect[256];
            size_t connectLen = sizeof(szConnect);
            char szColonPort[] = ":8050";
            size_t colonPortLen = sizeof(szColonPort) + 1;
            if (sizeof(rjctServerAddress) > (connectLen-colonPortLen)) {
                sm_printf(DBGOUT, "Server address is too long: %s\n", rjctServerAddress);
                return ERR_NO_VALID_IP_PORT_PATTERN;
            }
            else {
                strcpy(szConnect, rjctServerAddress);
                //strcat(szConnect, szColonPort);
                sm_printf(DBGOUT, "Server address:port set to %s\n", szConnect);
                connectStatus = SM_RjctConnect(NULL, szConnect, &commState, Atr, &AtrLen);
            }
        }
    }
#else
    #error "No communication channel defined"
#endif // TDA8029
    if ( (connectStatus == ERR_CONNECT_LINK_FAILED) || (connectStatus == ERR_CONNECT_SELECT_FAILED) )
    {
        sm_printf(CONSOLE, "SM_Connect failed with status 0x%04X\n", connectStatus);
        return connectStatus;
    }
    else if ( connectStatus == SMCOM_COM_FAILED )
    {
        sm_printf(CONSOLE, "SM_Connect failed with status 0x%04X (Could not open communication channel)\n", connectStatus);
        return connectStatus;
    }
    else if ( connectStatus == SMCOM_PROTOCOL_FAILED)
    {
        sm_printf(CONSOLE, "SM_Connect failed with status 0x%04X (Could not establish communication protocol)\n", connectStatus);
        return connectStatus;
    }
    else if ( connectStatus == ERR_NO_VALID_IP_PORT_PATTERN )
    {
        sm_printf(DBGOUT, "Pass the IP address and port number as arguments, e.g. \"127.0.0.1:8050\"!\n");
        return connectStatus;
    }
    else
    {
        int i=0;
#if defined(SCI2C)
        sm_printf(CONSOLE, "SCI2C_"); // To highlight the ATR format for SCI2C deviates from ISO7816-3
#elif defined(SPI)
        sm_printf(CONSOLE, "SCSPI_");
#endif
        if (AtrLen > 0)
        {
            sm_printf(CONSOLE, "ATR=0x");
            for (i=0; i<AtrLen; i++) { sm_printf(CONSOLE, "%02X.", Atr[i]); }
            sm_printf(CONSOLE, "\n");
        }
#if defined(TDA8029_UART)
        sm_printf(CONSOLE, "UART Baudrate Idx: 0x%02X\n", commState.param2);
        sm_printf(CONSOLE, "T=1           TA1: 0x%02X\n", commState.param1);
#endif
        sm_printf(CONSOLE, "HostLib Version  : 0x%04X\n", commState.hostLibVersion);
        if (connectStatus != SW_OK)
        {
            sm_printf(CONSOLE, "Select failed. SW = 0x%04X\n", connectStatus);
            return connectStatus;
        }
        sm_printf(CONSOLE, "Applet Version   : 0x%04X\n", commState.appletVersion);
        sm_printf(CONSOLE, "SecureBox Version: 0x%04X\n", commState.sbVersion);
    }
    sm_printf(DBGOUT, "==========SELECT-DONE=========\n");
    return SW_OK;
}

void EmbSe_Print(int flag, const char * format, ...)
{
    unsigned char buffer[EMBSE_MAX_PRINT_BUF_SIZE + 1];
    int active = 0;
    va_list vArgs;

    if ( (flag & EMBSE_LogControl & LOG_FLOW_MASK) == LOG_FLOW_ON ) {
        active = 1;
        printf("e2a71ch-flw: ");
    }
    else if ( (flag & EMBSE_LogControl & LOG_DBG_MASK) == LOG_DBG_ON ) {
        active = 1;
        printf("e2a71ch-dbg: ");
    }
    else if ( (flag & EMBSE_LogControl & LOG_ERR_MASK) == LOG_ERR_ON ) {
        active = 1;
        printf("e2a71ch-err: ");
    }

    if (active == 1)
    {
        va_start(vArgs, format);
        vsnprintf((char *)buffer, EMBSE_MAX_PRINT_BUF_SIZE, (char const *)format, vArgs);
        va_end(vArgs);
        printf("%s", buffer);
    }
    return;
}

static void EmbSe_PrintPayload(int flag, const U8 *pPayload, U16 nLength, const char *title)
{
    U16 i;
    int active = 0;

    if ( (flag & EMBSE_LogControl & LOG_FLOW_MASK) == LOG_FLOW_ON ) {
        active = 1;
        printf("e2a71ch-flw: %s", title);
    }
    else if ( (flag & EMBSE_LogControl & LOG_DBG_MASK) == LOG_DBG_ON ) {
        active = 1;
        printf("e2a71ch-dbg: %s", title);
    }
    else if ( (flag & EMBSE_LogControl & LOG_ERR_MASK) == LOG_ERR_ON ) {
        active = 1;
        printf("e2a71ch-err: %s", title);
    }

    if (active == 1)
    {
        for (i = 0; i < nLength; i++)
        {
            if (i % 16 == 0) { printf("\n"); }
            printf("%02X ", pPayload[i]);
        }
        printf("\n");
    }
}

/**
 Return SW_OK when the ecKey passed as argument matches one of the valid
 keys contained in the validKeys array. Upon successfull execution ident
 and idx contain values that point to the appropriate key in the secure
 element.

 @return ERR_PATTERN_COMPARE_FAILED  Not a reference key
 @return ERR_IDENT_IDX_RANGE         Refers to unsupported key type (aka. identifier) or index
 @return ERR_NO_PRIVATE_KEY          No private key present
*/
static U16 getEcKeyReference(const EC_KEY *eckey, axKeyIdentifier_t *validKeys, int nKeys,
                             SST_Identifier_t *ident, SST_Index_t *idx)
{
    U16 sw = ERR_PATTERN_COMPARE_FAILED;
    const BIGNUM *prv_key_bn;
    U8 tmpBuf[EMBSE_MAX_ECC_PUBKEY_BUF];
    U16 privKeylen = 0;
    U8 Ident = 0;
    U8 Index = 0;
    U32 Coeff[2] = {0, 0};
    int i = 0;
    int j = 0;

    ENSURE_OR_GO_EXIT(ident != NULL);
    ENSURE_OR_GO_EXIT(idx != NULL);

    // printf("Debug: getEcKeyReference: Possible matches = %d\n", nKeys);

    /* Test for private key */
    prv_key_bn = EC_KEY_get0_private_key(eckey);
    if (prv_key_bn)
    {
        privKeylen = BN_bn2bin(prv_key_bn, tmpBuf);
        /* get Ident and Index */
        Ident = tmpBuf[privKeylen-2];
        Index = tmpBuf[privKeylen-1];
        /* Get double ID string */
        for (j=0; j<2; j++)
        {
            for (i=3;i<7;i++)
            {
                Coeff[j] |= tmpBuf[privKeylen-i-(j*4)]<< 8*(i-3);
            }
        }
        if ( ((unsigned int)Coeff[0] == (unsigned int)EMBSE_REFKEY_ID) &&
            ((unsigned int)Coeff[1] == (unsigned int)EMBSE_REFKEY_ID) )
        {
            sw = ERR_IDENT_IDX_RANGE;
            // Look for matching key
            for (i=0; i<nKeys; i++)
            {
                if ( (validKeys[i].ident == Ident) && (validKeys[i].idx == Index) )
                {
                    // We have a match
                    *ident = validKeys[i].ident;
                    *idx = validKeys[i].idx;
                    sw = SW_OK;
                    break;
                }
            }
        }
        else
        {
            sw = ERR_PATTERN_COMPARE_FAILED;
        }
    }
    else
    {
        sw = ERR_NO_PRIVATE_KEY;
    }

exit:
    return sw;
}

/**
 * Either zero sign extend \p pIn so it becomes \p expectedLen byte long
 * or truncate the right most byte.
 * The caller must ensure \p expectedLen is bigger than \p actualLen
 * @param[in,out]   pOut
 * @param[in]       expectedLen Zero sign extend/truncate until this length.
 * @param[in]       pIn  Array representation of big number, to be zero sign extended or truncated
 * @param[in]       actualLen Length of incoming array \p pIn
 *
 * @retval SW_OK In case of successfull execution
 * @retval ERR_API_ERROR Requested adjustment would result in truncation
 */
static U16 axAdaptSize(U8* pOut, U16 expectedLen, const U8 *pIn, U16 actualLen)
{
    U16 sw = SW_OK;

    int numExtraByte = (int)expectedLen - (int)actualLen;

    if (numExtraByte == 0) {
        memcpy(pOut, pIn, actualLen);
    }
    else if (numExtraByte < 0) {
        memcpy(pOut, pIn, expectedLen);
    }
    else {
        memcpy(pOut + numExtraByte, pIn, actualLen);
        memset(pOut, 0x00, numExtraByte);
    }

    return sw;
}