/*
 * Copyright 2020 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */


#include "test_Crypto.h"

#define MAC_BLOCK_SIZE 16

/* clang-format off */
const uint8_t gSRCData1[MAC_BLOCK_SIZE] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
const uint8_t gSRCData2[] = {
    0x84,0x82,0x33,0x00,0x10,0xB3,0x60,0x8B,0x7A,0x4C,0xC3,0xA1,0x49,
    0x84,0x82,0x33,0x00,0x10,0xB3,0x60,0x8B,0x7A,0x4C,0xC3,0xA1,0x49,
    0x84,0x82,0x33,0x00,0x10,0xB3,0x60,0x8B,0x7A,0x4C,0xC3,0xA1,0x49,
    0x84,0x82,0x33,0x00,0x10,0xB3,0x60,0x8B,0x7A,0x4C,0xC3,0xA1,0x49,
    0x84,0x82,0x33,0x00,0x10,0xB3,0x60,0x8B,0x7A,0x4C,0xC3,0xA1,0x49,
    0x84,0x82,0x33,0x00,0x10,0xB3,0x60,0x8B,0x7A,0x4C,0xC3,0xA1,0x49,
    0x84,0x82,0x33,0x00,0x10,0xB3,0x60,0x8B,0x7A,0x4C,0xC3,0xA1,
};
const uint8_t srcData3[] = {
    0x84, 0x01, 0x03, 0x00, 0x28, 0x82, 0x7B, 0x9B, 0xBD, 0x3F, 0xDC, 0x41, 0x8C, 0x46, 0xBB, 0x42, 0xD4, 0x9A, 0x32, 0xC7, 0x0C, 0x0F,
    0x52, 0xB8, 0x6B, 0x24, 0x13, 0x73, 0xFF, 1,2,3,4,5,6,6,7,8,9,0,1,2,3,4,5,6,7,9, 10,
    0x52, 0xB8, 0x6B, 0x24, 0x13, 0x73, 0xFF, 1,2,3,4,5,6,6,7,8,9,0,1,2,3,4,5,6,7,9, 10,
    0x52, 0xB8, 0x6B, 0x24, 0x13, 0x73, 0xFF, 1,2,3,4,5,6,6,7,8,9,0,1,2,3,4,5,6,7,9, 10, 11, 1,2,3,4,5,
    0x52, 0xB8, 0x6B, 0x24, 0x13, 0x73, 0xFF, 1,2,3,4,5,6,6,7,8,9,0,1,2,3,4,5,6,7,9, 10,
    0x03, 0x61, 0x5E, 0x97, 0xA6, 0xDD, 0x8C, 0x18 };
const uint8_t srcData4[] = {
    0x28, 0x82, 0x7B, 0x9B, 0xBD, 0x3F, 0xDC, 0x41, 0x8C, 0x46, 0xBB, 0x42, 0xD4, 0x9A, 0x32, 0xC7, 0x0C, 0x0F,
    0x13, 0x73, 0xFF, 1,2,3,4,5,6,6,7,8,9,0,1,2,3,4,5,6,7,9, 10,
    0x13, 0x73, 0xFF, 1,2,3,4,5,6,6,7,8,9,0,1,2,3,4,5,6,7,9, 10,
    0x13, 0x73, 0xFF, 1,2,3,4,5,6,6,7,8,9,0,1,2,3,4,5,6,7,9, 10, 11, 1,2,3,4,5,
    0x13, 0x73, 0xFF, 1,2,3,4,5,6,6,7,8,9,0,1,2,3,4,5,6,7,9, 10,
    0xA6, 0xDD, 0x8C, 0x18 };

const uint8_t keystring[MAC_BLOCK_SIZE] = { 0xB3,0x35,0xFB,0xB5,0x14,0x00,0xB8,0x0B,0xB3,0x9B,0xE1,0xBF,0xD9,0x32,0x78,0x8C };
/* clang-format on */

static sss_status_t test_mac_multiStep_algo(userCtx_t *pUserCtx,
    const uint8_t expectedData[MAC_BLOCK_SIZE],
    const uint16_t srcData1Len,
    const uint16_t srcData2Len,
    const uint16_t srcData3Len,
    const uint16_t srcData4Len
);


