修改上传所有文件

e3_176_ref/drivers/source/crypto/sdrv_crypto_utility.c

@@ -0,0 +1,698 @@
+/**
+ * @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
+}