/*
 *
 *    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 Password Authenticated Session Establishment (PASE)
 *      protocol engine.
 *
 */

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

#include "ToolCommon.h"
#include <Weave/Support/ErrorStr.h>
#include <Weave/Profiles/security/WeaveSecurity.h>
#include <Weave/Profiles/security/WeavePASE.h>

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
#include "lwip/tcpip.h"
#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

using namespace nl::Weave::Profiles::Security;
using namespace nl::Weave::Profiles::Security::PASE;

#define DEBUG_PRINT_ENABLE 0
#define DEBUG_PRINT_MESSAGE_LENGTH 0

#define VerifyOrFail(TST, MSG) \
do { \
    if (!(TST)) \
    { \
        fprintf(stderr, "%s FAILED: ", __FUNCTION__); \
        fputs(MSG, stderr); \
        exit(-1); \
    } \
} while (0)

#define SuccessOrFail(ERR, MSG) \
do { \
    if ((ERR) != WEAVE_NO_ERROR) \
    { \
        fprintf(stderr, "%s FAILED: ", __FUNCTION__); \
        fputs(MSG, stderr); \
        fputs(ErrorStr(ERR), stderr); \
        fputs("\n", stderr); \
        exit(-1); \
    } \
} while (0)


void TestPASEEngine(const char *initPW, const char *respPW, uint32_t kPASEConfig, bool confirmKey, bool reconfigureTest)
{
    static WeavePASEEngine initEng;
    static WeavePASEEngine respEng;
    static WeaveFabricState initFabricState;
    static WeaveFabricState respFabricState;

    WEAVE_ERROR err;
    uint64_t initNodeId = 1;
    uint64_t respNodeId = 2;
    uint16_t sessionKeyId = sTestDefaultSessionKeyId;
    uint16_t encType = kWeaveEncryptionType_AES128CTRSHA1;
    uint16_t pwSrc = kPasswordSource_PairingCode;
    PacketBuffer *encodedMsg, *encodedMsg2;
    uint8_t reconfigureRequired = 0;
    bool expectSuccess = strcmp(initPW, respPW) == 0;
    const WeaveEncryptionKey *initSessionKey;
    const WeaveEncryptionKey *respSessionKey;

    // Zero static memory
    memset(&initEng, 0, sizeof initEng);
    memset(&respEng, 0, sizeof respEng);
    memset(&initFabricState, 0, sizeof initFabricState);
    memset(&respFabricState, 0, sizeof respFabricState);

    // Init PASE Engines
    initEng.Init();
    respEng.Init();

    // Initialize the Initiator/Responder FabricState objects
    err = initFabricState.Init();
    SuccessOrFail(err, "initFabricState.Init failed\n");
    err = respFabricState.Init();
    SuccessOrFail(err, "respFabricState.Init failed\n");

    // Set Initiator Pairing Password
    initEng.Pw = (const uint8_t *)initPW;
    initEng.PwLen = (uint16_t)strlen(initPW);

    // Set Responder Pairing Password
    respFabricState.PairingCode = respPW;

    // Allow only one congif option for Responder if we don't want to test Reconfigure Request
    if (!reconfigureTest)
    {
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG0_TEST_ONLY
        if (kPASEConfig == kPASEConfig_Config0_TEST_ONLY)
            respEng.AllowedPASEConfigs = kPASEConfig_SupportConfig0Bit_TEST_ONLY;
        else
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG1
        if (kPASEConfig == kPASEConfig_Config1)
            respEng.AllowedPASEConfigs = kPASEConfig_SupportConfig1Bit;
        else
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG2
        if (kPASEConfig == kPASEConfig_Config2)
            respEng.AllowedPASEConfigs = kPASEConfig_SupportConfig2Bit;
        else
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG3
        if (kPASEConfig == kPASEConfig_Config3)
            respEng.AllowedPASEConfigs = kPASEConfig_SupportConfig3Bit;
        else
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG4
        if (kPASEConfig == kPASEConfig_Config4)
            respEng.AllowedPASEConfigs = kPASEConfig_SupportConfig4Bit;
        else
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG5
        if (kPASEConfig == kPASEConfig_Config5)
            respEng.AllowedPASEConfigs = kPASEConfig_SupportConfig5Bit;
        else
#endif
            respEng.AllowedPASEConfigs = 0x0;
    }

    // Initiator generates and sends PASE Initiator Step 1 message.
    {
        encodedMsg = PacketBuffer::New();

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "GenerateInitiatorStep1 (Started):\n");
#endif
        err = initEng.GenerateInitiatorStep1(encodedMsg, kPASEConfig, initNodeId, respNodeId, sessionKeyId, encType, pwSrc, &initFabricState, confirmKey);
        SuccessOrFail(err, "WeavePASEEngine::GenerateInitiatorStep1 failed\n");

#if DEBUG_PRINT_MESSAGE_LENGTH
	fprintf(stdout, "GenerateInitiatorStep1: Message Size = %d \n", encodedMsg->DataLength());
#endif

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "GenerateInitiatorStep1 (Finished):\n");
#endif
    }

    // Responder receives and processes PASE Initiator Step 1 message.
    {
#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "ProcessInitiatorStep1 (Started):\n");
#endif

        err = respEng.ProcessInitiatorStep1(encodedMsg, respNodeId, initNodeId, &respFabricState);
	if (err == WEAVE_ERROR_PASE_RECONFIGURE_REQUIRED)
            reconfigureRequired = 1;
	else
            SuccessOrFail(err, "WeavePASEEngine::ProcessInitiatorStep1 failed\n");

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "ProcessInitiatorStep1 (Finished):\n");
#endif
        PacketBuffer::Free(encodedMsg);
        encodedMsg = NULL;
    }

    if (reconfigureRequired)
    {
        // Responder generates and sends PASE Responder Reconfig Message
        {
            encodedMsg = PacketBuffer::New();

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "GenerateResponderReconfigure (Started):\n");
#endif

            err = respEng.GenerateResponderReconfigure(encodedMsg);
            SuccessOrFail(err, "WeavePASEEngine::GenerateResponderReconfigure failed\n");

#if DEBUG_PRINT_MESSAGE_LENGTH
            fprintf(stdout, "GenerateResponderReconfigure: Message Size = %d \n", encodedMsg->DataLength());
#endif

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "GenerateResponderReconfigure (Finished):\n");
#endif
            // Reset PASE Engines
            respEng.Reset();
        }

        // Initiator receives and processes PASE Responder Reconfig Message
        {
#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "ProcessResponderReconfigure (Started):\n");
#endif

            err = initEng.ProcessResponderReconfigure(encodedMsg, kPASEConfig);
            SuccessOrFail(err, "WeavePASEEngine::ProcessResponderReconfigure failed\n");

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "ProcessResponderReconfigure (Finished):\n");
#endif
            PacketBuffer::Free(encodedMsg);
            encodedMsg = NULL;
        }

        // Initiator generates and sends PASE Initiator Step 1 message.
        {
            encodedMsg = PacketBuffer::New();

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "GenerateInitiatorStep1 (Started):\n");
#endif
            err = initEng.GenerateInitiatorStep1(encodedMsg, kPASEConfig, initNodeId, respNodeId, sessionKeyId, encType, pwSrc, &initFabricState, confirmKey);
            SuccessOrFail(err, "WeavePASEEngine::GenerateInitiatorStep1 failed\n");

