/*
 *
 *    Copyright (c) 2019 Google LLC.
 *    Copyright (c) 2013-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *    @file
 *      This file implements a process to effect a functional test for
 *      the Weave Elliptic Curve (EC) mathematical interfaces.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "ToolCommon.h"
#include <Weave/Core/WeaveConfig.h>

#include <sys/types.h>

// ============================================================
// Pamareters Declaration for Micro-ECC
// ============================================================

#if WEAVE_CONFIG_USE_MICRO_ECC

extern uint32_t sNIST_P192_ECPointS[2][6];
extern uint32_t sNIST_P192_ECPointT[2][6];
extern uint32_t sNIST_P192_ScalarD[];
extern uint32_t sNIST_P192_ScalarE[];
extern uint32_t sNIST_P192_ECPointRadd[2][6];
extern uint32_t sNIST_P192_ECPointRsub[2][6];
extern uint32_t sNIST_P192_ECPointRdbl[2][6];
extern uint32_t sNIST_P192_ECPointRmul[2][6];
extern uint32_t sNIST_P192_ECPointRjsm[2][6];

extern uint32_t sNIST_P224_ECPointS[2][7];
extern uint32_t sNIST_P224_ECPointT[2][7];
extern uint32_t sNIST_P224_ScalarD[];
extern uint32_t sNIST_P224_ScalarE[];
extern uint32_t sNIST_P224_ECPointRadd[2][7];
extern uint32_t sNIST_P224_ECPointRsub[2][7];
extern uint32_t sNIST_P224_ECPointRdbl[2][7];
extern uint32_t sNIST_P224_ECPointRmul[2][7];
extern uint32_t sNIST_P224_ECPointRjsm[2][7];

extern uint32_t sNIST_P256_ECPointS[2][8];
extern uint32_t sNIST_P256_ECPointT[2][8];
extern uint32_t sNIST_P256_ScalarD[];
extern uint32_t sNIST_P256_ScalarE[];
extern uint32_t sNIST_P256_ECPointRadd[2][8];
extern uint32_t sNIST_P256_ECPointRsub[2][8];
extern uint32_t sNIST_P256_ECPointRdbl[2][8];
extern uint32_t sNIST_P256_ECPointRmul[2][8];
extern uint32_t sNIST_P256_ECPointRjsm[2][8];

#endif // WEAVE_CONFIG_USE_MICRO_ECC

// ============================================================
// Pamareters Declaration for OpenSSL
// ============================================================

#if WEAVE_CONFIG_USE_OPENSSL_ECC

extern BIGNUM *NIST_P192_ECPointS_X();
extern BIGNUM *NIST_P192_ECPointS_Y();
extern BIGNUM *NIST_P192_ECPointT_X();
extern BIGNUM *NIST_P192_ECPointT_Y();
extern BIGNUM *NIST_P192_D();
extern BIGNUM *NIST_P192_E();
extern BIGNUM *NIST_P192_ECPointRadd_X();
extern BIGNUM *NIST_P192_ECPointRadd_Y();
extern BIGNUM *NIST_P192_ECPointRsub_X();
extern BIGNUM *NIST_P192_ECPointRsub_Y();
extern BIGNUM *NIST_P192_ECPointRdbl_X();
extern BIGNUM *NIST_P192_ECPointRdbl_Y();
extern BIGNUM *NIST_P192_ECPointRmul_X();
extern BIGNUM *NIST_P192_ECPointRmul_Y();
extern BIGNUM *NIST_P192_ECPointRjsm_X();
extern BIGNUM *NIST_P192_ECPointRjsm_Y();

extern BIGNUM *NIST_P224_ECPointS_X();
extern BIGNUM *NIST_P224_ECPointS_Y();
extern BIGNUM *NIST_P224_ECPointT_X();
extern BIGNUM *NIST_P224_ECPointT_Y();
extern BIGNUM *NIST_P224_D();
extern BIGNUM *NIST_P224_E();
extern BIGNUM *NIST_P224_ECPointRadd_X();
extern BIGNUM *NIST_P224_ECPointRadd_Y();
extern BIGNUM *NIST_P224_ECPointRsub_X();
extern BIGNUM *NIST_P224_ECPointRsub_Y();
extern BIGNUM *NIST_P224_ECPointRdbl_X();
extern BIGNUM *NIST_P224_ECPointRdbl_Y();
extern BIGNUM *NIST_P224_ECPointRmul_X();
extern BIGNUM *NIST_P224_ECPointRmul_Y();
extern BIGNUM *NIST_P224_ECPointRjsm_X();
extern BIGNUM *NIST_P224_ECPointRjsm_Y();

extern BIGNUM *NIST_P256_ECPointS_X();
extern BIGNUM *NIST_P256_ECPointS_Y();
extern BIGNUM *NIST_P256_ECPointT_X();
extern BIGNUM *NIST_P256_ECPointT_Y();
extern BIGNUM *NIST_P256_D();
extern BIGNUM *NIST_P256_E();
extern BIGNUM *NIST_P256_ECPointRadd_X();
extern BIGNUM *NIST_P256_ECPointRadd_Y();
extern BIGNUM *NIST_P256_ECPointRsub_X();
extern BIGNUM *NIST_P256_ECPointRsub_Y();
extern BIGNUM *NIST_P256_ECPointRdbl_X();
extern BIGNUM *NIST_P256_ECPointRdbl_Y();
extern BIGNUM *NIST_P256_ECPointRmul_X();
extern BIGNUM *NIST_P256_ECPointRmul_Y();
extern BIGNUM *NIST_P256_ECPointRjsm_X();
extern BIGNUM *NIST_P256_ECPointRjsm_Y();

#endif // WEAVE_CONFIG_USE_OPENSSL_ECC

// ============================================================
// End of Pamareters Declaration
// ============================================================

using namespace nl::Weave::Crypto;
using namespace nl::Weave::ASN1;
using namespace nl::Weave::Encoding;

// ============================================================
// EC Math Fanctiodns Declaration for Micro-ECC library
// ============================================================

#if WEAVE_CONFIG_USE_MICRO_ECC

/* Compares points: returns 1 if left == right */
#define uECC_point_equal(left, right, num_words) \
        uECC_vli_equal((left), (right), 2 * (num_words))