sss_status_t test_mac_multiStep_algo_mmm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0x90,0xFA,0x63,0x22,0x11,0x9D,0x60,0xDB,0x82,0x9D,0xC7,0xCF,0xC3,0x98,0x35,0x6C,};


    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_mmz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
            {0xF5,0x89,0x46,0x96,0x10,0x1B,0x57,0x37,0xD1,0xC5,0x62,0x16,0x9D,0xFF,0x88,0x03,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_mmp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
            {0xD1,0x05,0x5E,0xF8,0x98,0xFF,0x74,0xF0,0xFC,0x44,0x79,0xE5,0xD9,0x52,0x34,0xEE,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_mmq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
            {0x6C,0xEB,0x44,0x3F,0xAF,0x8D,0x21,0x78,0x08,0xD0,0x7B,0xC8,0xF0,0x16,0x03,0x4B,};


    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_mzm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
            {0xC0,0x80,0xB8,0x40,0x88,0xC4,0x0E,0x98,0x24,0xA8,0x93,0xD0,0xA1,0xC9,0xD1,0x29,};


    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_mzz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0x10,0xEF,0xEE,0x75,0xFD,0xE7,0xDF,0xD9,0x45,0xE5,0x98,0xE3,0x31,0x34,0xF8,0x6A,};


    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_mzp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0xD4,0xB0,0xD8,0x39,0x31,0x07,0x78,0xD2,0x9D,0x51,0x2D,0x97,0x6B,0x05,0x07,0xC2,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_mzq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0x06,0xD2,0xB2,0x05,0x6F,0x6C,0x6C,0x44,0xF6,0xDD,0x51,0x9A,0x0D,0x7B,0x33,0x47,};


    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_mpm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0xB6,0xE3,0x43,0x83,0xC1,0x33,0x4B,0x07,0xD8,0x3C,0xB4,0xDA,0xC2,0x7F,0xB1,0x56,};


    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_mpz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
    { 0x2C,0x86,0x75,0x84,0xD7,0x25,0x75,0x56,0x5A,0xE3,0xDA,0x8A,0x76,0xD5,0x20,0x78, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_mpp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x29,0x34,0xF6,0xE5,0xC5,0x1D,0x99,0xC6,0xB7,0x39,0x71,0xC9,0xAC,0x06,0xD1,0x35, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_mpq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0x71,0x12,0x09,0x62,0x81,0x25,0x54,0xF4,0x7B,0x09,0x1F,0xB9,0xE6,0x23,0x7E,0x3D,};


    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_mqm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0x8D,0xF2,0x84,0xE5,0x30,0xA0,0x1A,0x01,0xDF,0x84,0x6E,0x88,0xB1,0x6C,0xC2,0x50,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_mqz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
    { 0x80,0x5C,0xD9,0xBB,0x9E,0x6F,0xBB,0x98,0x1C,0xF1,0x7C,0x89,0x6B,0x05,0x86,0x73, };
    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_mqp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
            {0x6E,0xCC,0x06,0xED,0xC9,0x55,0xED,0xC6,0xA1,0x41,0x0A,0xE2,0xB7,0xF5,0x9E,0x82,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_mqq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0x5E,0xDC,0x15,0x66,0xE0,0x67,0x89,0xF8,0x2C,0x2A,0xC3,0xC4,0x53,0xC1,0x1C,0x01,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_zmm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
            {0xD7,0xE2,0x26,0x83,0xC6,0xC5,0x35,0xD0,0xEE,0x7D,0xB0,0x12,0x49,0xF0,0x54,0x10,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_zmz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
    { 0xC8,0xDC,0xC5,0xBC,0x31,0x3D,0x7F,0x8F,0xA1,0x76,0x47,0xF1,0xBD,0xED,0xFF,0xCE, };
    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_zmp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xCA,0x15,0xFF,0x1B,0xE1,0x2A,0xAC,0x2C,0xF5,0x8E,0x57,0x3B,0x7B,0x18,0x27,0x63, };;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_zmq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x51,0x71,0x68,0xAE,0x0D,0x71,0x00,0x38,0x25,0x90,0xD4,0x20,0x6C,0xDA,0x4C,0xBE, };;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_zzm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x15,0x5D,0xF8,0x66,0x68,0xD8,0x48,0xB9,0x6C,0x32,0x41,0x34,0x1B,0x59,0x2A,0x62, };;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_zzz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x59,0x3D,0x3F,0x51,0x75,0xED,0x59,0x17,0xF4,0x2D,0x1F,0xEF,0x9F,0x52,0xBF,0x53, };;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_zzp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x9A,0xB9,0xCB,0xE5,0x79,0x50,0xF3,0x78,0x66,0xCF,0x6E,0x4A,0xA5,0x77,0x50,0x1F, };;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_zzq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xAB,0xA8,0x71,0x31,0xAC,0x2A,0x1A,0x1A,0xA6,0x5A,0x32,0xEB,0x51,0x64,0x1F,0x29, };;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_zpm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x72,0xCF,0xEB,0xC5,0x5E,0xA0,0xD9,0x36,0x53,0xB6,0x8F,0xF7,0x7E,0xD8,0x75,0xE0, };;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_zpz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xB0,0x50,0x69,0x02,0x73,0x9D,0x0A,0x73,0x46,0x15,0xC7,0x76,0xC7,0x25,0x25,0xEF, };


    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_zpp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xF0,0x26,0xF3,0xEF,0xAE,0x80,0x65,0xE5,0x45,0x23,0xF0,0xF6,0xBC,0xD0,0x7D,0x54, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_zpq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x78,0x31,0x80,0x6A,0xEE,0xC4,0xE5,0x22,0x08,0x03,0xE6,0x1C,0x80,0x96,0xBB,0x8F, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_zqm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x52,0xD2,0x2B,0x58,0xC9,0x90,0xDA,0xA0,0x85,0x9B,0x98,0xE2,0x23,0xB8,0xF6,0x0B, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_zqz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xC5,0x75,0xC5,0x03,0x9F,0x31,0xDF,0x67,0xCF,0x05,0xCB,0xE3,0xD4,0x9D,0x5E,0x08, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_zqp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x33,0x94,0xBA,0x46,0xFF,0x8E,0x5E,0x82,0xB2,0xFF,0x7A,0xCB,0xBA,0x27,0x85,0x57, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_zqq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x3A,0x98,0x00,0xFF,0x90,0x63,0x90,0x16,0x41,0xB8,0xFF,0x2B,0xF9,0x30,0xB5,0xE1, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_pmm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x42,0xF5,0x9A,0x2B,0x3A,0xC6,0x85,0x87,0x8F,0xE4,0x46,0x03,0x94,0x3D,0x5D,0xF7, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_pmz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x2F,0xB3,0x72,0xAE,0x9E,0xC3,0x41,0xE9,0x6F,0x35,0x67,0xB8,0xB3,0x0A,0x4C,0x4B, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_pmp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xDE,0x6B,0x4C,0xC8,0x39,0xDB,0xDB,0xE4,0x65,0x9B,0x5A,0x2A,0x9F,0x7D,0xA5,0xA2, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_pmq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xE6,0x0B,0x48,0x5A,0x7E,0xB6,0xC0,0x48,0xA9,0xA6,0xCE,0xE5,0x1D,0x16,0x8B,0xD3, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_pzm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xBB,0xA4,0x76,0x83,0x2B,0xEA,0xEA,0x7D,0x4D,0x77,0x0D,0x07,0x19,0xC5,0x87,0x3D, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_pzz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0x38,0x11,0x1B,0xD9,0xF1,0x4D,0x07,0x33,0x28,0xCB,0xB3,0x93,0x95,0xBC,0x69,0x98, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_pzp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xD7,0xE0,0x43,0x16,0x1E,0x42,0x6B,0x81,0x97,0x4E,0xFC,0x0E,0x39,0xD5,0xAC,0xB8, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_pzq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xE5,0xC8,0xF3,0x69,0xBB,0x35,0x95,0xE1,0x8B,0xCD,0x8F,0x93,0x26,0xD2,0x27,0x10, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_ppm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xE9,0xCC,0x28,0x02,0x30,0x54,0xA0,0x0C,0x08,0x21,0x2E,0xB7,0x9F,0x71,0x94,0xEF, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_ppz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xD0,0x8C,0x24,0x0E,0x7F,0x70,0x34,0x77,0x63,0xE7,0x76,0xF8,0xB2,0xAD,0xF4,0x87, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_ppp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0xE4,0xDF,0x2B,0x4B,0xB7,0x24,0xA5,0x7D,0xA5,0x31,0xB2,0x2D,0x82,0x71,0x66,0xFE,};