#if DEBUG_PRINT_MESSAGE_LENGTH
	    fprintf(stdout, "GenerateInitiatorStep1: Message Size = %d \n", encodedMsg->DataLength());
#endif

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "GenerateInitiatorStep1 (Finished):\n");
#endif
        }

        // Responder receives and processes PASE Initiator Step 1 message.
        {
#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "ProcessInitiatorStep1 (Started):\n");
#endif

	    err = respEng.ProcessInitiatorStep1(encodedMsg, respNodeId, initNodeId, &respFabricState);
            SuccessOrFail(err, "WeavePASEEngine::ProcessInitiatorStep1 failed\n");

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "ProcessInitiatorStep1 (Finished):\n");
#endif
            PacketBuffer::Free(encodedMsg);
            encodedMsg = NULL;
        }

    }

    // Responder generates and sends PASE Responder Step 1 message.
    {
        encodedMsg = PacketBuffer::New();

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "GenerateResponderStep1 (Started):\n");
#endif
        err = respEng.GenerateResponderStep1(encodedMsg);
        SuccessOrFail(err, "WeavePASEEngine::GenerateResponderStep1 failed\n");

#if DEBUG_PRINT_MESSAGE_LENGTH
	fprintf(stdout, "GenerateResponderStep1: Message Size = %d \n", encodedMsg->DataLength());
