/**
 * @file sdrv_crypto_utility.c
 * @brief crypto utility api
 *
 * @copyright Copyright (c) 2021  Semidrive Semiconductor.
 *            All rights reserved.
 */

#include "sdrv_crypto_utility.h"

#ifdef PKE_PRINT_BUF

void print_buf_U8(uint8_t buf[], uint32_t byteLen, char name[])
{
    uint32_t i;

    printf(" %s: \n", name);
    printf(" addr:0x%x:", (uint32_t)buf);

    for (i = 0; i < byteLen; i++) {
        printf("%02x", buf[i]);
    }

    printf("\n");
}

void print_buf_U32(uint32_t buf[], uint32_t wordLen, char name[])
{
    uint32_t i;

    printf(" %s: %08x\n", name, (uint32_t)buf);

    for (i = 0; i < wordLen; i++) {
        printf("%08x", buf[i]);
    }

    printf("\n");
}

void print_BN_buf_U32(uint32_t buf[], uint32_t wordLen, char name[])
{
    uint32_t i;

    printf(" %08x %s: \n", (uint32_t)buf, name);

    for (i = 0; i < wordLen; i++) {
        printf("%08x", buf[wordLen - 1 - i]);
    }

    printf("\n");
}
#endif

void memcpy_(void *dst, void *src, uint32_t size)
{
    uint8_t *a = (uint8_t *)dst;
    uint8_t *b = (uint8_t *)src;

    uint32_t *aa = (uint32_t *)dst;
    uint32_t *bb = (uint32_t *)src;
    uint32_t i, count, tmp;

    if ((((uint32_t)dst) & 3) || (((uint32_t)src) & 3)) {
        while (size--) {
            *a++ = *b++;
        }
    } else {
        count = size / 4;

        for (i = 0; i < count; i++) {
            *aa++ = *bb++;
        }

        tmp = size & 3;

        if (tmp) {
            a += (size & (~0x03));
            b += (size & (~0x03));

            while (tmp--) {
                *a++ = *b++;
            }
        }
    }
}

void memset_(void *dst, uint8_t value, uint32_t size)
{
    uint8_t *a = (uint8_t *)dst;
    uint32_t i, count, tmp;

    tmp = ((uint32_t)dst) & 3;

    if (tmp) {
        if (size > 4 - tmp) {
            for (i = 0; i < 4 - tmp; i++) {
                *a++ = value;
            }

            size -= (4 - tmp);
        } else {
            for (i = 0; i < size; i++) {
                *a++ = value;
            }

            return;
        }
    }

    count = size / 4;

    if (count) {
        tmp = value;
        tmp = (tmp << 8) | value;
        tmp = (tmp << 8) | value;
        tmp = (tmp << 8) | value;

        for (i = 0; i < count; i++) {
            *((uint32_t *)a) = tmp;
            a += 4;
        }
    }

    tmp = size & 3;

    if (tmp) {
        for (i = 0; i < tmp; i++) {
            *a++ = value;
        }
    }
}

int8_t memcmp_(void *m1, void *m2, uint32_t size)
{
    int8_t *a = (int8_t *)m1;
    int8_t *b = (int8_t *)m2;
    int8_t c;

    while (size--) {
        c = (*a++ - *b++);

        if (c) {
            return c;
        }
    }

    return 0;
}

/**
 * @brief set uint32 buffer
 *
 * This function set uint32 buffer
 *
 * @param[out] a output word buffer
 * @param[in] value input word value
 * @param[in] wordLen word length of buffer a
 */
void uint32_set(uint32_t *a, uint32_t value, uint32_t wordLen)
{
    while (wordLen) {
        a[--wordLen] = value;
    }
}

/* function: copy uint32 buffer
 * parameters:
 *     dst ------------------------ output, output word buffer
 *     src ------------------------ input, input word buffer
 *     wordLen -------------------- input, word length of buffer dst or src
 * return: none
 * caution:
 */
void uint32_copy(uint32_t *dst, uint32_t *src, uint32_t wordLen)
{
    uint32_t i;

    if (dst != src) {
        for (i = 0; i < wordLen; i++) {
            dst[i] = src[i];
        }
    }
}