;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_ppq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =         {0x17,0xC6,0x24,0xD0,0x4C,0x3C,0x08,0x1C,0x26,0xEB,0x18,0x79,0xFC,0x8E,0x17,0x53,};
;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_pqm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =        
    { 0x9E,0xC2,0x0A,0xE5,0x5C,0xC1,0x90,0xA2,0xE6,0x23,0xD4,0x1E,0xFB,0x5D,0x98,0x32, };

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_pqz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] = { 0xE7,0x6A,0xA2,0xC1,0xDE,0x97,0xDE,0x0F,0x09,0x61,0xD0,0xA2,0x40,0xBC,0x8E,0x6D, };;

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_pqp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x0F,0x45,0x6C,0x7F,0x52,0xFE,0xDB,0xF7,0xE8,0x45,0x0C,0x9D,0xA7,0x35,0x24,0x7A,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_pqq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x7F,0x49,0xE2,0x54,0xE5,0xA1,0x82,0xDD,0x5E,0xC3,0xC1,0x1B,0x48,0xD3,0x16,0x27,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_qmm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x5D,0x5C,0x78,0x11,0x8F,0x14,0x65,0xC3,0xC7,0x61,0xE7,0x3B,0x84,0xF6,0xCE,0xCE,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_qmz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x4A,0x71,0xA4,0xE5,0x8D,0xD0,0xA0,0x66,0xDE,0x31,0xB2,0xE7,0xAD,0xB8,0xD9,0xF6,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_qmp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
       {0x51,0x6A,0xBE,0xEB,0x00,0x86,0xDE,0xB6,0xAC,0x89,0x9A,0x9F,0x87,0xE9,0x62,0x86,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_qmq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x78,0x14,0x6B,0xA9,0x06,0xFC,0x66,0x36,0xDC,0x43,0xD0,0x97,0x2B,0xDF,0x1D,0xEF,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) - 1,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_qzm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x37,0xCA,0xAD,0xE1,0xE4,0x2A,0x93,0xC6,0xB6,0x84,0xE6,0xA4,0xF3,0x4D,0x56,0x9D,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_qzz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0xB6,0x4F,0x1A,0x86,0xF8,0xFA,0x78,0x19,0xE0,0x7B,0xB3,0x22,0x27,0x9F,0xF5,0xED,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_qzp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0xC0,0x33,0xDA,0xA7,0x1B,0xD6,0xA1,0x9B,0x2F,0x9E,0x42,0x2C,0x55,0x45,0xE3,0xE4,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_qzq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x33,0x18,0xE9,0x1D,0xDD,0x67,0xDF,0x78,0xAB,0xB2,0xE0,0x81,0xA0,0xAF,0xC2,0x78,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4),
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_qpm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x20,0x2C,0x59,0x8B,0x5F,0xFD,0xBB,0x3D,0x8B,0xC7,0x21,0x2F,0x2A,0x74,0xF3,0xC2,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_qpz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x84,0x2C,0xBC,0xD2,0x1A,0xEB,0xD3,0xF4,0xA6,0xCF,0x3D,0xD7,0xAF,0xDF,0xF7,0xB9,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_qpp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x1B,0x08,0xEE,0x62,0x89,0xDA,0x5E,0x57,0x87,0x20,0xE2,0x5D,0x85,0x8C,0x7E,0xB4,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_qpq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0xCB,0xE6,0xF2,0x93,0x55,0x14,0xFA,0x5C,0x44,0x49,0xDB,0x55,0x82,0x43,0xFE,0x7E,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) + 1,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