#endif

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "GenerateResponderStep1 (Finished):\n");
#endif
    }

    // Responder generates and sends PASE Responder Step 2 message.
    {
        encodedMsg2 = PacketBuffer::New();

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "GenerateResponderStep2 (Started):\n");
#endif

        err = respEng.GenerateResponderStep2(encodedMsg2);
        SuccessOrFail(err, "WeavePASEEngine::GenerateResponderStep2 failed\n");

#if DEBUG_PRINT_MESSAGE_LENGTH
	fprintf(stdout, "GenerateResponderStep2: Message Size = %d \n", encodedMsg2->DataLength());
#endif

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "GenerateResponderStep2 (Finished):\n");
#endif
    }

    // Initiator receives and processes PASE Responder Step 1 message.
    {
#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "ProcessResponderStep1 (Started):\n");
#endif

        err = initEng.ProcessResponderStep1(encodedMsg);
        SuccessOrFail(err, "WeavePASEEngine::ProcessResponderStep1 failed\n");

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "ProcessResponderStep1 (Finished):\n");
#endif
        PacketBuffer::Free(encodedMsg);
        encodedMsg = NULL;
    }

    // Initiator receives and processes PASE Responder Step 2 message.
    {
#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "ProcessResponderStep2 (Started):\n");
#endif

        err = initEng.ProcessResponderStep2(encodedMsg2);
        SuccessOrFail(err, "WeavePASEEngine::ProcessResponderStep2 failed\n");

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "ProcessResponderStep2 (Finished):\n");
#endif
        PacketBuffer::Free(encodedMsg2);
        encodedMsg2 = NULL;
    }

    // Initiator generates and sends PASE Initiator Step 2 message.
    {
        encodedMsg = PacketBuffer::New();

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "GenerateInitiatorStep2 (Started):\n");
#endif

        err = initEng.GenerateInitiatorStep2(encodedMsg);
        SuccessOrFail(err, "WeavePASEEngine::GenerateInitiatorStep2 failed\n");

#if DEBUG_PRINT_MESSAGE_LENGTH
	fprintf(stdout, "GenerateInitiatorStep2: Message Size = %d \n", encodedMsg->DataLength());
#endif

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "GenerateInitiatorStep2 (Finished):\n");
#endif
    }

    // Responder receives and processes PASE Initiator Step 2 message.
    {
#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "ProcessInitiatorStep2 (Started):\n");
#endif

        err = respEng.ProcessInitiatorStep2(encodedMsg);
        PacketBuffer::Free(encodedMsg);
        encodedMsg = NULL;

        if (expectSuccess)
            SuccessOrFail(err, "WeavePASEEngine::ProcessInitiatorStep2 failed\n");
        else if (confirmKey)
        {
            VerifyOrFail(err == WEAVE_ERROR_KEY_CONFIRMATION_FAILED, "Expected error from WeavePASEEngine::ProcessInitiatorStep2\n");
            return;
        }

#if DEBUG_PRINT_ENABLE
        fprintf(stdout, "ProcessInitiatorStep2 (Finished):\n");
#endif
    }

    if (confirmKey)
    {
        // Responder generates and sends PASE Responder Key Confirmation message.
        {
            encodedMsg = PacketBuffer::New();

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "GenerateResponderKeyConfirm (Started):\n");
#endif
            err = respEng.GenerateResponderKeyConfirm(encodedMsg);
            SuccessOrFail(err, "WeavePASEEngine::GenerateResponderKeyConfirm failed\n");

#if DEBUG_PRINT_MESSAGE_LENGTH
            fprintf(stdout, "GenerateResponderKeyConfirm:   Message Size = %d \n", encodedMsg->DataLength());
#endif

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "GenerateResponderKeyConfirm (Finished):\n");
#endif
        }

        // Initiator receives and processes PASE Responder Key Confirmation message.
        {
#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "ProcessResponderKeyConfirm (Started):\n");
#endif

            err = initEng.ProcessResponderKeyConfirm(encodedMsg);
            SuccessOrFail(err, "WeavePASEEngine::ProcessResponderKeyConfirm failed\n");

#if DEBUG_PRINT_ENABLE
            fprintf(stdout, "ProcessResponderKeyConfirm (Finished):\n");
#endif
            PacketBuffer::Free(encodedMsg);
            encodedMsg = NULL;
        }
    }

    VerifyOrFail(initEng.State == WeavePASEEngine::kState_InitiatorDone, "Initiator state != Done\n");
    VerifyOrFail(respEng.State == WeavePASEEngine::kState_ResponderDone, "Responder state != Done\n");

    VerifyOrFail(initEng.SessionKeyId == respEng.SessionKeyId, "Initiator SessionKeyId != Responder SessionKeyId\n");
    VerifyOrFail(initEng.EncryptionType == respEng.EncryptionType, "Initiator EncryptionType != Responder EncryptionType\n");
    VerifyOrFail(initEng.PerformKeyConfirmation == respEng.PerformKeyConfirmation, "Initiator SessionKeyId != Responder SessionKeyId\n");

    err = initEng.GetSessionKey(initSessionKey);
    SuccessOrFail(err, "WeaveCASEEngine::GetSessionKey() failed\n");

    err = respEng.GetSessionKey(respSessionKey);
    SuccessOrFail(err, "WeaveCASEEngine::GetSessionKey() failed\n");

    VerifyOrFail(memcmp(initSessionKey->AES128CTRSHA1.DataKey, respSessionKey->AES128CTRSHA1.DataKey, WeaveEncryptionKey_AES128CTRSHA1::DataKeySize) == 0,
                 "Data key mismatch\n");

    VerifyOrFail(memcmp(initSessionKey->AES128CTRSHA1.IntegrityKey, respSessionKey->AES128CTRSHA1.IntegrityKey, WeaveEncryptionKey_AES128CTRSHA1::IntegrityKeySize) == 0,
                 "Integrity key mismatch\n");

    // Shutdown the Initiator/Responder FabricState objects
    err = initFabricState.Shutdown();
    SuccessOrFail(err, "initFabricState.Shutdown failed\n");
    err = respFabricState.Shutdown();
    SuccessOrFail(err, "respFabricState.Shutdown failed\n");

    // Shutdown PASE Engines
    respEng.Shutdown();
    initEng.Shutdown();
}