/* function: clear uint32 buffer
 * parameters:
 *     a -------------------------- input&output, word buffer a
 *     aWordLen ------------------- input, word length of buffer a
 * return: none
 * caution:
 */
void uint32_clear(uint32_t *a, uint32_t wordLen)
{
    uint32_t i = wordLen;

    while (i) {
        a[--i] = 0;
    }
}

static void uint32_sleep1(uint32_t count)
{
    uint32_t a = 0;
    uint32_t b = 0;
    uint32_t result = 0;
    uint32_t i;

    for (i = 0; i < count; i++) {
        result |= ((a + i) - (b + i));
    }
}

static void uint32_sleep2(uint32_t count)
{
    uint32_t a = 0;
    uint32_t b = 0;
    uint32_t result = 0;
    uint32_t i;

    for (i = 0; i < count; i++) {
        result |= ((a + i) ^ (b + i));
    }
}

/* function: sleep for a while
 * parameters:
 *     count ---------------------- input, count
 * return: none
 * caution:
 */

void uint32_sleep(uint32_t count, uint8_t rand)
{
    uint8_t rand1 = rand & 0x01;

    if (0 == rand1) {
        uint32_sleep1(count);
    } else {
        uint32_sleep2(count);
    }
}

/* function: convert 0x1122334455667788 to 0x4433221188776655
 * parameters:
 *     in ------------------------- source address
 *     out ------------------------ destination address
 *     wordLen -------------------- word length of in/out
 * return: none
 * caution:
 */
void uint32_endian_reverse(uint8_t *in, uint8_t *out, uint32_t wordLen)
{
    uint8_t tmp;

    if (in == out) {
        while (wordLen > 0) {
            tmp = *in;
            *in = *(in + 3);
            *(in + 3) = tmp;
            in += 1;
            tmp = *in;
            *in = *(in + 1);
            *(in + 1) = tmp;
            wordLen--;
            in += 3;
        }
    } else {
        while (wordLen > 0) {
            *(out) = *(in + 3);
            *(out + 1) = *(in + 2);
            *(out + 2) = *(in + 1);
            *(out + 3) = *(in);
            wordLen--;
            in += 4;
            out += 4;
        }
    }
}

/* function: reverse word array
 * parameters:
 *     in ------------------------- input, input buffer
 *     out ------------------------ output, output buffer
 *     wordLen -------------------- input, word length of in or out
 * return: none
 * caution:
 *    1. in and out could point the same buffer
 */
void reverse_word_array(uint8_t *in, uint32_t *out, uint32_t wordLen)
{
    uint32_t idx, round = wordLen >> 1;
    uint32_t tmp;
    uint32_t *p_in;

    if (((uint32_t)(in)) & 3) {
        memcpy_(out, in, wordLen << 2);
        p_in = out;
    } else {
        p_in = (uint32_t *)in;
    }

    for (idx = 0; idx < round; idx++) {
        tmp = p_in[idx];
        out[idx] = p_in[wordLen - 1 - idx];
        out[wordLen - 1 - idx] = tmp;
    }

    if ((wordLen & 0x1) && (p_in != out)) {
        out[round] = p_in[round];
    }
}

/* function: reverse byte array
 * parameters:
 *     in ------------------------- input, input buffer
 *     out ------------------------ output, output buffer
 *     byteLen -------------------- input, byte length of in or out
 * return: none
 * caution:
 *    1. in and out could point the same buffer
 */
void reverse_byte_array(uint8_t *in, uint8_t *out, uint32_t byteLen)
{
    uint32_t idx, round = byteLen >> 1;
    uint8_t tmp;

    for (idx = 0; idx < round; idx++) {
        tmp = in[idx];
        out[idx] = in[byteLen - 1 - idx];
        out[byteLen - 1 - idx] = tmp;
    }

    if ((byteLen & 0x1) && (in != out)) {
        out[round] = in[round];
    }
}

/* function: C = A XOR B
 * parameters:
 *     A -------------------------- input, byte buffer a
 *     B -------------------------- input, byte buffer b
 *     C -------------------------- output, C = A XOR B
 *     byteLen -------------------- input, byte length of A,B,C
 * return: none
 * caution:
 */