sss_status_t test_mac_multiStep_algo_qqm(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x6E,0xD0,0x7C,0x27,0x21,0x48,0x25,0x41,0xC4,0xCD,0xEE,0x53,0x9B,0x3F,0xC9,0x95,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) - 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_qqz(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x4D,0x4C,0x25,0x1E,0x6D,0x0D,0xC3,0x81,0x98,0x5B,0xEC,0xC7,0x10,0x5F,0xE7,0xD4,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4));
    return status;
}


sss_status_t test_mac_multiStep_algo_qqp(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0x6D,0x5D,0xF5,0x9F,0x0B,0xC1,0x67,0xBC,0xF3,0x70,0x95,0x9B,0x91,0x08,0x2B,0x64,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) + 1);
    return status;
}


sss_status_t test_mac_multiStep_algo_qqq(userCtx_t *pUserCtx) {
    sss_status_t status;
    const uint8_t expectedData[MAC_BLOCK_SIZE] =
        {0xB8,0xE0,0x0B,0x59,0xAC,0x33,0xAE,0x74,0xAF,0x09,0x30,0xC0,0x2A,0xFC,0xF3,0x11,};

    status = test_mac_multiStep_algo(pUserCtx, expectedData,
        MAC_BLOCK_SIZE,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) * 0,
        (MAC_BLOCK_SIZE * 4) * 0);
    return status;
}