void PASEEngine_Test1(uint32_t kPASEConfig)
{
    TestPASEEngine("TestPassword", "TestPassword", kPASEConfig, true, false);
}

void PASEEngine_Test2(uint32_t kPASEConfig)
{
    TestPASEEngine("TestPassword", "TestPassword", kPASEConfig, false, false);
}

void PASEEngine_Test3(uint32_t kPASEConfig)
{
    TestPASEEngine("TestPassword", "TestwordPass", kPASEConfig, true, false);
}

void PASEEngine_Test4(uint32_t kPASEConfig)
{
    TestPASEEngine("TestPassword", "TestPassword", kPASEConfig, true, true);
}

// #if WEAVE_CONFIG_SUPPORT_PASE_CONFIG1

// void PASEEngine_Test4()
// {
//     WEAVE_ERROR err;
//     WeavePASEEngine eng;
//     uint64_t initNodeId = 2;
//     uint64_t respNodeId = 0x18B43000001E8775ULL;
//     uint16_t sessionKeyId = WeaveKeyId::kType_Session | 0;
//     uint16_t encType = kWeaveEncryptionType_AES128CTRSHA1;
//     uint16_t pwSrc = kPasswordSource_PairingCode;
//     const char *pw = "TEST";
//     bool confirmKey = true;

//     {
//         static BN_ULONG sStep1_GXa_Data[] =
//         {
//             0x489074D4, 0x1193F992, 0x91F2366A, 0xDE0D0674, 0x1F0B4EAA, 0x1CACC906, 0x8431D6B8, 0x1BA5CF84,
//             0xAFB7CFFC, 0x1C0CD0B2, 0x30107FCD, 0x6C1F82BD, 0x60E4D718, 0x147B3479, 0x1FE9BC5D, 0x72A16982,
//             0xC4A7BD74, 0x694E53B4, 0x6BDD1919, 0xC04FF3CA, 0xF3F699CA, 0x0AAC83EE, 0xCD62B502, 0xD17926E4,
//             0x6464227B, 0x656C08C7, 0xA84E3742, 0x065EA552, 0x27D150CA, 0x5B842DF0, 0x92CF93D3, 0x19A0D1D6
//         };
//         static BIGNUM sStep1_GXa =
//         {
//             sStep1_GXa_Data,
//             sizeof(sStep1_GXa_Data)/sizeof(BN_ULONG),
//             sizeof(sStep1_GXa_Data)/sizeof(BN_ULONG),
//             0,
//             BN_FLG_STATIC_DATA
//         };