/* Points subtraction: result = left - right */
static void uECC_point_sub(uECC_word_t *result,
                           const uECC_word_t *left,
                           const uECC_word_t *right,
                           uECC_Curve curve)
{
    const wordcount_t num_words = uECC_curve_num_words(curve);

    /**
     * result = - right
     *    * result_x = right_x
     *    * result_y = curve_p - result_y
     */
    uECC_vli_set(result, right, num_words);
    uECC_vli_sub(result + num_words, uECC_curve_p(curve), right + num_words, num_words);
    /* result = left - right */
    uECC_point_add(result, left, result, curve);
}

/* Point double: result = 2 * point */
static void uECC_point_dbl(uECC_word_t *result,
                           const uECC_word_t *point,
                           uECC_Curve curve)
{
    uECC_word_t scalar[kuECC_MaxWordCount] = { 0x02 };

    /* result = 2 * point */
    uECC_point_mult(result, point, scalar, curve);
}

static uECC_Curve CurveOID2uECC_Curve(OID curveOID)
{
    switch (curveOID)
    {
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1
    case kOID_EllipticCurve_secp160r1:
        return uECC_secp160r1();
#endif
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1
    case kOID_EllipticCurve_prime192v1:
        return uECC_secp192r1();
#endif
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1
    case kOID_EllipticCurve_secp224r1:
        return uECC_secp224r1();
#endif
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1
    case kOID_EllipticCurve_prime256v1:
        return uECC_secp256r1();
#endif
    default:
        return NULL;
    }
}