static sss_status_t test_mac_multiStep_algo(userCtx_t *pUserCtx,
    const uint8_t expectedData[MAC_BLOCK_SIZE],
    const uint16_t srcData1Len,
    const uint16_t srcData2Len,
    const uint16_t srcData3Len,
    const uint16_t srcData4Len
    )
{
    sss_status_t status;
    uint8_t outdata[256] = { 0 };
    size_t outdatLen = sizeof(outdata);
    uint8_t count = 0;

    sss_algorithm_t algorithm = kAlgorithm_SSS_CMAC_AES;
    sss_mode_t mode = kMode_SSS_Mac;

    status = sss_host_key_object_allocate_handle(&pUserCtx->key,
        __LINE__,
        kSSS_KeyPart_Default,
        kSSS_CipherType_CMAC,
        16,
        kKeyObject_Mode_Transient);
    if (status != kStatus_SSS_Success)
    {
        LOG_E("Userkey_key_object_alloc_mac_multiStep Failed!!!");
        goto exit;
    }

    status = sss_host_key_store_set_key(&pUserCtx->ks,
        &pUserCtx->key,
        keystring,
        sizeof(keystring),
        sizeof(keystring) * 8,
        NULL,
        0);
    if (status != kStatus_SSS_Success)
    {
        LOG_E("Userkey_set_key_mac_multiStep Failed!!!");
        goto exit;
    }

    status = sss_host_mac_context_init(
        &pUserCtx->mac, &pUserCtx->session, &pUserCtx->key, algorithm, mode);
    if (status != kStatus_SSS_Success)
    {
        LOG_E("Userkey_mac_context_init_multiStep Failed!!!");
        goto exit;
    }

    status = sss_host_mac_init(&pUserCtx->mac);
    if (status != kStatus_SSS_Success)
    {
        LOG_E("Userkey_mac_init_multiStep Failed!!!");
        goto exit;
    }

    if (srcData1Len > 0) {
        status = sss_host_mac_update(&pUserCtx->mac, gSRCData1, srcData1Len);
        if (status != kStatus_SSS_Success)
        {
            LOG_E("Userkey_mac_update_multiStep step1 Failed!!!");
            goto exit;
        }
    }


    if (srcData2Len > 0) {
        status = sss_host_mac_update(&pUserCtx->mac, gSRCData2, srcData2Len);
        if (status != kStatus_SSS_Success)
        {
            LOG_E("Userkey_mac_update_multiStep step2 Failed!!!");
            goto exit;
        }
    }

    if (srcData3Len > 0) {
        status = sss_host_mac_update(&pUserCtx->mac, srcData3, srcData3Len);
        if (status != kStatus_SSS_Success)
        {
            LOG_E("Userkey_mac_update_multiStep step2 Failed!!!");
            goto exit;
        }
    }
    if (srcData4Len > 0) {
        status = sss_host_mac_update(&pUserCtx->mac, srcData4, srcData4Len);
        if (status != kStatus_SSS_Success)
        {
            LOG_E("Userkey_mac_update_multiStep step2 Failed!!!");
            goto exit;
        }
    }
    status = sss_host_mac_finish(&pUserCtx->mac, outdata, &outdatLen);
    if (status != kStatus_SSS_Success)
    {
        LOG_E("Userkey_mac_finish_multiStep Failed!!!");
        goto exit;
    }
    LOG_AU8_I(outdata, outdatLen);
    for (count = 0;count < outdatLen;count++)
    {
        if (outdata[count] != expectedData[count])
        {
            LOG_E("Crypto results are wrong mac_multiStep !!!");
            LOG_MAU8_E("Expected", expectedData, MAC_BLOCK_SIZE);
            printf("\n        {");
            for (size_t i = 0; i < outdatLen; i++) {
                printf("0x%02X,", outdata[i]);
            }
            printf("};\n\n");
            //LOG_MAU8_E("Got", outdata, outdatLen);
            status = kStatus_SSS_Fail;
            break;
        }
    }

#if 0
   // sss_host_key_object_free(&pUserCtx->key);
    sss_host_mac_context_free(&pUserCtx->mac);
    status = sss_host_mac_context_init(
        &pUserCtx->mac, &pUserCtx->session, &pUserCtx->key, algorithm, mode);
    status = sss_host_mac_init(&pUserCtx->mac);
    status = sss_host_mac_update(&pUserCtx->mac, expectedData, 16);
    status = sss_host_mac_update(&pUserCtx->mac, srcData3, srcData3Len);
    sss_host_mac_finish(&pUserCtx->mac, outdata, &outdatLen);
#endif

exit:
    sss_host_key_object_free(&pUserCtx->key);
    sss_host_mac_context_free(&pUserCtx->mac);
    sss_host_key_store_context_free(&pUserCtx->ks);
    return status;
}