//         static BN_ULONG sStep1_GXb_Data[] =
//         {
//             0x81E18A01, 0x713C878C, 0x962F52CA, 0xF24B104A, 0x9881D2FD, 0x9DEEDB68, 0x7EB7C7BF, 0xA41EB45D,
//             0x75D130C6, 0xEED03DCA, 0xA579049F, 0xACF81B96, 0x7EE5C37F, 0xFA0B9F7B, 0x00F249E4, 0x6077423F,
//             0x41E2884A, 0x12901333, 0xE70D84B5, 0x89E2156D, 0x20BC2FA3, 0x6CD51881, 0xC5D0B8FC, 0x600FEC4A,
//             0x1FFA2B28, 0xA7ADE0D3, 0x9EFAF283, 0x58F90D59, 0xA5C38799, 0x7DDC9026, 0x5CEAC89E, 0xA6F89527
//         };
//         static BIGNUM sStep1_GXb =
//         {
//             sStep1_GXb_Data,
//             sizeof(sStep1_GXb_Data)/sizeof(BN_ULONG),
//             sizeof(sStep1_GXb_Data)/sizeof(BN_ULONG),
//             0,
//             BN_FLG_STATIC_DATA
//         };

//         static BN_ULONG sStep1_ZKPXaGR_Data[] =
//         {
//             0x75269981, 0xB55D5588, 0xA0B51CD6, 0x24E8CBF0, 0x159C04A9, 0xB6E106E7, 0xDEDA34FE, 0xAE7E14BB,
//             0x654C34F6, 0x395420B9, 0x79AA6244, 0x3CBBD127, 0x707BFBF9, 0x5D0C8931, 0xD798146B, 0x41EAC306,
//             0xED825191, 0x63222B03, 0xAC9C8870, 0x40F7A4B7, 0x237D25CF, 0x7828CBB8, 0x3C6D9E88, 0xC2D1C807,
//             0x7730F83F, 0x782E3935, 0x99FD5A5E, 0x47F8D507, 0x5B36F070, 0xEA29F69E, 0x2F64AD00, 0x15DC1EBC
//         };
//         static BIGNUM sStep1_ZKPXaGR =
//         {
//             sStep1_ZKPXaGR_Data,
//             sizeof(sStep1_ZKPXaGR_Data)/sizeof(BN_ULONG),
//             sizeof(sStep1_ZKPXaGR_Data)/sizeof(BN_ULONG),
//             0,
//             BN_FLG_STATIC_DATA
//         };

//         static BN_ULONG sStep1_ZKPXaB_Data[] =
//         {
//             0x108B6CF1, 0x92CD53F9, 0x8A01E0D0, 0x1FAC5D41, 0x6315ED77
//         };
//         static BIGNUM sStep1_ZKPXaB =
//         {
//             sStep1_ZKPXaB_Data,
//             sizeof(sStep1_ZKPXaB_Data)/sizeof(BN_ULONG),
//             sizeof(sStep1_ZKPXaB_Data)/sizeof(BN_ULONG),
//             0,
//             BN_FLG_STATIC_DATA
//         };

//         static BN_ULONG sStep1_ZKPXbGR_Data[] =
//         {
//             0xD21EF93B, 0x84F3FD15, 0x764815C5, 0x7FE5C7F9, 0x669FE0F2,
//             0x21760B13, 0x26550314, 0x0B50ED64, 0xF6100E47, 0x96C99FB7,
//             0x61DD062C, 0x08724518, 0xBE3AC240, 0x50DE63FF, 0x6819D65C,
//             0xE67ED248, 0x0D196466, 0x1A5F64EC, 0x954855F9, 0x6CB8DCD0,
//             0x8E08B4A2, 0x103F04B3, 0xC59FA937, 0x48D363A8, 0x98F686CA,
//             0x9F29FA89, 0xBC87A0C2, 0xD185017B, 0xAA4A469D, 0x4329CBC0,
//             0x6863E791, 0xBAE0CE9C
//         };
//         static BIGNUM sStep1_ZKPXbGR =
//         {
//             sStep1_ZKPXbGR_Data,
//             sizeof(sStep1_ZKPXbGR_Data)/sizeof(BN_ULONG),
//             sizeof(sStep1_ZKPXbGR_Data)/sizeof(BN_ULONG),
//             0,
//             BN_FLG_STATIC_DATA
//         };

//         static BN_ULONG sStep1_ZKPXbB_Data[] =
//         {
//                 0x4F113953, 0xBD0FAB7D, 0x405A9C56, 0x451A745F, 0xB061B450
//         };
//         static BIGNUM sStep1_ZKPXbB =
//         {
//             sStep1_ZKPXbB_Data,
//             sizeof(sStep1_ZKPXbB_Data)/sizeof(BN_ULONG),
//             sizeof(sStep1_ZKPXbB_Data)/sizeof(BN_ULONG),
//             0,
//             BN_FLG_STATIC_DATA
//         };

