angd-dev/data-lite-c
1
0
Fork 0
Code Pull Requests Releases Activity

Replaced system SQLite with SQLCipher to support encrypted database

Browse Source
This commit is contained in:
Oleksii Zghurskyi
2025-06-07 18:11:17 +03:00
parent f4198d62a7
commit 177d74700f
534 changed files with 362771 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1580
Sources/DataLiteC/libtomcrypt/math/fp/ltc_ecc_fp_mulmod.c Normal file
View File

File diff suppressed because it is too large Load Diff

658
Sources/DataLiteC/libtomcrypt/math/gmp_desc.c Normal file
View 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,
&copy,
&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,
&divide,
&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
&ltc_ecc_fp_mulmod,
#else
&ltc_ecc_mulmod,
#endif /* LTC_MECC_FP */
&ltc_ecc_projective_add_point,
&ltc_ecc_projective_dbl_point,
&ltc_ecc_map,
#ifdef LTC_ECC_SHAMIR
#ifdef LTC_MECC_FP
&ltc_ecc_fp_mul2add,
#else
&ltc_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

560
Sources/DataLiteC/libtomcrypt/math/ltm_desc.c Normal file
View File

@@ -0,0 +1,560 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#define DESC_DEF_ONLY
#include "tomcrypt_private.h"
#ifdef LTM_DESC
#include <tommath.h>
#if !defined(PRIVATE_MP_WARRAY) && !defined(BN_MP_PRIME_IS_PRIME_C)
#include <stdbool.h>
#endif
static const struct {
mp_err mpi_code;
int ltc_code;
} mpi_to_ltc_codes[] = {
{ MP_OKAY , CRYPT_OK},
{ MP_MEM , CRYPT_MEM},
{ MP_VAL , CRYPT_INVALID_ARG},
#if defined(MP_BUF) || defined(MP_USE_ENUMS)
{ MP_ITER , CRYPT_INVALID_PACKET},
{ MP_BUF , CRYPT_BUFFER_OVERFLOW},
#endif
};
/**
Convert a MPI error to a LTC error (Possibly the most powerful function ever! Oh wait... no)
@param err The error to convert
@return The equivalent LTC error code or CRYPT_ERROR if none found
*/
static int mpi_to_ltc_error(mp_err err)
{
size_t x;
for (x = 0; x < sizeof(mpi_to_ltc_codes)/sizeof(mpi_to_ltc_codes[0]); x++) {
if (err == mpi_to_ltc_codes[x].mpi_code) {
return mpi_to_ltc_codes[x].ltc_code;
}
}
return CRYPT_ERROR;
}
static int init_mpi(void **a)
{
LTC_ARGCHK(a != NULL);
*a = XCALLOC(1, sizeof(mp_int));
if (*a == NULL) {
return CRYPT_MEM;
} else {
return CRYPT_OK;
}
}
static int init(void **a)
{
int err;
LTC_ARGCHK(a != NULL);
if ((err = init_mpi(a)) != CRYPT_OK) {
return err;
}
if ((err = mpi_to_ltc_error(mp_init(*a))) != CRYPT_OK) {
XFREE(*a);
}
return err;
}
static void deinit(void *a)
{
LTC_ARGCHKVD(a != NULL);
mp_clear(a);
XFREE(a);
}
static int neg(const void *a, void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return mpi_to_ltc_error(mp_neg(a, b));
}
static int copy(const void *a, void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return mpi_to_ltc_error(mp_copy(a, b));
}
static int init_copy(void **a, const void *b)
{
int err;
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
if ((err = init_mpi(a)) != CRYPT_OK) return err;
return mpi_to_ltc_error(mp_init_copy(*a, b));
}
/* ---- trivial ---- */
static int set_int(void *a, ltc_mp_digit b)
{
LTC_ARGCHK(a != NULL);
#ifdef BN_MP_SET_INT_C
return mpi_to_ltc_error(mp_set_int(a, b));
#else
mp_set_u32(a, b);
return CRYPT_OK;
#endif
}
static unsigned long get_int(const void *a)
{
LTC_ARGCHK(a != NULL);
#ifdef BN_MP_GET_INT_C
return mp_get_int(a);
#else
return mp_get_ul(a);
#endif
}
static ltc_mp_digit get_digit(const void *a, int n)
{
const mp_int *A;
LTC_ARGCHK(a != NULL);
A = a;
return (n >= A->used || n < 0) ? 0 : A->dp[n];
}
static int get_digit_count(const void *a)
{
const mp_int *A;
LTC_ARGCHK(a != NULL);
A = a;
return A->used;
}
static int compare(const void *a, const void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
switch (mp_cmp(a, b)) {
case MP_LT: return LTC_MP_LT;
case MP_EQ: return LTC_MP_EQ;
case MP_GT: return LTC_MP_GT;
default: return 0;
}
}
static int compare_d(const void *a, ltc_mp_digit b)
{
LTC_ARGCHK(a != NULL);
switch (mp_cmp_d(a, b)) {
case MP_LT: return LTC_MP_LT;
case MP_EQ: return LTC_MP_EQ;
case MP_GT: return LTC_MP_GT;
default: return 0;
}
}
static int count_bits(const void *a)
{
LTC_ARGCHK(a != NULL);
return mp_count_bits(a);
}
static int count_lsb_bits(const void *a)
{
LTC_ARGCHK(a != NULL);
return mp_cnt_lsb(a);
}
static int twoexpt(void *a, int n)
{
LTC_ARGCHK(a != NULL);
return mpi_to_ltc_error(mp_2expt(a, n));
}
/* ---- conversions ---- */
/* read ascii string */
static int read_radix(void *a, const char *b, int radix)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return mpi_to_ltc_error(mp_read_radix(a, b, radix));
}
/* write one */
static int write_radix(const void *a, char *b, int radix)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
#ifdef BN_MP_TORADIX_C
return mpi_to_ltc_error(mp_toradix(a, b, radix));
#else
return mpi_to_ltc_error(mp_to_radix(a, b, SIZE_MAX, NULL, radix));
#endif
}
/* get size as unsigned char string */
static unsigned long unsigned_size(const void *a)
{
LTC_ARGCHK(a != NULL);
#ifdef BN_MP_UNSIGNED_BIN_SIZE_C
return mp_unsigned_bin_size(a);
#else
return (unsigned long)mp_ubin_size(a);
#endif
}
/* store */
static int unsigned_write(const void *a, unsigned char *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
#ifdef BN_MP_TO_UNSIGNED_BIN_C
return mpi_to_ltc_error(mp_to_unsigned_bin(a, b));
#else
return mpi_to_ltc_error(mp_to_ubin(a, b, SIZE_MAX, NULL));
#endif
}
/* read */
static int unsigned_read(void *a, const unsigned char *b, unsigned long len)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
#ifdef BN_MP_READ_UNSIGNED_BIN_C
return mpi_to_ltc_error(mp_read_unsigned_bin(a, b, len));
#else
return mpi_to_ltc_error(mp_from_ubin(a, b, (size_t)len));
#endif
}
/* add */
static int add(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_add(a, b, c));
}
static int addi(const void *a, ltc_mp_digit b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_add_d(a, b, c));
}
/* sub */
static int sub(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_sub(a, b, c));
}
static int subi(const void *a, ltc_mp_digit b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_sub_d(a, b, c));
}
/* mul */
static int mul(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_mul(a, b, c));
}
static int muli(const void *a, ltc_mp_digit b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_mul_d(a, b, c));
}
/* sqr */
static int sqr(const void *a, void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return mpi_to_ltc_error(mp_sqr(a, b));
}
/* sqrtmod_prime */
static int sqrtmod_prime(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_sqrtmod_prime(a, b, c));
}
/* div */
static int divide(const void *a, const void *b, void *c, void *d)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return mpi_to_ltc_error(mp_div(a, b, c, d));
}
static int div_2(const void *a, void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return mpi_to_ltc_error(mp_div_2(a, b));
}
/* modi */
static int modi(const void *a, ltc_mp_digit b, ltc_mp_digit *c)
{
mp_digit tmp;
int err;
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
if ((err = mpi_to_ltc_error(mp_mod_d(a, b, &tmp))) != CRYPT_OK) {
return err;
}
*c = tmp;
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);
return mpi_to_ltc_error(mp_gcd(a, b, c));
}
/* lcm */
static int lcm(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_lcm(a, b, c));
}
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);
return mpi_to_ltc_error(mp_addmod(a,b,c,d));
}
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);
return mpi_to_ltc_error(mp_submod(a,b,c,d));
}
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);
return mpi_to_ltc_error(mp_mulmod(a,b,c,d));
}
static int sqrmod(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_sqrmod(a,b,c));
}
/* invmod */
static int invmod(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_invmod(a, b, c));
}
/* setup */
static int montgomery_setup(const void *a, void **b)
{
int err;
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
*b = XCALLOC(1, sizeof(mp_digit));
if (*b == NULL) {
return CRYPT_MEM;
}
if ((err = mpi_to_ltc_error(mp_montgomery_setup(a, *b))) != CRYPT_OK) {
XFREE(*b);
}
return err;
}
/* get normalization value */
static int montgomery_normalization(void *a, const void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return mpi_to_ltc_error(mp_montgomery_calc_normalization(a, b));
}
/* reduce */
static int montgomery_reduce(void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return mpi_to_ltc_error(mp_montgomery_reduce(a, b, *((mp_digit *)c)));
}
/* clean up */
static void montgomery_deinit(void *a)
{
XFREE(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);
return mpi_to_ltc_error(mp_exptmod(a,b,c,d));
}
static int isprime(const void *a, int b, int *c)
{
int err;
#if defined(PRIVATE_MP_WARRAY) || defined(BN_MP_PRIME_IS_PRIME_C)
int res;
#else
bool res;
#endif
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
b = mp_prime_rabin_miller_trials(mp_count_bits(a));
err = mpi_to_ltc_error(mp_prime_is_prime(a, b, &res));
*c = res ? LTC_MP_YES : LTC_MP_NO;
return err;
}
static int set_rand(void *a, int size)
{
LTC_ARGCHK(a != NULL);
return mpi_to_ltc_error(mp_rand(a, size));
}
#ifndef MP_DIGIT_BIT
#define MP_DIGIT_BIT DIGIT_BIT
#endif
const ltc_math_descriptor ltm_desc = {
"LibTomMath",
(int)MP_DIGIT_BIT,
&init,
&init_copy,
&deinit,
&neg,
&copy,
&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,
&divide,
&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
&ltc_ecc_fp_mulmod,
#else
&ltc_ecc_mulmod,
#endif
&ltc_ecc_projective_add_point,
&ltc_ecc_projective_dbl_point,
&ltc_ecc_map,
#ifdef LTC_ECC_SHAMIR
#ifdef LTC_MECC_FP
&ltc_ecc_fp_mul2add,
#else
&ltc_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

64
Sources/DataLiteC/libtomcrypt/math/multi.c Normal file
View File

@@ -0,0 +1,64 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#include "tomcrypt_private.h"
#ifdef LTC_MPI
int ltc_mp_init_multi(void **a, ...)
{
void **cur = a;
int np = 0;
va_list args;
va_start(args, a);
while (cur != NULL) {
if (ltc_mp_init(cur) != CRYPT_OK) {
/* failed */
va_list clean_list;
va_start(clean_list, a);
cur = a;
while (np--) {
ltc_mp_clear(*cur);
cur = va_arg(clean_list, void**);
}
va_end(clean_list);
va_end(args);
return CRYPT_MEM;
}
++np;
cur = va_arg(args, void**);
}
va_end(args);
return CRYPT_OK;
}
void ltc_mp_deinit_multi(void *a, ...)
{
void *cur = a;
va_list args;
va_start(args, a);
while (cur != NULL) {
ltc_mp_clear(cur);
cur = va_arg(args, void *);
}
va_end(args);
}
void ltc_mp_cleanup_multi(void **a, ...)
{
void **cur = a;
va_list args;
va_start(args, a);
while (cur != NULL) {
if (*cur != NULL) {
ltc_mp_clear(*cur);
*cur = NULL;
}
cur = va_arg(args, void**);
}
va_end(args);
}
#endif

52
Sources/DataLiteC/libtomcrypt/math/radix_to_bin.c Normal file
View File

@@ -0,0 +1,52 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#include "tomcrypt_private.h"
/**
@file radix_to_bin.c
Convert data from a specific radix to binary.
Steffen Jaeckel
*/
/**
Convert data from a specific radix to binary
The default MPI descriptors #ltm_desc, #tfm_desc and #gmp_desc
have the following restrictions on parameters:
\p in - NUL-terminated char buffer
\p radix - 2..64
@param in The input
@param radix The radix of the input
@param out The output buffer
@param len [in/out] The length of the output buffer
@return CRYPT_OK on success.
*/
int radix_to_bin(const void *in, int radix, void *out, unsigned long *len)
{
unsigned long l;
void* mpi;
int err;
LTC_ARGCHK(in != NULL);
LTC_ARGCHK(len != NULL);
if ((err = ltc_mp_init(&mpi)) != CRYPT_OK) return err;
if ((err = ltc_mp_read_radix(mpi, in, radix)) != CRYPT_OK) goto LBL_ERR;
if ((l = ltc_mp_unsigned_bin_size(mpi)) > *len) {
*len = l;
err = CRYPT_BUFFER_OVERFLOW;
goto LBL_ERR;
}
*len = l;
if ((err = ltc_mp_to_unsigned_bin(mpi, out)) != CRYPT_OK) goto LBL_ERR;
LBL_ERR:
ltc_mp_clear(mpi);
return err;
}

65
Sources/DataLiteC/libtomcrypt/math/rand_bn.c Normal file
View File

@@ -0,0 +1,65 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#include "tomcrypt_private.h"
#if defined(LTC_MDSA) || defined(LTC_MECC)
/**
Generate a random number N with given bitlength (note: MSB can be 0)
*/
int rand_bn_bits(void *N, int bits, prng_state *prng, int wprng)
{
int res, bytes;
unsigned char *buf, mask;
LTC_ARGCHK(N != NULL);
LTC_ARGCHK(bits > 1);
/* check PRNG */
if ((res = prng_is_valid(wprng)) != CRYPT_OK) return res;
bytes = (bits+7) >> 3;
mask = 0xff >> (bits % 8 == 0 ? 0 : 8 - bits % 8);
/* allocate buffer */
if ((buf = XCALLOC(1, bytes)) == NULL) return CRYPT_MEM;
/* generate random bytes */
if (prng_descriptor[wprng].read(buf, bytes, prng) != (unsigned long)bytes) {
res = CRYPT_ERROR_READPRNG;
goto cleanup;
}
/* mask bits */
buf[0] &= mask;
/* load value */
if ((res = ltc_mp_read_unsigned_bin(N, buf, bytes)) != CRYPT_OK) goto cleanup;
res = CRYPT_OK;
cleanup:
#ifdef LTC_CLEAN_STACK
zeromem(buf, bytes);
#endif
XFREE(buf);
return res;
}
/**
Generate a random number N in a range: 1 <= N < limit
*/
int rand_bn_upto(void *N, void *limit, prng_state *prng, int wprng)
{
int res, bits;
LTC_ARGCHK(N != NULL);
LTC_ARGCHK(limit != NULL);
bits = ltc_mp_count_bits(limit);
do {
res = rand_bn_bits(N, bits, prng, wprng);
if (res != CRYPT_OK) return res;
} while (ltc_mp_cmp_d(N, 0) != LTC_MP_GT || ltc_mp_cmp(N, limit) != LTC_MP_LT);
return CRYPT_OK;
}
#endif

78
Sources/DataLiteC/libtomcrypt/math/rand_prime.c Normal file
View File

@@ -0,0 +1,78 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#include "tomcrypt_private.h"
#if defined(LTC_MRSA) || (!defined(LTC_NO_MATH) && !defined(LTC_NO_PRNGS))
/**
@file rand_prime.c
Generate a random prime, Tom St Denis
*/
#define USE_BBS 1
int rand_prime(void *N, long len, prng_state *prng, int wprng)
{
int err, res, type;
unsigned char *buf;
LTC_ARGCHK(N != NULL);
/* get type */
if (len < 0) {
type = USE_BBS;
len = -len;
} else {
type = 0;
}
/* allow sizes between 2 and 512 bytes for a prime size */
if (len < 2 || len > 512) {
return CRYPT_INVALID_PRIME_SIZE;
}
/* valid PRNG? Better be! */
if ((err = prng_is_valid(wprng)) != CRYPT_OK) {
return err;
}
/* allocate buffer to work with */
buf = XCALLOC(1, len);
if (buf == NULL) {
return CRYPT_MEM;
}
do {
/* generate value */
if (prng_descriptor[wprng].read(buf, len, prng) != (unsigned long)len) {
XFREE(buf);
return CRYPT_ERROR_READPRNG;
}
/* munge bits */
buf[0] |= 0x80 | 0x40;
buf[len-1] |= 0x01 | ((type & USE_BBS) ? 0x02 : 0x00);
/* load value */
if ((err = ltc_mp_read_unsigned_bin(N, buf, len)) != CRYPT_OK) {
XFREE(buf);
return err;
}
/* test */
if ((err = ltc_mp_prime_is_prime(N, LTC_MILLER_RABIN_REPS, &res)) != CRYPT_OK) {
XFREE(buf);
return err;
}
} while (res == LTC_MP_NO);
#ifdef LTC_CLEAN_STACK
zeromem(buf, len);
#endif
XFREE(buf);
return CRYPT_OK;
}
#endif /* LTC_NO_MATH */

875
Sources/DataLiteC/libtomcrypt/math/tfm_desc.c Normal file
View File

@@ -0,0 +1,875 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#define DESC_DEF_ONLY
#include "tomcrypt_private.h"
#ifdef TFM_DESC
#include <tfm.h>
#if !defined(TFM_VERSION_3)
# if 0 /* Enable if desirable */
# warning "pre-constification TFM used (TFM_VERSION_3 undefined)"
# endif
# define TFM_UNCONST(type) (type)
#elif TFM_VERSION <= TFM_VERSION_3(0, 13, 89)
# if 0 /* Enable if desirable */
# warning "pre-constification TFM used (older version detected)"
# endif
# define TFM_UNCONST(type) (type)
#else
# define TFM_UNCONST(type)
#endif
static const struct {
int tfm_code, ltc_code;
} tfm_to_ltc_codes[] = {
{ FP_OKAY , CRYPT_OK},
{ FP_MEM , CRYPT_MEM},
{ FP_VAL , CRYPT_INVALID_ARG},
};
/**
Convert a tfm error to a LTC error (Possibly the most powerful function ever! Oh wait... no)
@param err The error to convert
@return The equivalent LTC error code or CRYPT_ERROR if none found
*/
static int tfm_to_ltc_error(int err)
{
int x;
for (x = 0; x < (int)(sizeof(tfm_to_ltc_codes)/sizeof(tfm_to_ltc_codes[0])); x++) {
if (err == tfm_to_ltc_codes[x].tfm_code) {
return tfm_to_ltc_codes[x].ltc_code;
}
}
return CRYPT_ERROR;
}
static int init(void **a)
{
LTC_ARGCHK(a != NULL);
*a = XCALLOC(1, sizeof(fp_int));
if (*a == NULL) {
return CRYPT_MEM;
}
fp_init(*a);
return CRYPT_OK;
}
static void deinit(void *a)
{
LTC_ARGCHKVD(a != NULL);
XFREE(a);
}
static int neg(const void *a, void *b)
{
/* fp_neg() is a macro that accesses the internals of the b */
fp_int *tmpb = b;
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
fp_neg(a, tmpb);
return CRYPT_OK;
}
static int copy(const void *a, void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
fp_copy(a, b);
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);
fp_set(a, b);
return CRYPT_OK;
}
static unsigned long get_int(const void *a)
{
const fp_int *A;
LTC_ARGCHK(a != NULL);
A = a;
return A->used > 0 ? A->dp[0] : 0;
}
static ltc_mp_digit get_digit(const void *a, int n)
{
const fp_int *A;
LTC_ARGCHK(a != NULL);
A = a;
return (n >= A->used || n < 0) ? 0 : A->dp[n];
}
static int get_digit_count(const void *a)
{
const fp_int *A;
LTC_ARGCHK(a != NULL);
A = a;
return A->used;
}
static int compare(const void *a, const void *b)
{
int ret;
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
ret = fp_cmp(TFM_UNCONST(void *)a, TFM_UNCONST(void *)b);
switch (ret) {
case FP_LT: return LTC_MP_LT;
case FP_EQ: return LTC_MP_EQ;
case FP_GT: return LTC_MP_GT;
}
return 0;
}
static int compare_d(const void *a, ltc_mp_digit b)
{
int ret;
LTC_ARGCHK(a != NULL);
ret = fp_cmp_d(TFM_UNCONST(void *)a, b);
switch (ret) {
case FP_LT: return LTC_MP_LT;
case FP_EQ: return LTC_MP_EQ;
case FP_GT: return LTC_MP_GT;
}
return 0;
}
static int count_bits(const void *a)
{
LTC_ARGCHK(a != NULL);
return fp_count_bits(TFM_UNCONST(void *)a);
}
static int count_lsb_bits(const void *a)
{
LTC_ARGCHK(a != NULL);
return fp_cnt_lsb(TFM_UNCONST(void *)a);
}
static int twoexpt(void *a, int n)
{
LTC_ARGCHK(a != NULL);
fp_2expt(a, n);
return CRYPT_OK;
}
/* ---- conversions ---- */
/* read ascii string */
static int read_radix(void *a, const char *b, int radix)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return tfm_to_ltc_error(fp_read_radix(a, b, radix));
}
/* write one */
static int write_radix(const void *a, char *b, int radix)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return tfm_to_ltc_error(fp_toradix(TFM_UNCONST(void *)a, b, radix));
}
/* get size as unsigned char string */
static unsigned long unsigned_size(const void *a)
{
LTC_ARGCHK(a != NULL);
return fp_unsigned_bin_size(TFM_UNCONST(void *)a);
}
/* store */
static int unsigned_write(const void *a, unsigned char *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
fp_to_unsigned_bin(TFM_UNCONST(void *)a, b);
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);
fp_read_unsigned_bin(a, b, len);
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);
fp_add(TFM_UNCONST(void *)a, TFM_UNCONST(void *)b, c);
return CRYPT_OK;
}
static int addi(const void *a, ltc_mp_digit b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
fp_add_d(TFM_UNCONST(void *)a, b, c);
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);
fp_sub(TFM_UNCONST(void *)a, TFM_UNCONST(void *)b, c);
return CRYPT_OK;
}
static int subi(const void *a, ltc_mp_digit b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
fp_sub_d(TFM_UNCONST(void *)a, b, c);
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);
fp_mul(TFM_UNCONST(void *)a, TFM_UNCONST(void *)b, c);
return CRYPT_OK;
}
static int muli(const void *a, ltc_mp_digit b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
fp_mul_d(TFM_UNCONST(void *)a, b, c);
return CRYPT_OK;
}
/* sqr */
static int sqr(const void *a, void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
fp_sqr(TFM_UNCONST(void *)a, b);
return CRYPT_OK;
}
/* sqrtmod_prime - NOT SUPPORTED */
/* div */
static int divide(const void *a, const void *b, void *c, void *d)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
return tfm_to_ltc_error(fp_div(TFM_UNCONST(void *)a, TFM_UNCONST(void *)b, c, d));
}
static int div_2(const void *a, void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
fp_div_2(TFM_UNCONST(void *)a, b);
return CRYPT_OK;
}
/* modi */
static int modi(const void *a, ltc_mp_digit b, ltc_mp_digit *c)
{
fp_digit tmp;
int err;
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
if ((err = tfm_to_ltc_error(fp_mod_d(TFM_UNCONST(void *)a, b, &tmp))) != CRYPT_OK) {
return err;
}
*c = tmp;
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);
fp_gcd(TFM_UNCONST(void *)a, TFM_UNCONST(void *)b, c);
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);
fp_lcm(TFM_UNCONST(void *)a, TFM_UNCONST(void *)b, c);
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);
return tfm_to_ltc_error(fp_addmod(TFM_UNCONST(void *)a,TFM_UNCONST(void *)b,TFM_UNCONST(void *)c,d));
}
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);
return tfm_to_ltc_error(fp_submod(TFM_UNCONST(void *)a,TFM_UNCONST(void *)b,TFM_UNCONST(void *)c,d));
}
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);
return tfm_to_ltc_error(fp_mulmod(TFM_UNCONST(void *)a,TFM_UNCONST(void *)b,TFM_UNCONST(void *)c,d));
}
static int sqrmod(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return tfm_to_ltc_error(fp_sqrmod(TFM_UNCONST(void *)a,TFM_UNCONST(void *)b,c));
}
/* invmod */
static int invmod(const void *a, const void *b, void *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
return tfm_to_ltc_error(fp_invmod(TFM_UNCONST(void *)a, TFM_UNCONST(void *)b, c));
}
/* setup */
static int montgomery_setup(const void *a, void **b)
{
int err;
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
*b = XCALLOC(1, sizeof(fp_digit));
if (*b == NULL) {
return CRYPT_MEM;
}
if ((err = tfm_to_ltc_error(fp_montgomery_setup(TFM_UNCONST(void *)a, *b))) != CRYPT_OK) {
XFREE(*b);
}
return err;
}
/* get normalization value */
static int montgomery_normalization(void *a, const void *b)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
fp_montgomery_calc_normalization(a, TFM_UNCONST(void *)b);
return CRYPT_OK;
}
/* reduce */
static int montgomery_reduce(void *a, const void *b, void *c)
{
fp_digit *tmpc = c;
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
LTC_ARGCHK(c != NULL);
fp_montgomery_reduce(a, TFM_UNCONST(void *)b, *tmpc);
return CRYPT_OK;
}
/* clean up */
static void montgomery_deinit(void *a)
{
XFREE(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);
return tfm_to_ltc_error(fp_exptmod(TFM_UNCONST(void *)a,TFM_UNCONST(void *)b,TFM_UNCONST(void *)c,d));
}
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 = (fp_isprime_ex(TFM_UNCONST(void *)a, b) == FP_YES) ? LTC_MP_YES : LTC_MP_NO;
return CRYPT_OK;
}
#if defined(LTC_MECC) && defined(LTC_MECC_ACCEL)
static int tfm_ecc_projective_dbl_point(const ecc_point *P, ecc_point *R, const void *ma, const void *modulus, void *Mp)
{
fp_int t1, t2;
fp_digit mp;
int err, inf;
LTC_ARGCHK(P != NULL);
LTC_ARGCHK(R != NULL);
LTC_ARGCHK(modulus != NULL);
LTC_ARGCHK(Mp != NULL);
mp = *((fp_digit*)Mp);
fp_init(&t1);
fp_init(&t2);
if (P != R) {
fp_copy(P->x, R->x);
fp_copy(P->y, R->y);
fp_copy(P->z, R->z);
}
if ((err = ltc_ecc_is_point_at_infinity(P, modulus, &inf)) != CRYPT_OK) return err;
if (inf) {
/* if P is point at infinity >> Result = point at infinity */
ltc_mp.set_int(R->x, 1);
ltc_mp.set_int(R->y, 1);
ltc_mp.set_int(R->z, 0);
return CRYPT_OK;
}
/* t1 = Z * Z */
fp_sqr(R->z, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* Z = Y * Z */
fp_mul(R->z, R->y, R->z);
fp_montgomery_reduce(R->z, TFM_UNCONST(void *)modulus, mp);
/* Z = 2Z */
fp_add(R->z, R->z, R->z);
if (fp_cmp(R->z, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(R->z, TFM_UNCONST(void *)modulus, R->z);
}
if (ma == NULL) { /* special case for curves with a == -3 (10% faster than general case) */
/* T2 = X - T1 */
fp_sub(R->x, &t1, &t2);
if (fp_cmp_d(&t2, 0) == LTC_MP_LT) {
fp_add(&t2, TFM_UNCONST(void *)modulus, &t2);
}
/* T1 = X + T1 */
fp_add(&t1, R->x, &t1);
if (fp_cmp(&t1, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t1, TFM_UNCONST(void *)modulus, &t1);
}
/* T2 = T1 * T2 */
fp_mul(&t1, &t2, &t2);
fp_montgomery_reduce(&t2, TFM_UNCONST(void *)modulus, mp);
/* T1 = 2T2 */
fp_add(&t2, &t2, &t1);
if (fp_cmp(&t1, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t1, TFM_UNCONST(void *)modulus, &t1);
}
/* T1 = T1 + T2 */
fp_add(&t1, &t2, &t1);
if (fp_cmp(&t1, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t1, TFM_UNCONST(void *)modulus, &t1);
}
}
else {
/* T2 = T1 * T1 */
fp_sqr(&t1, &t2);
fp_montgomery_reduce(&t2, TFM_UNCONST(void *)modulus, mp);
/* T1 = T2 * a */
fp_mul(&t2, TFM_UNCONST(void *)ma, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* T2 = X * X */
fp_sqr(R->x, &t2);
fp_montgomery_reduce(&t2, TFM_UNCONST(void *)modulus, mp);
/* T1 = T1 + T2 */
fp_add(&t1, &t2, &t1);
if (fp_cmp(&t1, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t1, TFM_UNCONST(void *)modulus, &t1);
}
/* T1 = T1 + T2 */
fp_add(&t1, &t2, &t1);
if (fp_cmp(&t1, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t1, TFM_UNCONST(void *)modulus, &t1);
}
/* T1 = T1 + T2 */
fp_add(&t1, &t2, &t1);
if (fp_cmp(&t1, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t1, TFM_UNCONST(void *)modulus, &t1);
}
}
/* Y = 2Y */
fp_add(R->y, R->y, R->y);
if (fp_cmp(R->y, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(R->y, TFM_UNCONST(void *)modulus, R->y);
}
/* Y = Y * Y */
fp_sqr(R->y, R->y);
fp_montgomery_reduce(R->y, TFM_UNCONST(void *)modulus, mp);
/* T2 = Y * Y */
fp_sqr(R->y, &t2);
fp_montgomery_reduce(&t2, TFM_UNCONST(void *)modulus, mp);
/* T2 = T2/2 */
if (fp_isodd(&t2)) {
fp_add(&t2, TFM_UNCONST(void *)modulus, &t2);
}
fp_div_2(&t2, &t2);
/* Y = Y * X */
fp_mul(R->y, R->x, R->y);
fp_montgomery_reduce(R->y, TFM_UNCONST(void *)modulus, mp);
/* X = T1 * T1 */
fp_sqr(&t1, R->x);
fp_montgomery_reduce(R->x, TFM_UNCONST(void *)modulus, mp);
/* X = X - Y */
fp_sub(R->x, R->y, R->x);
if (fp_cmp_d(R->x, 0) == FP_LT) {
fp_add(R->x, TFM_UNCONST(void *)modulus, R->x);
}
/* X = X - Y */
fp_sub(R->x, R->y, R->x);
if (fp_cmp_d(R->x, 0) == FP_LT) {
fp_add(R->x, TFM_UNCONST(void *)modulus, R->x);
}
/* Y = Y - X */
fp_sub(R->y, R->x, R->y);
if (fp_cmp_d(R->y, 0) == FP_LT) {
fp_add(R->y, TFM_UNCONST(void *)modulus, R->y);
}
/* Y = Y * T1 */
fp_mul(R->y, &t1, R->y);
fp_montgomery_reduce(R->y, TFM_UNCONST(void *)modulus, mp);
/* Y = Y - T2 */
fp_sub(R->y, &t2, R->y);
if (fp_cmp_d(R->y, 0) == FP_LT) {
fp_add(R->y, TFM_UNCONST(void *)modulus, R->y);
}
return CRYPT_OK;
}
/**
Add two ECC points
@param P The point to add
@param Q The point to add
@param R [out] The destination of the double
@param modulus The modulus of the field the ECC curve is in
@param Mp The "b" value from montgomery_setup()
@return CRYPT_OK on success
*/
static int tfm_ecc_projective_add_point(const ecc_point *P, const ecc_point *Q, ecc_point *R, const void *ma, const void *modulus, void *Mp)
{
fp_int t1, t2, x, y, z;
fp_digit mp;
int err, inf;
LTC_ARGCHK(P != NULL);
LTC_ARGCHK(Q != NULL);
LTC_ARGCHK(R != NULL);
LTC_ARGCHK(modulus != NULL);
LTC_ARGCHK(Mp != NULL);
mp = *((fp_digit*)Mp);
fp_init(&t1);
fp_init(&t2);
fp_init(&x);
fp_init(&y);
fp_init(&z);
if ((err = ltc_ecc_is_point_at_infinity(P, modulus, &inf)) != CRYPT_OK) return err;
if (inf) {
/* P is point at infinity >> Result = Q */
ltc_mp.copy(Q->x, R->x);
ltc_mp.copy(Q->y, R->y);
ltc_mp.copy(Q->z, R->z);
return CRYPT_OK;
}
if ((err = ltc_ecc_is_point_at_infinity(Q, modulus, &inf)) != CRYPT_OK) return err;
if (inf) {
/* Q is point at infinity >> Result = P */
ltc_mp.copy(P->x, R->x);
ltc_mp.copy(P->y, R->y);
ltc_mp.copy(P->z, R->z);
return CRYPT_OK;
}
/* should we dbl instead? */
fp_sub(TFM_UNCONST(void *)modulus, Q->y, &t1);
if ( (fp_cmp(P->x, Q->x) == FP_EQ) &&
(Q->z != NULL && fp_cmp(P->z, Q->z) == FP_EQ) &&
(fp_cmp(P->y, Q->y) == FP_EQ || fp_cmp(P->y, &t1) == FP_EQ)) {
return tfm_ecc_projective_dbl_point(P, R, ma, modulus, Mp);
}
fp_copy(P->x, &x);
fp_copy(P->y, &y);
fp_copy(P->z, &z);
/* if Z is one then these are no-operations */
if (Q->z != NULL) {
/* T1 = Z' * Z' */
fp_sqr(Q->z, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* X = X * T1 */
fp_mul(&t1, &x, &x);
fp_montgomery_reduce(&x, TFM_UNCONST(void *)modulus, mp);
/* T1 = Z' * T1 */
fp_mul(Q->z, &t1, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* Y = Y * T1 */
fp_mul(&t1, &y, &y);
fp_montgomery_reduce(&y, TFM_UNCONST(void *)modulus, mp);
}
/* T1 = Z*Z */
fp_sqr(&z, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* T2 = X' * T1 */
fp_mul(Q->x, &t1, &t2);
fp_montgomery_reduce(&t2, TFM_UNCONST(void *)modulus, mp);
/* T1 = Z * T1 */
fp_mul(&z, &t1, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* T1 = Y' * T1 */
fp_mul(Q->y, &t1, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* Y = Y - T1 */
fp_sub(&y, &t1, &y);
if (fp_cmp_d(&y, 0) == FP_LT) {
fp_add(&y, TFM_UNCONST(void *)modulus, &y);
}
/* T1 = 2T1 */
fp_add(&t1, &t1, &t1);
if (fp_cmp(&t1, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t1, TFM_UNCONST(void *)modulus, &t1);
}
/* T1 = Y + T1 */
fp_add(&t1, &y, &t1);
if (fp_cmp(&t1, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t1, TFM_UNCONST(void *)modulus, &t1);
}
/* X = X - T2 */
fp_sub(&x, &t2, &x);
if (fp_cmp_d(&x, 0) == FP_LT) {
fp_add(&x, TFM_UNCONST(void *)modulus, &x);
}
/* T2 = 2T2 */
fp_add(&t2, &t2, &t2);
if (fp_cmp(&t2, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t2, TFM_UNCONST(void *)modulus, &t2);
}
/* T2 = X + T2 */
fp_add(&t2, &x, &t2);
if (fp_cmp(&t2, TFM_UNCONST(void *)modulus) != FP_LT) {
fp_sub(&t2, TFM_UNCONST(void *)modulus, &t2);
}
/* if Z' != 1 */
if (Q->z != NULL) {
/* Z = Z * Z' */
fp_mul(&z, Q->z, &z);
fp_montgomery_reduce(&z, TFM_UNCONST(void *)modulus, mp);
}
/* Z = Z * X */
fp_mul(&z, &x, &z);
fp_montgomery_reduce(&z, TFM_UNCONST(void *)modulus, mp);
/* T1 = T1 * X */
fp_mul(&t1, &x, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* X = X * X */
fp_sqr(&x, &x);
fp_montgomery_reduce(&x, TFM_UNCONST(void *)modulus, mp);
/* T2 = T2 * x */
fp_mul(&t2, &x, &t2);
fp_montgomery_reduce(&t2, TFM_UNCONST(void *)modulus, mp);
/* T1 = T1 * X */
fp_mul(&t1, &x, &t1);
fp_montgomery_reduce(&t1, TFM_UNCONST(void *)modulus, mp);
/* X = Y*Y */
fp_sqr(&y, &x);
fp_montgomery_reduce(&x, TFM_UNCONST(void *)modulus, mp);
/* X = X - T2 */
fp_sub(&x, &t2, &x);
if (fp_cmp_d(&x, 0) == FP_LT) {
fp_add(&x, TFM_UNCONST(void *)modulus, &x);
}
/* T2 = T2 - X */
fp_sub(&t2, &x, &t2);
if (fp_cmp_d(&t2, 0) == FP_LT) {
fp_add(&t2, TFM_UNCONST(void *)modulus, &t2);
}
/* T2 = T2 - X */
fp_sub(&t2, &x, &t2);
if (fp_cmp_d(&t2, 0) == FP_LT) {
fp_add(&t2, TFM_UNCONST(void *)modulus, &t2);
}
/* T2 = T2 * Y */
fp_mul(&t2, &y, &t2);
fp_montgomery_reduce(&t2, TFM_UNCONST(void *)modulus, mp);
/* Y = T2 - T1 */
fp_sub(&t2, &t1, &y);
if (fp_cmp_d(&y, 0) == FP_LT) {
fp_add(&y, TFM_UNCONST(void *)modulus, &y);
}
/* Y = Y/2 */
if (fp_isodd(&y)) {
fp_add(&y, TFM_UNCONST(void *)modulus, &y);
}
fp_div_2(&y, &y);
fp_copy(&x, R->x);
fp_copy(&y, R->y);
fp_copy(&z, R->z);
return CRYPT_OK;
}
#endif
static int set_rand(void *a, int size)
{
LTC_ARGCHK(a != NULL);
fp_rand(a, size);
return CRYPT_OK;
}
const ltc_math_descriptor tfm_desc = {
"TomsFastMath",
(int)DIGIT_BIT,
&init,
&init_copy,
&deinit,
&neg,
&copy,
&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,
NULL, /* TODO: &sqrtmod_prime */
&divide,
&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
&ltc_ecc_fp_mulmod,
#else
&ltc_ecc_mulmod,
#endif /* LTC_MECC_FP */
#ifdef LTC_MECC_ACCEL
&tfm_ecc_projective_add_point,
&tfm_ecc_projective_dbl_point,
#else
&ltc_ecc_projective_add_point,
&ltc_ecc_projective_dbl_point,
#endif /* LTC_MECC_ACCEL */
&ltc_ecc_map,
#ifdef LTC_ECC_SHAMIR
#ifdef LTC_MECC_FP
&ltc_ecc_fp_mul2add,
#else
&ltc_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