void uint8_xor(uint8_t *a, uint8_t *b, uint8_t *c, uint32_t byteLen)
{
    uint32_t i;

    for (i = 0; i < byteLen; i++) {
        c[i] = a[i] ^ b[i];
    }
}

/* function: get real bit length of big number a of wordLen words
 */
uint32_t get_valid_bits(const uint32_t *a, uint32_t wordLen)
{
    uint32_t i = 0;
    uint32_t j = 0;

    if (0 == wordLen) {
        return 0;
    }

    for (i = wordLen; i > 0; i--) {
        if (a[i - 1]) {
            break;
        }
    }

    if (0 == i) {
        return 0;
    }

    for (j = 32; j > 0; j--) {
        if (a[i - 1] & (((uint32_t)0x1) << (j - 1))) {
            break;
        }
    }

    return ((i - 1) << 5) + j;
}

/* function: get real word lenth of big number a of max_words words
 * parameters:
 *     a -------------------------- input, big integer a
 *     max_words ------------------ input, max word length of a
 * return: real word lenth of big number a
 * caution:
 */
uint32_t get_valid_words(uint32_t *a, uint32_t max_words)
{
    uint32_t i;

    for (i = max_words; i > 0; i--) {
        if (a[i - 1]) {
            return i;
        }
    }

    return 0;
}

/* function: check whether big number or uint8_t buffer a is all zero or not
 * parameters:
 *     a -------------------------- input, byte buffer a
 *     aByteLen ------------------- input, byte length of a
 * return: 0(a is not zero),1(a is all zero)
 * caution:
 */
uint8_t uint8_bignum_check_zero(uint8_t a[], uint32_t aByteLen)
{
    uint32_t i;

    for (i = 0; i < aByteLen; i++) {
        if (a[i]) {
            return 0;
        }
    }

    return 1;
}

/* function: check whether big number or uint32_t buffer a is all zero or not
 * parameters:
 *     a -------------------------- input, big integer or word buffer a
 *     aWordLen ------------------- input, word length of a
 * return: 0(a is not zero), 1(a is all zero)
 * caution:
 */
uint8_t uint32_bignum_check_zero(uint32_t a[], uint32_t aWordLen)
{
    uint32_t i;

    for (i = 0; i < aWordLen; i++) {
        if (a[i]) {
            return 0;
        }
    }

    return 1;
}

/* function: compare big integer a and b
 * parameters:
 *     a -------------------------- input, big integer a
 *     aWordLen ------------------- input, word length of a
 *     b -------------------------- input, big integer b
 *     bWordLen ------------------- input, word length of b
 * return:
 *     0:a=b,   1:a>b,   -1: a<b
 * caution:
 */
int32_t uint32_bignumcmp(uint32_t *a, uint32_t aWordLen, uint32_t *b,
                         uint32_t bWordLen)
{
    int32_t i;

    aWordLen = get_valid_words(a, aWordLen);
    bWordLen = get_valid_words(b, bWordLen);

    if (aWordLen > bWordLen) {
        return 1;
    }

    if (aWordLen < bWordLen) {
        return -1;
    }

    for (i = (aWordLen - 1); i >= 0; i--) {
        if (a[i] > b[i]) {
            return 1;
        }

        if (a[i] < b[i]) {
            return -1;
        }
    }

    return 0;
}

/* function: securely compare big integer a and b
 * parameters:
 *     a -------------------------- input, big integer a
 *     b -------------------------- input, big integer b
 *     wordLen -------------------- input, word length of a and b
 * return: 0(a=b), other(a!=b)
 * caution:
 */
static uint32_t uint32_sec_cmp1(uint32_t *a, uint32_t *b, uint32_t wordLen)
{
    uint32_t i, result;

    result = 0;

    for (i = 0; i < wordLen; i++) {
        result |= (a[i] - b[i]);
    }

    return result;
}

/* function: securely compare big integer a and b
 * parameters:
 *     a -------------------------- input, big integer a
 *     b -------------------------- input, big integer b
 *     wordLen -------------------- input, word length of a and b
 * return: 0(a=b), other(a!=b)
 * caution:
 */
static uint32_t uint32_sec_cmp2(uint32_t *a, uint32_t *b, uint32_t wordLen)
{
    uint32_t i, result;

    result = 0;

    for (i = 0; i < wordLen; i++) {
        result |= (a[i] ^ b[i]);
    }

    return result;
}