// 	//        InitiatorStep1Message initStep1Msg;
//         initStep1Msg.GXa = sStep1_GXa;
//         initStep1Msg.GXb = sStep1_GXb;
//         initStep1Msg.ZKPXaB = sStep1_ZKPXaB;
//         initStep1Msg.ZKPXaGR = sStep1_ZKPXaGR;
//         initStep1Msg.ZKPXbB = sStep1_ZKPXbB;
//         initStep1Msg.ZKPXbGR = sStep1_ZKPXbGR;
//         initStep1Msg.ProtocolConfig = kPASEConfig_Config1;
//         initStep1Msg.AlternateConfigCount = 0;
//         initStep1Msg.SessionKeyId = sessionKeyId;
//         initStep1Msg.EncryptionType = encType;
//         initStep1Msg.PasswordSource = pwSrc;
//         initStep1Msg.PerformKeyConfirmation = confirmKey;
//         PacketBuffer *BufStep1Msg = PacketBuffer::New();

//         err = eng.ProcessInitiatorStep1(BufStep1Msg, respNodeId, initNodeId, (const uint8_t *)pw, (uint16_t)strlen(pw));
//         PacketBuffer::Free(BufStep1Msg);
//         SuccessOrFail(err, "WeavePASEEngine::ProcessInitiatorStep1 failed\n");
//     }
// }
// #endif  /* WEAVE_CONFIG_SUPPORT_PASE_CONFIG1 */

int main(int argc, char *argv[])
{
    WEAVE_ERROR err;

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
    tcpip_init(NULL, NULL);
#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

    err = nl::Weave::Platform::Security::InitSecureRandomDataSource(NULL, 64, NULL, 0);
    FAIL_ERROR(err, "InitSecureRandomDataSource() failed");

#define NUMBER_OF_ITERATIONS 1

    int i;
    uint32_t PASE_Configs[] = {
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG0_TEST_ONLY
                                 kPASEConfig_Config0_TEST_ONLY,
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG1
                                 kPASEConfig_Config1,
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG2
                                 kPASEConfig_Config2,
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG3
                                 kPASEConfig_Config3,
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG4
                                 kPASEConfig_Config4,
#endif
#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG5
                                 kPASEConfig_Config5,
#endif
                               };
    time_t sec_now;
    time_t sec_last;

    for (uint8_t j = 0; j < sizeof(PASE_Configs)/sizeof(uint32_t); j++)
    {
        printf("\nTEST1 for PASE Config %08X (%d iterations)\n", PASE_Configs[j], NUMBER_OF_ITERATIONS);
	sec_last = time(NULL);
        for (i=0; i < NUMBER_OF_ITERATIONS; i++)
            PASEEngine_Test1(PASE_Configs[j]);
	sec_now = time(NULL);
        printf("TIME DELTA (sec) = %ld sec\n", (sec_now - sec_last));

        printf("\nTEST2 for PASE Config %08X (%d iterations)\n", PASE_Configs[j], NUMBER_OF_ITERATIONS);
	sec_last = time(NULL);
        for (i=0; i < NUMBER_OF_ITERATIONS; i++)
            PASEEngine_Test2(PASE_Configs[j]);
        sec_now = time(NULL);
        printf("TIME DELTA (sec) = %ld sec\n", (sec_now - sec_last));

        printf("\nTEST3 for PASE Config %08X (%d iterations)\n", PASE_Configs[j], NUMBER_OF_ITERATIONS);
	sec_last = time(NULL);
        for (i=0; i < NUMBER_OF_ITERATIONS; i++)
            PASEEngine_Test3(PASE_Configs[j]);
        sec_now = time(NULL);
        printf("TIME DELTA (sec) = %ld sec\n", (sec_now - sec_last));

        printf("\nTEST4 for PASE Config %08X (%d iterations)\n", PASE_Configs[j], NUMBER_OF_ITERATIONS);
	sec_last = time(NULL);
        for (i=0; i < NUMBER_OF_ITERATIONS; i++)
            PASEEngine_Test4(PASE_Configs[j]);
        sec_now = time(NULL);
        printf("TIME DELTA (sec) = %ld sec\n", (sec_now - sec_last));
    }
// #if WEAVE_CONFIG_SUPPORT_PASE_CONFIG1
//     PASEEngine_Test4();
// #endif
    printf("All tests succeeded\n");
}