Replaced system SQLite with SQLCipher to support encrypted database
This commit is contained in:
Oleksii Zghurskyi
658
Sources/DataLiteC/libtomcrypt/math/gmp_desc.c
Normal file
658
Sources/DataLiteC/libtomcrypt/math/gmp_desc.c
Normal file
@@ -0,0 +1,658 @@
|
||||
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
|
||||
/* SPDX-License-Identifier: Unlicense */
|
||||
|
||||
#define DESC_DEF_ONLY
|
||||
#include "tomcrypt_private.h"
|
||||
|
||||
#ifdef GMP_DESC
|
||||
|
||||
#include <stdio.h>
|
||||
#include <gmp.h>
|
||||
|
||||
static int init(void **a)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
|
||||
*a = XCALLOC(1, sizeof(__mpz_struct));
|
||||
if (*a == NULL) {
|
||||
return CRYPT_MEM;
|
||||
}
|
||||
mpz_init(*a);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static void deinit(void *a)
|
||||
{
|
||||
LTC_ARGCHKVD(a != NULL);
|
||||
mpz_clear(a);
|
||||
XFREE(a);
|
||||
}
|
||||
|
||||
static int neg(const void *a, void *b)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
mpz_neg(b, a);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int copy(const void *a, void *b)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
mpz_set(b, a);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int init_copy(void **a, const void *b)
|
||||
{
|
||||
if (init(a) != CRYPT_OK) {
|
||||
return CRYPT_MEM;
|
||||
}
|
||||
return copy(b, *a);
|
||||
}
|
||||
|
||||
/* ---- trivial ---- */
|
||||
static int set_int(void *a, ltc_mp_digit b)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
mpz_set_ui(a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static unsigned long get_int(const void *a)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
return mpz_get_ui(a);
|
||||
}
|
||||
|
||||
static ltc_mp_digit get_digit(const void *a, int n)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
return mpz_getlimbn(a, n);
|
||||
}
|
||||
|
||||
static int get_digit_count(const void *a)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
return mpz_size(a);
|
||||
}
|
||||
|
||||
static int compare(const void *a, const void *b)
|
||||
{
|
||||
int ret;
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
ret = mpz_cmp(a, b);
|
||||
if (ret < 0) {
|
||||
return LTC_MP_LT;
|
||||
} else if (ret > 0) {
|
||||
return LTC_MP_GT;
|
||||
} else {
|
||||
return LTC_MP_EQ;
|
||||
}
|
||||
}
|
||||
|
||||
static int compare_d(const void *a, ltc_mp_digit b)
|
||||
{
|
||||
int ret;
|
||||
LTC_ARGCHK(a != NULL);
|
||||
ret = mpz_cmp_ui((__mpz_struct *)a, b);
|
||||
if (ret < 0) {
|
||||
return LTC_MP_LT;
|
||||
} else if (ret > 0) {
|
||||
return LTC_MP_GT;
|
||||
} else {
|
||||
return LTC_MP_EQ;
|
||||
}
|
||||
}
|
||||
|
||||
static int count_bits(const void *a)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
return mpz_sizeinbase(a, 2);
|
||||
}
|
||||
|
||||
static int count_lsb_bits(const void *a)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
return mpz_scan1(a, 0);
|
||||
}
|
||||
|
||||
|
||||
static int twoexpt(void *a, int n)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
mpz_set_ui(a, 0);
|
||||
mpz_setbit(a, n);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* ---- conversions ---- */
|
||||
|
||||
static const char rmap[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
|
||||
|
||||
/* read ascii string */
|
||||
static int read_radix(void *a, const char *b, int radix)
|
||||
{
|
||||
int ret;
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
if (radix == 64) {
|
||||
/* Sadly, GMP only supports radixes up to 62, but we need 64.
|
||||
* So, although this is not the most elegant or efficient way,
|
||||
* let's just convert the base 64 string (6 bits per digit) to
|
||||
* an octal string (3 bits per digit) that's twice as long. */
|
||||
char c, *tmp, *q;
|
||||
const char *p;
|
||||
int i;
|
||||
tmp = XMALLOC (1 + 2 * XSTRLEN (b));
|
||||
if (tmp == NULL) {
|
||||
return CRYPT_MEM;
|
||||
}
|
||||
p = b;
|
||||
q = tmp;
|
||||
while ((c = *p++) != 0) {
|
||||
for (i = 0; i < 64; i++) {
|
||||
if (c == rmap[i])
|
||||
break;
|
||||
}
|
||||
if (i == 64) {
|
||||
XFREE (tmp);
|
||||
/* printf ("c = '%c'\n", c); */
|
||||
return CRYPT_ERROR;
|
||||
}
|
||||
*q++ = '0' + (i / 8);
|
||||
*q++ = '0' + (i % 8);
|
||||
}
|
||||
*q = 0;
|
||||
ret = mpz_set_str(a, tmp, 8);
|
||||
/* printf ("ret = %d for '%s'\n", ret, tmp); */
|
||||
XFREE (tmp);
|
||||
} else {
|
||||
ret = mpz_set_str(a, b, radix);
|
||||
}
|
||||
return (ret == 0 ? CRYPT_OK : CRYPT_ERROR);
|
||||
}
|
||||
|
||||
/* write one */
|
||||
static int write_radix(const void *a, char *b, int radix)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
if (radix >= 11 && radix <= 36)
|
||||
/* If radix is positive, GMP uses lowercase, and if negative, uppercase.
|
||||
* We want it to use uppercase, to match the test vectors (presumably
|
||||
* generated with LibTomMath). */
|
||||
radix = -radix;
|
||||
mpz_get_str(b, radix, a);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* get size as unsigned char string */
|
||||
static unsigned long unsigned_size(const void *a)
|
||||
{
|
||||
unsigned long t;
|
||||
LTC_ARGCHK(a != NULL);
|
||||
t = mpz_sizeinbase(a, 2);
|
||||
if (mpz_cmp_ui((__mpz_struct *)a, 0) == 0) return 0;
|
||||
return (t>>3) + ((t&7)?1:0);
|
||||
}
|
||||
|
||||
/* store */
|
||||
static int unsigned_write(const void *a, unsigned char *b)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
mpz_export(b, NULL, 1, 1, 1, 0, a);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* read */
|
||||
static int unsigned_read(void *a, const unsigned char *b, unsigned long len)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
mpz_import(a, len, 1, 1, 1, 0, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* add */
|
||||
static int add(const void *a, const void *b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_add(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int addi(const void *a, ltc_mp_digit b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_add_ui(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* sub */
|
||||
static int sub(const void *a, const void *b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_sub(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int subi(const void *a, ltc_mp_digit b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_sub_ui(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* mul */
|
||||
static int mul(const void *a, const void *b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_mul(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int muli(const void *a, ltc_mp_digit b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_mul_ui(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* sqr */
|
||||
static int sqr(const void *a, void *b)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
mpz_mul(b, a, a);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* sqrtmod_prime */
|
||||
static int sqrtmod_prime(const void *n, const void *prime, void *ret)
|
||||
{
|
||||
int res, legendre, i;
|
||||
mpz_t t1, C, Q, S, Z, M, T, R, two;
|
||||
|
||||
LTC_ARGCHK(n != NULL);
|
||||
LTC_ARGCHK(prime != NULL);
|
||||
LTC_ARGCHK(ret != NULL);
|
||||
|
||||
/* first handle the simple cases */
|
||||
if (mpz_cmp_ui((__mpz_struct *)n, 0) == 0) {
|
||||
mpz_set_ui(ret, 0);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
if (mpz_cmp_ui((__mpz_struct *)prime, 2) == 0) return CRYPT_ERROR; /* prime must be odd */
|
||||
legendre = mpz_legendre(n, prime);
|
||||
if (legendre == -1) return CRYPT_ERROR; /* quadratic non-residue mod prime */
|
||||
|
||||
mpz_init(t1); mpz_init(C); mpz_init(Q);
|
||||
mpz_init(S); mpz_init(Z); mpz_init(M);
|
||||
mpz_init(T); mpz_init(R); mpz_init(two);
|
||||
|
||||
/* SPECIAL CASE: if prime mod 4 == 3
|
||||
* compute directly: res = n^(prime+1)/4 mod prime
|
||||
* Handbook of Applied Cryptography algorithm 3.36
|
||||
*/
|
||||
i = mpz_mod_ui(t1, prime, 4); /* t1 is ignored here */
|
||||
if (i == 3) {
|
||||
mpz_add_ui(t1, prime, 1);
|
||||
mpz_fdiv_q_2exp(t1, t1, 2);
|
||||
mpz_powm(ret, n, t1, prime);
|
||||
res = CRYPT_OK;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
/* NOW: Tonelli-Shanks algorithm */
|
||||
|
||||
/* factor out powers of 2 from prime-1, defining Q and S as: prime-1 = Q*2^S */
|
||||
mpz_set(Q, prime);
|
||||
mpz_sub_ui(Q, Q, 1);
|
||||
/* Q = prime - 1 */
|
||||
mpz_set_ui(S, 0);
|
||||
/* S = 0 */
|
||||
while (mpz_even_p(Q)) {
|
||||
mpz_fdiv_q_2exp(Q, Q, 1);
|
||||
/* Q = Q / 2 */
|
||||
mpz_add_ui(S, S, 1);
|
||||
/* S = S + 1 */
|
||||
}
|
||||
|
||||
/* find a Z such that the Legendre symbol (Z|prime) == -1 */
|
||||
mpz_set_ui(Z, 2);
|
||||
/* Z = 2 */
|
||||
while(1) {
|
||||
legendre = mpz_legendre(Z, prime);
|
||||
if (legendre == -1) break;
|
||||
mpz_add_ui(Z, Z, 1);
|
||||
/* Z = Z + 1 */
|
||||
}
|
||||
|
||||
mpz_powm(C, Z, Q, prime);
|
||||
/* C = Z ^ Q mod prime */
|
||||
mpz_add_ui(t1, Q, 1);
|
||||
mpz_fdiv_q_2exp(t1, t1, 1);
|
||||
/* t1 = (Q + 1) / 2 */
|
||||
mpz_powm(R, n, t1, prime);
|
||||
/* R = n ^ ((Q + 1) / 2) mod prime */
|
||||
mpz_powm(T, n, Q, prime);
|
||||
/* T = n ^ Q mod prime */
|
||||
mpz_set(M, S);
|
||||
/* M = S */
|
||||
mpz_set_ui(two, 2);
|
||||
|
||||
while (1) {
|
||||
mpz_set(t1, T);
|
||||
i = 0;
|
||||
while (1) {
|
||||
if (mpz_cmp_ui(t1, 1) == 0) break;
|
||||
mpz_powm(t1, t1, two, prime);
|
||||
i++;
|
||||
}
|
||||
if (i == 0) {
|
||||
mpz_set(ret, R);
|
||||
res = CRYPT_OK;
|
||||
goto cleanup;
|
||||
}
|
||||
mpz_sub_ui(t1, M, i);
|
||||
mpz_sub_ui(t1, t1, 1);
|
||||
mpz_powm(t1, two, t1, prime);
|
||||
/* t1 = 2 ^ (M - i - 1) */
|
||||
mpz_powm(t1, C, t1, prime);
|
||||
/* t1 = C ^ (2 ^ (M - i - 1)) mod prime */
|
||||
mpz_mul(C, t1, t1);
|
||||
mpz_mod(C, C, prime);
|
||||
/* C = (t1 * t1) mod prime */
|
||||
mpz_mul(R, R, t1);
|
||||
mpz_mod(R, R, prime);
|
||||
/* R = (R * t1) mod prime */
|
||||
mpz_mul(T, T, C);
|
||||
mpz_mod(T, T, prime);
|
||||
/* T = (T * C) mod prime */
|
||||
mpz_set_ui(M, i);
|
||||
/* M = i */
|
||||
}
|
||||
|
||||
cleanup:
|
||||
mpz_clear(t1); mpz_clear(C); mpz_clear(Q);
|
||||
mpz_clear(S); mpz_clear(Z); mpz_clear(M);
|
||||
mpz_clear(T); mpz_clear(R); mpz_clear(two);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* div */
|
||||
static int divide(const void *a, const void *b, void *c, void *d)
|
||||
{
|
||||
mpz_t tmp;
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
if (c != NULL) {
|
||||
mpz_init(tmp);
|
||||
mpz_divexact(tmp, a, b);
|
||||
}
|
||||
if (d != NULL) {
|
||||
mpz_mod(d, a, b);
|
||||
}
|
||||
if (c != NULL) {
|
||||
mpz_set(c, tmp);
|
||||
mpz_clear(tmp);
|
||||
}
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int div_2(const void *a, void *b)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
mpz_divexact_ui(b, a, 2);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* modi */
|
||||
static int modi(const void *a, ltc_mp_digit b, ltc_mp_digit *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
|
||||
*c = mpz_fdiv_ui(a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* gcd */
|
||||
static int gcd(const void *a, const void *b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_gcd(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* lcm */
|
||||
static int lcm(const void *a, const void *b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_lcm(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int addmod(const void *a, const void *b, const void *c, void *d)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
LTC_ARGCHK(d != NULL);
|
||||
mpz_add(d, a, b);
|
||||
mpz_mod(d, d, c);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int submod(const void *a, const void *b, const void *c, void *d)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
LTC_ARGCHK(d != NULL);
|
||||
mpz_sub(d, a, b);
|
||||
mpz_mod(d, d, c);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int mulmod(const void *a, const void *b, const void *c, void *d)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
LTC_ARGCHK(d != NULL);
|
||||
mpz_mul(d, a, b);
|
||||
mpz_mod(d, d, c);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int sqrmod(const void *a, const void *b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_mul(c, a, a);
|
||||
mpz_mod(c, c, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* invmod */
|
||||
static int invmod(const void *a, const void *b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_invert(c, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* setup */
|
||||
static int montgomery_setup(const void *a, void **b)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
*b = (void *)1;
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* get normalization value */
|
||||
static int montgomery_normalization(void *a, const void *b)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
mpz_set_ui(a, 1);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* reduce */
|
||||
static int montgomery_reduce(void *a, const void *b, void *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
mpz_mod(a, a, b);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
/* clean up */
|
||||
static void montgomery_deinit(void *a)
|
||||
{
|
||||
LTC_UNUSED_PARAM(a);
|
||||
}
|
||||
|
||||
static int exptmod(const void *a, const void *b, const void *c, void *d)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(b != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
LTC_ARGCHK(d != NULL);
|
||||
mpz_powm(d, a, b, c);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int isprime(const void *a, int b, int *c)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
LTC_ARGCHK(c != NULL);
|
||||
if (b == 0) {
|
||||
b = LTC_MILLER_RABIN_REPS;
|
||||
} /* if */
|
||||
*c = mpz_probab_prime_p(a, b) > 0 ? LTC_MP_YES : LTC_MP_NO;
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
static int set_rand(void *a, int size)
|
||||
{
|
||||
LTC_ARGCHK(a != NULL);
|
||||
mpz_random(a, size);
|
||||
return CRYPT_OK;
|
||||
}
|
||||
|
||||
const ltc_math_descriptor gmp_desc = {
|
||||
"GNU MP",
|
||||
sizeof(mp_limb_t) * CHAR_BIT - GMP_NAIL_BITS,
|
||||
|
||||
&init,
|
||||
&init_copy,
|
||||
&deinit,
|
||||
|
||||
&neg,
|
||||
©,
|
||||
|
||||
&set_int,
|
||||
&get_int,
|
||||
&get_digit,
|
||||
&get_digit_count,
|
||||
&compare,
|
||||
&compare_d,
|
||||
&count_bits,
|
||||
&count_lsb_bits,
|
||||
&twoexpt,
|
||||
|
||||
&read_radix,
|
||||
&write_radix,
|
||||
&unsigned_size,
|
||||
&unsigned_write,
|
||||
&unsigned_read,
|
||||
|
||||
&add,
|
||||
&addi,
|
||||
&sub,
|
||||
&subi,
|
||||
&mul,
|
||||
&muli,
|
||||
&sqr,
|
||||
&sqrtmod_prime,
|
||||
÷,
|
||||
&div_2,
|
||||
&modi,
|
||||
&gcd,
|
||||
&lcm,
|
||||
|
||||
&mulmod,
|
||||
&sqrmod,
|
||||
&invmod,
|
||||
|
||||
&montgomery_setup,
|
||||
&montgomery_normalization,
|
||||
&montgomery_reduce,
|
||||
&montgomery_deinit,
|
||||
|
||||
&exptmod,
|
||||
&isprime,
|
||||
|
||||
#ifdef LTC_MECC
|
||||
#ifdef LTC_MECC_FP
|
||||
<c_ecc_fp_mulmod,
|
||||
#else
|
||||
<c_ecc_mulmod,
|
||||
#endif /* LTC_MECC_FP */
|
||||
<c_ecc_projective_add_point,
|
||||
<c_ecc_projective_dbl_point,
|
||||
<c_ecc_map,
|
||||
#ifdef LTC_ECC_SHAMIR
|
||||
#ifdef LTC_MECC_FP
|
||||
<c_ecc_fp_mul2add,
|
||||
#else
|
||||
<c_ecc_mul2add,
|
||||
#endif /* LTC_MECC_FP */
|
||||
#else
|
||||
NULL,
|
||||
#endif /* LTC_ECC_SHAMIR */
|
||||
#else
|
||||
NULL, NULL, NULL, NULL, NULL,
|
||||
#endif /* LTC_MECC */
|
||||
|
||||
#ifdef LTC_MRSA
|
||||
&rsa_make_key,
|
||||
&rsa_exptmod,
|
||||
#else
|
||||
NULL, NULL,
|
||||
#endif
|
||||
&addmod,
|
||||
&submod,
|
||||
|
||||
&set_rand,
|
||||
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user