/* function: securely compare big integer a and b
 * parameters:
 *     a -------------------------- input, big integer a
 *     b -------------------------- input, big integer b
 *     wordLen -------------------- input, word length of a and b
 * return: 0(a=b), other(a!=b)
 * caution:
 */
uint32_t uint32_sec_cmp(uint32_t *a, uint32_t *b, uint32_t wordLen,
                        uint8_t rand)
{
    uint8_t rand1 = rand & 0x01;

    if (0 == rand1) {
        return uint32_sec_cmp1(a, b, wordLen);
    } else {
        return uint32_sec_cmp2(a, b, wordLen);
    }
}

/* function: for a = b*2^t, b is odd, get t
 * parameters:
 *     a -------------------------- big integer a
 * return:
 *     number of multiple by 2, for a
 * caution:
 *     1. make sure a != 0
 */
uint32_t get_multiple2_number(uint32_t a[])
{
    uint32_t t, i = 0, j = 0;

    while (0 == (a[i])) {
        i++;
    }

    t = a[i];

    while (!(t & 1)) {
        j++;
        t >>= 1;
    }

    return (i << 5) + j;
}

/* function: a = a/(2^n)
 * parameters:
 *     a -------------------------- big integer a
 *     aWordLen ------------------- word length of a
 *     n -------------------------- exponent of 2^n
 * return:
 *     word length of a = a/(2^n)
 * caution:
 *     1. make sure aWordLen is real word length of a
 *     2. a may be 0, then aWordLen is 0, to make sure aWordLen-1 is available,
 * so data type of aWordLen is int32_t, not uint32_t
 */
uint32_t big_div2n(uint32_t a[], int32_t aWordLen, uint32_t n)
{
    int32_t i;
    uint32_t j;

    aWordLen = get_valid_words(a, aWordLen);

    if (0 == n) {
        return aWordLen;
    }

    if (!aWordLen) {
        return 0;
    }

    if (n <= 32) {
        for (i = 0; i < aWordLen - 1; i++) {
            a[i] >>= n;
            a[i] |= (a[i + 1] << (32 - n));
        }

        a[i] >>= n;

        if (!a[i]) {
            return i;
        }

        return aWordLen;
    } else {
        j = n >> 5;
        n &= 31;

        for (i = 0; i < aWordLen - (int32_t)j - 1; i++) {
            a[i] = a[i + j] >> n;
            a[i] |= (a[i + j + 1] << (32 - n));
        }

        a[i] = a[i + j] >> n;
        uint32_clear(a + aWordLen - j, j);

        if (!a[i]) {
            return i;
        }

        return aWordLen - j;
    }
}

/* Function: check whether a is equal to 1 or not
 * Parameters:
 *     a ---------------- pointer to uint32_t big integer a
 *     aWordLen --------- word length of big integer a
 * Return: 1(a is 1), 0(a is not 1)
 * Caution:
 */
uint8_t bigint_check_1(uint32_t a[], uint32_t aWordLen)
{
    uint32_t i;

    if (!aWordLen) {
        return 0;
    }

    if (a[0] != 1) {
        return 0;
    }

    for (i = 1; i < aWordLen; i++) {
        if (a[i]) {
            return 0;
        }
    }

    return 1;
}

/* function: check whether a is equal to p-1 or not
 * parameters:
 *     a ---------------- pointer to uint32_t big integer a
 *     p ---------------- pointer to uint32_t big integer p, p must be odd
 *     wordLen ---------- word length of a and p
 * return: 1(a is 1), 0(a is not 1)
 * caution:
 *     1. make sure p is odd
 */
uint8_t bigint_check_p_1(uint32_t a[], uint32_t p[], uint32_t wordLen)
{
    uint32_t i;

    if (!wordLen) {
        return 0;
    }

    if (a[0] != p[0] - 1) {
        return 0;
    }

    for (i = 1; i < wordLen; i++) {
        if (a[i] != p[i]) {
            return 0;
        }
    }

    return 1;
}

uint32_t ce_get_current_time(void)
{
#ifdef BOARD_KERNEL_TIMER
    return timer_get_current_time(&g_kernel_timer);
#else
    return 0;
#endif
}