static bool TestECMath_PointAddition(OID curveOID, uint32_t iterationCounter)
{
    uECC_Curve curve;
    uECC_word_t *ecPointS;
    uECC_word_t *ecPointT;
    uECC_word_t *ecPointR_Expected;
    EccPoint ecPointR;

    curve = CurveOID2uECC_Curve(curveOID);
    if (curve == NULL)
    {
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointS = (uECC_word_t*)sNIST_P192_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P192_ECPointT;
        ecPointR_Expected = (uECC_word_t*)sNIST_P192_ECPointRadd;
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointS = (uECC_word_t*)sNIST_P224_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P224_ECPointT;
        ecPointR_Expected = (uECC_word_t*)sNIST_P224_ECPointRadd;
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointS = (uECC_word_t*)sNIST_P256_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P256_ECPointT;
        ecPointR_Expected = (uECC_word_t*)sNIST_P256_ECPointRadd;
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    // Main Loop: ecPointR = ecPointS + ecPointT
    for (uint i = 0; i < iterationCounter; i++)
        uECC_point_add(ecPointR, ecPointS, ecPointT, curve);

    // Compare Result ecPointR == ecPointR_Expected
    if (!uECC_point_equal(ecPointR, ecPointR_Expected, uECC_curve_num_words(curve)))
    {
        printf("\tERROR: MicroECC point addition test failed !!! \n");
        return false;
    }

    return true;
}

static bool TestECMath_PointSubtraction(OID curveOID, uint32_t iterationCounter)
{
    uECC_Curve curve;
    uECC_word_t *ecPointS;
    uECC_word_t *ecPointT;
    uECC_word_t *ecPointR_Expected;
    EccPoint ecPointR;

    curve = CurveOID2uECC_Curve(curveOID);
    if (curve == NULL)
    {
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointS = (uECC_word_t*)sNIST_P192_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P192_ECPointT;
        ecPointR_Expected = (uECC_word_t*)sNIST_P192_ECPointRsub;
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointS = (uECC_word_t*)sNIST_P224_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P224_ECPointT;
        ecPointR_Expected = (uECC_word_t*)sNIST_P224_ECPointRsub;
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointS = (uECC_word_t*)sNIST_P256_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P256_ECPointT;
        ecPointR_Expected = (uECC_word_t*)sNIST_P256_ECPointRsub;
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    // Main Loop: ecPointR = ecPointS - ecPointT
    for (uint i = 0; i < iterationCounter; i++)
    {
        /* ecPointR = ecPointS - ecPointT */
        uECC_point_sub(ecPointR, ecPointS, ecPointT, curve);
    }

    // Compare Result ecPointR == ecPointR_Expected
    if (!uECC_point_equal(ecPointR, ecPointR_Expected, uECC_curve_num_words(curve)))
    {
        printf("\tERROR: MicroECC point subtraction test failed !!! \n");
        return false;
    }

    return true;
}

static bool TestECMath_PointDouble(OID curveOID, uint32_t iterationCounter)
{
    uECC_Curve curve;
    uECC_word_t *ecPointS;
    uECC_word_t *ecPointR_Expected;
    EccPoint ecPointR;

    curve = CurveOID2uECC_Curve(curveOID);
    if (curve == NULL)
    {
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointS = (uECC_word_t*)sNIST_P192_ECPointS;
        ecPointR_Expected = (uECC_word_t*)sNIST_P192_ECPointRdbl;
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointS = (uECC_word_t*)sNIST_P224_ECPointS;
        ecPointR_Expected = (uECC_word_t*)sNIST_P224_ECPointRdbl;
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointS = (uECC_word_t*)sNIST_P256_ECPointS;
        ecPointR_Expected = (uECC_word_t*)sNIST_P256_ECPointRdbl;
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    // Main Loop: ecPointR = 2 * ecPointS
    for (uint i = 0; i < iterationCounter; i++)
        uECC_point_dbl(ecPointR, ecPointS, curve);

    // Compare Result ecPointR == ecPointRExpected
    if (!uECC_point_equal(ecPointR, ecPointR_Expected, uECC_curve_num_words(curve)))
    {
        printf("\tERROR: MicroECC point double test failed !!! \n");
        return false;
    }

    return true;
}

static bool TestECMath_PointMultiply(OID curveOID, uint32_t iterationCounter)
{
    uECC_Curve curve;
    uECC_word_t *ecPointS;
    uECC_word_t *scalarD;
    uECC_word_t *ecPointR_Expected;
    EccPoint ecPointR;

    curve = CurveOID2uECC_Curve(curveOID);
    if (curve == NULL)
    {
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointS = (uECC_word_t*)sNIST_P192_ECPointS;
        scalarD = (uECC_word_t*)sNIST_P192_ScalarD;
        ecPointR_Expected = (uECC_word_t*)sNIST_P192_ECPointRmul;
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointS = (uECC_word_t*)sNIST_P224_ECPointS;
        scalarD = (uECC_word_t*)sNIST_P224_ScalarD;
        ecPointR_Expected = (uECC_word_t*)sNIST_P224_ECPointRmul;
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointS = (uECC_word_t*)sNIST_P256_ECPointS;
        scalarD = (uECC_word_t*)sNIST_P256_ScalarD;
        ecPointR_Expected = (uECC_word_t*)sNIST_P256_ECPointRmul;
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    // Main Loop: ecPointR = ScalarD * ecPointS
    for (uint i = 0; i < iterationCounter; i++)
        uECC_point_mult(ecPointR, ecPointS, scalarD, curve);

    // Compare Result ecPointR == ecPointRExpected
    if (!uECC_point_equal(ecPointR, ecPointR_Expected, uECC_curve_num_words(curve)))
    {
        printf("\tERROR: MicroECC point multiply test failed !!! \n");
        return false;
    }

    return true;
}

static bool TestECMath_JointScalarMultiply(OID curveOID, uint32_t iterationCounter)
{
    uECC_Curve curve;
    uECC_word_t *ecPointS;
    uECC_word_t *ecPointT;
    uECC_word_t *scalarD;
    uECC_word_t *scalarE;
    uECC_word_t *ecPointR_Expected;
    EccPoint ecPointR;
    EccPoint ecPointTmp1;
    EccPoint ecPointTmp2;

    curve = CurveOID2uECC_Curve(curveOID);
    if (curve == NULL)
    {
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    switch (curveOID) {

    case kOID_EllipticCurve_prime192v1:
        ecPointS = (uECC_word_t*)sNIST_P192_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P192_ECPointT;
        scalarD = (uECC_word_t*)sNIST_P192_ScalarD;
        scalarE = (uECC_word_t*)sNIST_P192_ScalarE;
        ecPointR_Expected = (uECC_word_t*)sNIST_P192_ECPointRjsm;
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointS = (uECC_word_t*)sNIST_P224_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P224_ECPointT;
        scalarD = (uECC_word_t*)sNIST_P224_ScalarD;
        scalarE = (uECC_word_t*)sNIST_P224_ScalarE;
        ecPointR_Expected = (uECC_word_t*)sNIST_P224_ECPointRjsm;
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointS = (uECC_word_t*)sNIST_P256_ECPointS;
        ecPointT = (uECC_word_t*)sNIST_P256_ECPointT;
        scalarD = (uECC_word_t*)sNIST_P256_ScalarD;
        scalarE = (uECC_word_t*)sNIST_P256_ScalarE;
        ecPointR_Expected = (uECC_word_t*)sNIST_P256_ECPointRjsm;
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        return false;
    }

    // Main Loop: ecPointR = ScalarD * ecPointS + ScalarE * ecPointT
    for (uint i = 0; i < iterationCounter; i++)
    {
        // ecPointTmp1 = ScalarD * ecPointS
        uECC_point_mult(ecPointTmp1, ecPointS, scalarD, curve);

        // ecPointTmp2 = ScalarE * ecPointT
        uECC_point_mult(ecPointTmp2, ecPointT, scalarE, curve);

        // ecPointR = ecPointTmp1 + ecPointTmp2
        uECC_point_add(ecPointR, ecPointTmp1, ecPointTmp2, curve);
    }

    // Compare Result ecPointR == ecPointRExpected
    if (!uECC_point_equal(ecPointR, ecPointR_Expected, uECC_curve_num_words(curve)))
    {
        printf("\tERROR: MicroECC joint scalar multiply test failed !!! \n");
        return false;
    }

    return true;
}
#endif // WEAVE_CONFIG_USE_MICRO_ECC

// ============================================================
// EC Math Fanctions Declaration for OpenSSL ECC Library
// ============================================================

#if WEAVE_CONFIG_USE_OPENSSL_ECC

static bool TestECMath_PointAddition(OID curveOID, uint32_t iterationCounter)
{
    WEAVE_ERROR err;
    EC_GROUP *ecGroup = NULL;
    EC_POINT *ecPointS = NULL;
    BIGNUM *ecPointSx = NULL;
    BIGNUM *ecPointSy = NULL;
    EC_POINT *ecPointT = NULL;
    BIGNUM *ecPointTx = NULL;
    BIGNUM *ecPointTy = NULL;
    EC_POINT *ecPointR = NULL;
    EC_POINT *ecPointR_Expected = NULL;
    BIGNUM *ecPointRx_Expected = NULL;
    BIGNUM *ecPointRy_Expected = NULL;

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointSx = NIST_P192_ECPointS_X();
        ecPointSy = NIST_P192_ECPointS_Y();
        ecPointTx = NIST_P192_ECPointT_X();
        ecPointTy = NIST_P192_ECPointT_Y();
        ecPointRx_Expected = NIST_P192_ECPointRadd_X();
        ecPointRy_Expected = NIST_P192_ECPointRadd_Y();
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointSx = NIST_P224_ECPointS_X();
        ecPointSy = NIST_P224_ECPointS_Y();
        ecPointTx = NIST_P224_ECPointT_X();
        ecPointTy = NIST_P224_ECPointT_Y();
        ecPointRx_Expected = NIST_P224_ECPointRadd_X();
        ecPointRy_Expected = NIST_P224_ECPointRadd_Y();
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointSx = NIST_P256_ECPointS_X();
        ecPointSy = NIST_P256_ECPointS_Y();
        ecPointTx = NIST_P256_ECPointT_X();
        ecPointTy = NIST_P256_ECPointT_Y();
        ecPointRx_Expected = NIST_P256_ECPointRadd_X();
        ecPointRy_Expected = NIST_P256_ECPointRadd_Y();
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

    // Get EC Group for Curve OID
    err = GetECGroupForCurve(curveOID, ecGroup);
    SuccessOrExit(err);

    // Create EC_POINT object for Point S
    ecPointS = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointS != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointS, ecPointSx, ecPointSy, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point T
    ecPointT = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointT != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointT, ecPointTx, ecPointTy, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R_Expected (Expected Result)
    ecPointR_Expected = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR_Expected != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointR_Expected, ecPointRx_Expected, ecPointRy_Expected, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R (Actual Result)
    ecPointR = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR != NULL, err = WEAVE_ERROR_NO_MEMORY);

    // Main Loop: ecPointR = ecPointS + ecPointT
    for (uint i = 0; i < iterationCounter; i++)
        if (!EC_POINT_add(ecGroup, ecPointR, ecPointS, ecPointT, NULL))
            ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Compare Result ecPointR == ecPointR_Expected
    if ( EC_POINT_cmp(ecGroup, ecPointR, ecPointR_Expected, NULL)  != 0 )
    {
        printf("\tERROR: OpenSSL point addition test failed !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

exit:
    BN_free(ecPointSx);
    BN_free(ecPointSy);
    BN_free(ecPointTx);
    BN_free(ecPointTy);
    BN_free(ecPointRx_Expected);
    BN_free(ecPointRy_Expected);
    EC_POINT_free(ecPointR);
    EC_POINT_free(ecPointR_Expected);
    EC_POINT_free(ecPointT);
    EC_POINT_free(ecPointS);
    EC_GROUP_free(ecGroup);
    if (err != WEAVE_NO_ERROR)
    {
        printf("\tERROR: Exiting with error !!! \n");
        return false;
    }

    return true;
}

static bool TestECMath_PointSubtraction(OID curveOID, uint32_t iterationCounter)
{
    WEAVE_ERROR err;
    EC_GROUP *ecGroup = NULL;
    EC_POINT *ecPointS = NULL;
    BIGNUM *ecPointSx = NULL;
    BIGNUM *ecPointSy = NULL;
    EC_POINT *ecPointT = NULL;
    BIGNUM *ecPointTx = NULL;
    BIGNUM *ecPointTy = NULL;
    EC_POINT *ecPointR = NULL;
    EC_POINT *ecPointR_Expected = NULL;
    BIGNUM *ecPointRx_Expected = NULL;
    BIGNUM *ecPointRy_Expected = NULL;
    EC_POINT *ecPointTmp = NULL;

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointSx = NIST_P192_ECPointS_X();
        ecPointSy = NIST_P192_ECPointS_Y();
        ecPointTx = NIST_P192_ECPointT_X();
        ecPointTy = NIST_P192_ECPointT_Y();
        ecPointRx_Expected = NIST_P192_ECPointRsub_X();
        ecPointRy_Expected = NIST_P192_ECPointRsub_Y();
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointSx = NIST_P224_ECPointS_X();
        ecPointSy = NIST_P224_ECPointS_Y();
        ecPointTx = NIST_P224_ECPointT_X();
        ecPointTy = NIST_P224_ECPointT_Y();
        ecPointRx_Expected = NIST_P224_ECPointRsub_X();
        ecPointRy_Expected = NIST_P224_ECPointRsub_Y();
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointSx = NIST_P256_ECPointS_X();
        ecPointSy = NIST_P256_ECPointS_Y();
        ecPointTx = NIST_P256_ECPointT_X();
        ecPointTy = NIST_P256_ECPointT_Y();
        ecPointRx_Expected = NIST_P256_ECPointRsub_X();
        ecPointRy_Expected = NIST_P256_ECPointRsub_Y();
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

    // Get EC Group for Curve OID
    err = GetECGroupForCurve(curveOID, ecGroup);
    SuccessOrExit(err);

    // Create EC_POINT object for Point S
    ecPointS = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointS != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointS, ecPointSx, ecPointSy, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point T
    ecPointT = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointT != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointT, ecPointTx, ecPointTy, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R_Expected (Expected Result)
    ecPointR_Expected = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR_Expected != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointR_Expected, ecPointRx_Expected, ecPointRy_Expected, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R (Actual Result)
    ecPointR = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR != NULL, err = WEAVE_ERROR_NO_MEMORY);

    // Create EC_POINT object for Temp Point
    ecPointTmp = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointTmp != NULL, err = WEAVE_ERROR_NO_MEMORY);

    // Main Loop: ecPointR = ecPointS - ecPointT
    for (uint i = 0; i < iterationCounter; i++)
    {
        ecPointTmp = EC_POINT_dup(ecPointT, ecGroup);
        VerifyOrExit(ecPointTmp != NULL, err = WEAVE_ERROR_NO_MEMORY);

        if (!EC_POINT_invert(ecGroup, ecPointTmp, NULL))
            ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

        if (!EC_POINT_add(ecGroup, ecPointR, ecPointS, ecPointTmp, NULL))
            ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

    // Compare Result ecPointR == ecPointR_Expected
    if ( EC_POINT_cmp(ecGroup, ecPointR, ecPointR_Expected, NULL)  != 0 )
    {
        printf("\tERROR: OpenSSL point subtraction test failed !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

exit:
    BN_free(ecPointSx);
    BN_free(ecPointSy);
    BN_free(ecPointTx);
    BN_free(ecPointTy);
    BN_free(ecPointRx_Expected);
    BN_free(ecPointRy_Expected);
    EC_POINT_free(ecPointTmp);
    EC_POINT_free(ecPointR);
    EC_POINT_free(ecPointR_Expected);
    EC_POINT_free(ecPointT);
    EC_POINT_free(ecPointS);
    EC_GROUP_free(ecGroup);
    if (err != WEAVE_NO_ERROR)
    {
        printf("\tERROR: Exiting with error !!! \n");
        return false;
    }

    return true;
}

static bool TestECMath_PointDouble(OID curveOID, uint32_t iterationCounter)
{
    WEAVE_ERROR err;
    EC_GROUP *ecGroup = NULL;
    EC_POINT *ecPointS = NULL;
    BIGNUM *ecPointSx = NULL;
    BIGNUM *ecPointSy = NULL;
    EC_POINT *ecPointR = NULL;
    EC_POINT *ecPointR_Expected = NULL;
    BIGNUM *ecPointRx_Expected = NULL;
    BIGNUM *ecPointRy_Expected = NULL;

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointSx = NIST_P192_ECPointS_X();
        ecPointSy = NIST_P192_ECPointS_Y();
        ecPointRx_Expected = NIST_P192_ECPointRdbl_X();
        ecPointRy_Expected = NIST_P192_ECPointRdbl_Y();
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointSx = NIST_P224_ECPointS_X();
        ecPointSy = NIST_P224_ECPointS_Y();
        ecPointRx_Expected = NIST_P224_ECPointRdbl_X();
        ecPointRy_Expected = NIST_P224_ECPointRdbl_Y();
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointSx = NIST_P256_ECPointS_X();
        ecPointSy = NIST_P256_ECPointS_Y();
        ecPointRx_Expected = NIST_P256_ECPointRdbl_X();
        ecPointRy_Expected = NIST_P256_ECPointRdbl_Y();
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

    // Get EC Group for Curve OID
    err = GetECGroupForCurve(curveOID, ecGroup);
    SuccessOrExit(err);

    // Create EC_POINT object for Point S
    ecPointS = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointS != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointS, ecPointSx, ecPointSy, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R_Expected (Expected Result)
    ecPointR_Expected = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR_Expected != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointR_Expected, ecPointRx_Expected, ecPointRy_Expected, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R (Actual Result)
    ecPointR = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR != NULL, err = WEAVE_ERROR_NO_MEMORY);

    // Main Loop: ecPointR = 2 * ecPointS
    for (uint i = 0; i < iterationCounter; i++)
        if (!EC_POINT_dbl(ecGroup, ecPointR, ecPointS, NULL))
            ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Compare Result ecPointR == ecPointR_Expected
    if ( EC_POINT_cmp(ecGroup, ecPointR, ecPointR_Expected, NULL)  != 0 )
    {
        printf("\tERROR: OpenSSL point double test failed !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

exit:
    BN_free(ecPointSx);
    BN_free(ecPointSy);
    BN_free(ecPointRx_Expected);
    BN_free(ecPointRy_Expected);
    EC_POINT_free(ecPointR);
    EC_POINT_free(ecPointR_Expected);
    EC_POINT_free(ecPointS);
    EC_GROUP_free(ecGroup);
    if (err != WEAVE_NO_ERROR)
    {
        printf("\tERROR: Exiting with error !!! \n");
        return false;
    }

    return true;
}

static bool TestECMath_PointMultiply(OID curveOID, uint32_t iterationCounter)
{
    WEAVE_ERROR err;
    EC_GROUP *ecGroup = NULL;
    EC_POINT *ecPointS = NULL;
    BIGNUM *ecPointSx = NULL;
    BIGNUM *ecPointSy = NULL;
    BIGNUM *scalarD = NULL;
    EC_POINT *ecPointR = NULL;
    EC_POINT *ecPointR_Expected = NULL;
    BIGNUM *ecPointRx_Expected = NULL;
    BIGNUM *ecPointRy_Expected = NULL;

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointSx = NIST_P192_ECPointS_X();
        ecPointSy = NIST_P192_ECPointS_Y();
        scalarD  = NIST_P192_D();
        ecPointRx_Expected = NIST_P192_ECPointRmul_X();
        ecPointRy_Expected = NIST_P192_ECPointRmul_Y();
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointSx = NIST_P224_ECPointS_X();
        ecPointSy = NIST_P224_ECPointS_Y();
        scalarD  = NIST_P224_D();
        ecPointRx_Expected = NIST_P224_ECPointRmul_X();
        ecPointRy_Expected = NIST_P224_ECPointRmul_Y();
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointSx = NIST_P256_ECPointS_X();
        ecPointSy = NIST_P256_ECPointS_Y();
        scalarD  = NIST_P256_D();
        ecPointRx_Expected = NIST_P256_ECPointRmul_X();
        ecPointRy_Expected = NIST_P256_ECPointRmul_Y();
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

    // Get EC Group for Curve OID
    err = GetECGroupForCurve(curveOID, ecGroup);
    SuccessOrExit(err);

    // Create EC_POINT object for Point S
    ecPointS = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointS != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointS, ecPointSx, ecPointSy, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R_Expected (Expected Result)
    ecPointR_Expected = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR_Expected != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointR_Expected, ecPointRx_Expected, ecPointRy_Expected, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R (Actual Result)
    ecPointR = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR != NULL, err = WEAVE_ERROR_NO_MEMORY);

    // Main Loop: ecPointR = scalarD * ecPointS
    for (uint i = 0; i < iterationCounter; i++)
        if (!EC_POINT_mul(ecGroup, ecPointR, NULL, ecPointS, scalarD, NULL))
            ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Compare Result ecPointR == ecPointR_Expected
    if ( EC_POINT_cmp(ecGroup, ecPointR, ecPointR_Expected, NULL)  != 0 )
    {
        printf("\tERROR: OpenSSL point multiply test failed !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

exit:
    BN_free(ecPointSx);
    BN_free(ecPointSy);
    BN_free(scalarD);
    BN_free(ecPointRx_Expected);
    BN_free(ecPointRy_Expected);
    EC_POINT_free(ecPointR);
    EC_POINT_free(ecPointR_Expected);
    EC_POINT_free(ecPointS);
    EC_GROUP_free(ecGroup);
    if (err != WEAVE_NO_ERROR)
    {
        printf("\tERROR: Exiting with error !!! \n");
        return false;
    }

    return true;
}

#if !defined(OPENSSL_IS_BORINGSSL)

static bool TestECMath_JointScalarMultiply(OID curveOID, uint32_t iterationCounter)
{
    WEAVE_ERROR err;
    EC_GROUP *ecGroup = NULL;
    EC_POINT *ecPointS = NULL;
    BIGNUM *ecPointSx = NULL;
    BIGNUM *ecPointSy = NULL;
    EC_POINT *ecPointT = NULL;
    BIGNUM *ecPointTx = NULL;
    BIGNUM *ecPointTy = NULL;
    BIGNUM *scalarD = NULL;
    BIGNUM *scalarE = NULL;
    EC_POINT *ecPointR = NULL;
    EC_POINT *ecPointR_Expected = NULL;
    BIGNUM *ecPointRx_Expected = NULL;
    BIGNUM *ecPointRy_Expected = NULL;
    const EC_POINT *ecPoints[2];
    const BIGNUM *scalars[2];

    switch (curveOID) {
    case kOID_EllipticCurve_prime192v1:
        ecPointSx = NIST_P192_ECPointS_X();
        ecPointSy = NIST_P192_ECPointS_Y();
        ecPointTx = NIST_P192_ECPointT_X();
        ecPointTy = NIST_P192_ECPointT_Y();
        scalarD   = NIST_P192_D();
        scalarE   = NIST_P192_E();
        ecPointRx_Expected = NIST_P192_ECPointRjsm_X();
        ecPointRy_Expected = NIST_P192_ECPointRjsm_Y();
        break;

    case kOID_EllipticCurve_secp224r1:
        ecPointSx = NIST_P224_ECPointS_X();
        ecPointSy = NIST_P224_ECPointS_Y();
        ecPointTx = NIST_P224_ECPointT_X();
        ecPointTy = NIST_P224_ECPointT_Y();
        scalarD   = NIST_P224_D();
        scalarE   = NIST_P224_E();
        ecPointRx_Expected = NIST_P224_ECPointRjsm_X();
        ecPointRy_Expected = NIST_P224_ECPointRjsm_Y();
        break;

    case kOID_EllipticCurve_prime256v1:
        ecPointSx = NIST_P256_ECPointS_X();
        ecPointSy = NIST_P256_ECPointS_Y();
        ecPointTx = NIST_P256_ECPointT_X();
        ecPointTy = NIST_P256_ECPointT_Y();
        scalarD   = NIST_P256_D();
        scalarE   = NIST_P256_E();
        ecPointRx_Expected = NIST_P256_ECPointRjsm_X();
        ecPointRy_Expected = NIST_P256_ECPointRjsm_Y();
        break;

    default:
        printf("\tERROR: Unsupported Elliptic Curve !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

    // Get EC Group for Curve OID
    err = GetECGroupForCurve(curveOID, ecGroup);
    SuccessOrExit(err);

    // Create EC_POINT object for Point S
    ecPointS = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointS != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointS, ecPointSx, ecPointSy, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point T
    ecPointT = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointT != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointT, ecPointTx, ecPointTy, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R_Expected (Expected Result)
    ecPointR_Expected = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR_Expected != NULL, err = WEAVE_ERROR_NO_MEMORY);

    if (!EC_POINT_set_affine_coordinates_GFp(ecGroup, ecPointR_Expected, ecPointRx_Expected, ecPointRy_Expected, NULL))
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create EC_POINT object for Point R (Actual Result)
    ecPointR = EC_POINT_new(ecGroup);
    VerifyOrExit(ecPointR != NULL, err = WEAVE_ERROR_NO_MEMORY);

    ecPoints[0] = ecPointS;
    ecPoints[1] = ecPointT;
    scalars[0]  = scalarD;
    scalars[1]  = scalarE;

    // Main Loop: ecPointR = scalarD * ecPointS + scalarE * ecPointT
    for (uint i = 0; i < iterationCounter; i++)
        if (!EC_POINTs_mul(ecGroup, ecPointR, NULL, 2, ecPoints, scalars, NULL))
            ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Compare Result ecPointR == ecPointR_Expected
    if ( EC_POINT_cmp(ecGroup, ecPointR, ecPointR_Expected, NULL)  != 0 )
    {
        printf("\tERROR: OpenSSL joint scalar multiply test failed !!! \n");
        ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT);
    }

exit:
    BN_free(ecPointSx);
    BN_free(ecPointSy);
    BN_free(ecPointTx);
    BN_free(ecPointTy);
    BN_free(scalarD);
    BN_free(scalarE);
    BN_free(ecPointRx_Expected);
    BN_free(ecPointRy_Expected);
    EC_POINT_free(ecPointR);
    EC_POINT_free(ecPointR_Expected);
    EC_POINT_free(ecPointT);
    EC_POINT_free(ecPointS);
    EC_GROUP_free(ecGroup);
    if (err != WEAVE_NO_ERROR)
    {
        printf("\tERROR: Exiting with error !!! \n");
        return false;
    }

    return true;
}

#endif // !defined(OPENSSL_IS_BORINGSSL)

#endif // WEAVE_CONFIG_USE_OPENSSL_ECC

// ============================================================
// Test Body
// ============================================================

#ifndef TEST_ECMATH_DEBUG_PRINT_ENABLE
#define TEST_ECMATH_DEBUG_PRINT_ENABLE          0
#endif

#ifndef TEST_ECMATH_NUMBER_OF_ITERATIONS
#define TEST_ECMATH_NUMBER_OF_ITERATIONS        1
#endif

int main(int argc, char *argv[])
{
    bool status = true;

    struct TestCurve {
        OID oid;
        char const *name;
    };

    TestCurve TestECMath_Curves[] = {
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1
        { kOID_EllipticCurve_prime192v1, "PRIME192v1" },
#endif
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1
        { kOID_EllipticCurve_secp224r1, "SECP224r1" },
#endif
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1
        { kOID_EllipticCurve_prime256v1, "PRIME256v1" },
#endif
    };

    typedef bool (*TestECMath_Function)(OID curveOID, uint32_t iterationCounter);

    struct TestFunction {
        TestECMath_Function function;
        char const *name;
    };

    TestFunction TestECMath_Functions[] = {
        { TestECMath_PointAddition, "EC Point Addition" },
        { TestECMath_PointSubtraction, "EC Point Subtraction" },
        { TestECMath_PointDouble, "EC Point Double" },
        { TestECMath_PointMultiply, "EC Point Multiply" },
#if !defined(OPENSSL_IS_BORINGSSL)
        { TestECMath_JointScalarMultiply, "EC Joint Scalar Multiply" },
#endif
    };


    for (uint j = 0; j < sizeof(TestECMath_Curves)/sizeof(TestCurve); j++)
    {
        printf("Starting Elliptic Curve tests for %s curve (%d iterations)\n", TestECMath_Curves[j].name, TEST_ECMATH_NUMBER_OF_ITERATIONS);

        for (uint i = 0; i < sizeof(TestECMath_Functions)/sizeof(TestFunction); i++)
        {
#if TEST_ECMATH_DEBUG_PRINT_ENABLE
            printf("\tRunning %s test\n", TestECMath_Functions[i].name);
            time_t timeStart = time(NULL);
#endif

            status = TestECMath_Functions[i].function(TestECMath_Curves[j].oid, TEST_ECMATH_NUMBER_OF_ITERATIONS);
            VerifyOrExit(status == true, );

#if TEST_ECMATH_DEBUG_PRINT_ENABLE
            time_t timeEnd = time(NULL);
            printf("\tTotal Time = %ld sec\n", (timeEnd - timeStart));
#endif
        }
    }

exit:
    return ((status != false) ? EXIT_SUCCESS : EXIT_FAILURE);
}