FreeRTOS-202107.00.tar.gz

/* sp.c * * Copyright (C) 2006-2020 wolfSSL Inc. * * This file is part of wolfSSL. * * wolfSSL is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * wolfSSL is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA */ /* Implementation by Sean Parkinson. */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #include <wolfssl/wolfcrypt/settings.h> #include <wolfssl/wolfcrypt/error-crypt.h> #include <wolfssl/wolfcrypt/cpuid.h> #ifdef NO_INLINE #include <wolfssl/wolfcrypt/misc.h> #else #define WOLFSSL_MISC_INCLUDED #include <wolfcrypt/src/misc.c> #endif #if defined(WOLFSSL_HAVE_SP_RSA) || defined(WOLFSSL_HAVE_SP_DH) || \ defined(WOLFSSL_HAVE_SP_ECC) #ifdef RSA_LOW_MEM #ifndef WOLFSSL_SP_SMALL #define WOLFSSL_SP_SMALL #endif #endif #include <wolfssl/wolfcrypt/sp.h> #ifdef WOLFSSL_SP_ARM64_ASM #if defined(WOLFSSL_HAVE_SP_RSA) || defined(WOLFSSL_HAVE_SP_DH) #ifndef WOLFSSL_SP_NO_2048 /* Read big endian unsigned byte array into r. * * r A single precision integer. * size Maximum number of bytes to convert * a Byte array. * n Number of bytes in array to read. */ static void sp_2048_from_bin(sp_digit* r, int size, const byte* a, int n) { int i, j; byte* d; for (i = n - 1,j = 0; i >= 7; i -= 8) { r[j] = ((sp_digit)a[i - 0] << 0) | ((sp_digit)a[i - 1] << 8) | ((sp_digit)a[i - 2] << 16) | ((sp_digit)a[i - 3] << 24) | ((sp_digit)a[i - 4] << 32) | ((sp_digit)a[i - 5] << 40) | ((sp_digit)a[i - 6] << 48) | ((sp_digit)a[i - 7] << 56); j++; } if (i >= 0) { r[j] = 0; d = (byte*)r; switch (i) { case 6: d[n - 1 - 6] = a[6]; //fallthrough case 5: d[n - 1 - 5] = a[5]; //fallthrough case 4: d[n - 1 - 4] = a[4]; //fallthrough case 3: d[n - 1 - 3] = a[3]; //fallthrough case 2: d[n - 1 - 2] = a[2]; //fallthrough case 1: d[n - 1 - 1] = a[1]; //fallthrough case 0: d[n - 1 - 0] = a[0]; //fallthrough } j++; } for (; j < size; j++) { r[j] = 0; } } /* Convert an mp_int to an array of sp_digit. * * r A single precision integer. * size Maximum number of bytes to convert * a A multi-precision integer. */ static void sp_2048_from_mp(sp_digit* r, int size, const mp_int* a) { #if DIGIT_BIT == 64 int j; XMEMCPY(r, a->dp, sizeof(sp_digit) * a->used); for (j = a->used; j < size; j++) { r[j] = 0; } #elif DIGIT_BIT > 64 int i, j = 0; word32 s = 0; r[0] = 0; for (i = 0; i < a->used && j < size; i++) { r[j] |= ((sp_digit)a->dp[i] << s); r[j] &= 0xffffffffffffffffl; s = 64U - s; if (j + 1 >= size) { break; } /* lint allow cast of mismatch word32 and mp_digit */ r[++j] = (sp_digit)(a->dp[i] >> s); /*lint !e9033*/ while ((s + 64U) <= (word32)DIGIT_BIT) { s += 64U; r[j] &= 0xffffffffffffffffl; if (j + 1 >= size) { break; } if (s < (word32)DIGIT_BIT) { /* lint allow cast of mismatch word32 and mp_digit */ r[++j] = (sp_digit)(a->dp[i] >> s); /*lint !e9033*/ } else { r[++j] = 0L; } } s = (word32)DIGIT_BIT - s; } for (j++; j < size; j++) { r[j] = 0; } #else int i, j = 0, s = 0; r[0] = 0; for (i = 0; i < a->used && j < size; i++) { r[j] |= ((sp_digit)a->dp[i]) << s; if (s + DIGIT_BIT >= 64) { r[j] &= 0xffffffffffffffffl; if (j + 1 >= size) { break; } s = 64 - s; if (s == DIGIT_BIT) { r[++j] = 0; s = 0; } else { r[++j] = a->dp[i] >> s; s = DIGIT_BIT - s; } } else { s += DIGIT_BIT; } } for (j++; j < size; j++) { r[j] = 0; } #endif } /* Write r as big endian to byte array. * Fixed length number of bytes written: 256 * * r A single precision integer. * a Byte array. */ static void sp_2048_to_bin(sp_digit* r, byte* a) { int i, j; for (i = 31, j = 0; i >= 0; i--) { a[j++] = r[i] >> 56; a[j++] = r[i] >> 48; a[j++] = r[i] >> 40; a[j++] = r[i] >> 32; a[j++] = r[i] >> 24; a[j++] = r[i] >> 16; a[j++] = r[i] >> 8; a[j++] = r[i] >> 0; } } #ifndef WOLFSSL_SP_SMALL /* Multiply a and b into r. (r = a * b) * * r A single precision integer. * a A single precision integer. * b A single precision integer. */ static void sp_2048_mul_8(sp_digit* r, const sp_digit* a, const sp_digit* b) { sp_digit tmp[8]; __asm__ __volatile__ ( "ldp x9, x10, [%[a], 0]\n\t" "ldp x11, x12, [%[a], 16]\n\t" "ldp x13, x14, [%[a], 32]\n\t" "ldp x15, x16, [%[a], 48]\n\t" "ldp x17, x19, [%[b], 0]\n\t" "ldp x20, x21, [%[b], 16]\n\t" "ldp x22, x23, [%[b], 32]\n\t" "ldp x24, x25, [%[b], 48]\n\t" "# A[0] * B[0]\n\t" "mul x4, x9, x17\n\t" "umulh x5, x9, x17\n\t" "str x4, [%[tmp]]\n\t" "# A[0] * B[1]\n\t" "mul x7, x9, x19\n\t" "umulh x8, x9, x19\n\t" "adds x5, x5, x7\n\t" "# A[1] * B[0]\n\t" "mul x7, x10, x17\n\t" "adc x6, xzr, x8\n\t" "umulh x8, x10, x17\n\t" "adds x5, x5, x7\n\t" "adcs x6, x6, x8\n\t" "str x5, [%[tmp], 8]\n\t" "adc x4, xzr, xzr\n\t" "# A[0] * B[2]\n\t" "mul x7, x9, x20\n\t" "umulh x8, x9, x20\n\t" "adds x6, x6, x7\n\t" "# A[1] * B[1]\n\t" "mul x7, x10, x19\n\t" "adcs x4, x4, x8\n\t" "umulh x8, x10, x19\n\t" "adc x5, xzr, xzr\n\t" "adds x6, x6, x7\n\t" "# A[2] * B[0]\n\t" "mul x7, x11, x17\n\t" "adcs x4, x4, x8\n\t" "umulh x8, x11, x17\n\t" "adc x5, x5, xzr\n\t" "adds x6, x6, x7\n\t" "adcs x4, x4, x8\n\t" "str x6, [%[tmp], 16]\n\t" "adc x5, x5, xzr\n\t" "# A[0] * B[3]\n\t" "mul x7, x9, x21\n\t" "umulh x8, x9, x21\n\t" "adds x4, x4, x7\n\t" "# A[1] * B[2]\n\t" "mul x7, x10, x20\n\t" "adcs x5, x5, x8\n\t" "umulh x8, x10, x20\n\t" "adc x6, xzr, xzr\n\t" "adds x4, x4, x7\n\t" "# A[2] * B[1]\n\t" "mul x7, x11, x19\n\t" "adcs x5, x5, x8\n\t" "umulh x8, x11, x19\n\t" "adc x6, x6, xzr\n\t" "adds x4, x4, x7\n\t" "# A[3] * B[0]\n\t" "mul x7, x12, x17\n\t" "adcs x5, x5, x8\n\t" "umulh x8, x12, x17\n\t" "adc x6, x6, xzr\n\t" "adds x4, x4, x7\n\t" "adcs x5, x5, x8\n\t" "str x4, [%[tmp], 24]\n\t" "adc x6, x6, xzr\n\t" "# A[0] * B[4]\n\t" "mul x7, x9, x22\n\t" "umulh x8, x9, x22\n\t" "adds x5, x5, x7\n\t" "# A[1] * B[3]\n\t" "mul x7, x10, x21\n\t" "adcs x6, x6, x8\n\t" "umulh x8, x10, x21\n\t" "adc x4, xzr, xzr\n\t" "adds x