libs/libtomcrypt/math/ltm_desc.c

   1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
   2  *
   3  * LibTomCrypt is a library that provides various cryptographic
   4  * algorithms in a highly modular and flexible manner.
   5  *
   6  * The library is free for all purposes without any express
   7  * guarantee it works.
   8  *
   9  * Tom St Denis, tomstdenis@gmail.com, http://libtomcrypt.com
  10  */
  11
  12 #define DESC_DEF_ONLY
  13 #include "tomcrypt.h"
  14
  15 #ifdef LTM_DESC
  16
  17 #include <tommath.h>
  18
  19 static const struct {
  20     int mpi_code, ltc_code;
  21 } mpi_to_ltc_codes[] = {
  22    { MP_OKAY ,  CRYPT_OK},
  23    { MP_MEM  ,  CRYPT_MEM},
  24    { MP_VAL  ,  CRYPT_INVALID_ARG},
  25 };
  26
  27 /**
  28    Convert a MPI error to a LTC error (Possibly the most powerful function ever!  Oh wait... no)
  29    @param err    The error to convert
  30    @return The equivalent LTC error code or CRYPT_ERROR if none found
  31 */
  32 static int mpi_to_ltc_error(int err)
  33 {
  34    int x;
  35
  36    for (x = 0; x < (int)(sizeof(mpi_to_ltc_codes)/sizeof(mpi_to_ltc_codes[0])); x++) {
  37        if (err == mpi_to_ltc_codes[x].mpi_code) {
  38           return mpi_to_ltc_codes[x].ltc_code;
  39        }
  40    }
  41    return CRYPT_ERROR;
  42 }
  43
  44 static int init(void **a)
  45 {
  46    int err;
  47
  48    LTC_ARGCHK(a != NULL);
  49
  50    *a = XCALLOC(1, sizeof(mp_int));
  51    if (*a == NULL) {
  52       return CRYPT_MEM;
  53    }
  54
  55    if ((err = mpi_to_ltc_error(mp_init(*a))) != CRYPT_OK) {
  56       XFREE(*a);
  57    }
  58    return err;
  59 }
  60
  61 static void deinit(void *a)
  62 {
  63    LTC_ARGCHKVD(a != NULL);
  64    mp_clear(a);
  65    XFREE(a);
  66 }
  67
  68 static int neg(void *a, void *b)
  69 {
  70    LTC_ARGCHK(a != NULL);
  71    LTC_ARGCHK(b != NULL);
  72    return mpi_to_ltc_error(mp_neg(a, b));
  73 }
  74
  75 static int copy(void *a, void *b)
  76 {
  77    LTC_ARGCHK(a != NULL);
  78    LTC_ARGCHK(b != NULL);
  79    return mpi_to_ltc_error(mp_copy(a, b));
  80 }
  81
  82 static int init_copy(void **a, void *b)
  83 {
  84    if (init(a) != CRYPT_OK) {
  85       return CRYPT_MEM;
  86    }
  87    return copy(b, *a);
  88 }
  89
  90 /* ---- trivial ---- */
  91 static int set_int(void *a, unsigned long b)
  92 {
  93    LTC_ARGCHK(a != NULL);
  94    return mpi_to_ltc_error(mp_set_int(a, b));
  95 }
  96
  97 static unsigned long get_int(void *a)
  98 {
  99    LTC_ARGCHK(a != NULL);
 100    return mp_get_int(a);
 101 }
 102
 103 static unsigned long get_digit(void *a, int n)
 104 {
 105    mp_int *A;
 106    LTC_ARGCHK(a != NULL);
 107    A = a;
 108    return (n >= A->used || n < 0) ? 0 : A->dp[n];
 109 }
 110
 111 static int get_digit_count(void *a)
 112 {
 113    mp_int *A;
 114    LTC_ARGCHK(a != NULL);
 115    A = a;
 116    return A->used;
 117 }
 118
 119 static int compare(void *a, void *b)
 120 {
 121    int ret;
 122    LTC_ARGCHK(a != NULL);
 123    LTC_ARGCHK(b != NULL);
 124    ret = mp_cmp(a, b);
 125    switch (ret) {
 126       case MP_LT: return LTC_MP_LT;
 127       case MP_EQ: return LTC_MP_EQ;
 128       case MP_GT: return LTC_MP_GT;
 129    }
 130    return 0;
 131 }
 132
 133 static int compare_d(void *a, unsigned long b)
 134 {
 135    int ret;
 136    LTC_ARGCHK(a != NULL);
 137    ret = mp_cmp_d(a, b);
 138    switch (ret) {
 139       case MP_LT: return LTC_MP_LT;
 140       case MP_EQ: return LTC_MP_EQ;
 141       case MP_GT: return LTC_MP_GT;
 142    }
 143    return 0;
 144 }
 145
 146 static int count_bits(void *a)
 147 {
 148    LTC_ARGCHK(a != NULL);
 149    return mp_count_bits(a);
 150 }
 151
 152 static int count_lsb_bits(void *a)
 153 {
 154    LTC_ARGCHK(a != NULL);
 155    return mp_cnt_lsb(a);
 156 }
 157
 158
 159 static int twoexpt(void *a, int n)
 160 {
 161    LTC_ARGCHK(a != NULL);
 162    return mpi_to_ltc_error(mp_2expt(a, n));
 163 }
 164
 165 /* ---- conversions ---- */
 166
 167 /* read ascii string */
 168 static int read_radix(void *a, const char *b, int radix)
 169 {
 170    LTC_ARGCHK(a != NULL);
 171    LTC_ARGCHK(b != NULL);
 172    return mpi_to_ltc_error(mp_read_radix(a, b, radix));
 173 }
 174
 175 /* write one */
 176 static int write_radix(void *a, char *b, int radix)
 177 {
 178    LTC_ARGCHK(a != NULL);
 179    LTC_ARGCHK(b != NULL);
 180    return mpi_to_ltc_error(mp_toradix(a, b, radix));
 181 }
 182
 183 /* get size as unsigned char string */
 184 static unsigned long unsigned_size(void *a)
 185 {
 186    LTC_ARGCHK(a != NULL);
 187    return mp_unsigned_bin_size(a);
 188 }
 189
 190 /* store */
 191 static int unsigned_write(void *a, unsigned char *b)
 192 {
 193    LTC_ARGCHK(a != NULL);
 194    LTC_ARGCHK(b != NULL);
 195    return mpi_to_ltc_error(mp_to_unsigned_bin(a, b));
 196 }
 197
 198 /* read */
 199 static int unsigned_read(void *a, unsigned char *b, unsigned long len)
 200 {
 201    LTC_ARGCHK(a != NULL);
 202    LTC_ARGCHK(b != NULL);
 203    return mpi_to_ltc_error(mp_read_unsigned_bin(a, b, len));
 204 }
 205
 206 /* add */
 207 static int add(void *a, void *b, void *c)
 208 {
 209    LTC_ARGCHK(a != NULL);
 210    LTC_ARGCHK(b != NULL);
 211    LTC_ARGCHK(c != NULL);
 212    return mpi_to_ltc_error(mp_add(a, b, c));
 213 }
 214
 215 static int addi(void *a, unsigned long b, void *c)
 216 {
 217    LTC_ARGCHK(a != NULL);
 218    LTC_ARGCHK(c != NULL);
 219    return mpi_to_ltc_error(mp_add_d(a, b, c));
 220 }
 221
 222 /* sub */
 223 static int sub(void *a, void *b, void *c)
 224 {
 225    LTC_ARGCHK(a != NULL);
 226    LTC_ARGCHK(b != NULL);
 227    LTC_ARGCHK(c != NULL);
 228    return mpi_to_ltc_error(mp_sub(a, b, c));
 229 }
 230
 231 static int subi(void *a, unsigned long b, void *c)
 232 {
 233    LTC_ARGCHK(a != NULL);
 234    LTC_ARGCHK(c != NULL);
 235    return mpi_to_ltc_error(mp_sub_d(a, b, c));
 236 }
 237
 238 /* mul */
 239 static int mul(void *a, void *b, void *c)
 240 {
 241    LTC_ARGCHK(a != NULL);
 242    LTC_ARGCHK(b != NULL);
 243    LTC_ARGCHK(c != NULL);
 244    return mpi_to_ltc_error(mp_mul(a, b, c));
 245 }
 246
 247 static int muli(void *a, unsigned long b, void *c)
 248 {
 249    LTC_ARGCHK(a != NULL);
 250    LTC_ARGCHK(c != NULL);
 251    return mpi_to_ltc_error(mp_mul_d(a, b, c));
 252 }
 253
 254 /* sqr */
 255 static int sqr(void *a, void *b)
 256 {
 257    LTC_ARGCHK(a != NULL);
 258    LTC_ARGCHK(b != NULL);
 259    return mpi_to_ltc_error(mp_sqr(a, b));
 260 }
 261
 262 /* div */
 263 static int divide(void *a, void *b, void *c, void *d)
 264 {
 265    LTC_ARGCHK(a != NULL);
 266    LTC_ARGCHK(b != NULL);
 267    return mpi_to_ltc_error(mp_div(a, b, c, d));
 268 }
 269
 270 static int div_2(void *a, void *b)
 271 {
 272    LTC_ARGCHK(a != NULL);
 273    LTC_ARGCHK(b != NULL);
 274    return mpi_to_ltc_error(mp_div_2(a, b));
 275 }
 276
 277 /* modi */
 278 static int modi(void *a, unsigned long b, unsigned long *c)
 279 {
 280    mp_digit tmp;
 281    int      err;
 282
 283    LTC_ARGCHK(a != NULL);
 284    LTC_ARGCHK(c != NULL);
 285
 286    if ((err = mpi_to_ltc_error(mp_mod_d(a, b, &tmp))) != CRYPT_OK) {
 287       return err;
 288    }
 289    *c = tmp;
 290    return CRYPT_OK;
 291 }
 292
 293 /* gcd */
 294 static int gcd(void *a, void *b, void *c)
 295 {
 296    LTC_ARGCHK(a != NULL);
 297    LTC_ARGCHK(b != NULL);
 298    LTC_ARGCHK(c != NULL);
 299    return mpi_to_ltc_error(mp_gcd(a, b, c));
 300 }
 301
 302 /* lcm */
 303 static int lcm(void *a, void *b, void *c)
 304 {
 305    LTC_ARGCHK(a != NULL);
 306    LTC_ARGCHK(b != NULL);
 307    LTC_ARGCHK(c != NULL);
 308    return mpi_to_ltc_error(mp_lcm(a, b, c));
 309 }
 310
 311 static int mulmod(void *a, void *b, void *c, void *d)
 312 {
 313    LTC_ARGCHK(a != NULL);
 314    LTC_ARGCHK(b != NULL);
 315    LTC_ARGCHK(c != NULL);
 316    LTC_ARGCHK(d != NULL);
 317    return mpi_to_ltc_error(mp_mulmod(a,b,c,d));
 318 }
 319
 320 static int sqrmod(void *a, void *b, void *c)
 321 {
 322    LTC_ARGCHK(a != NULL);
 323    LTC_ARGCHK(b != NULL);
 324    LTC_ARGCHK(c != NULL);
 325    return mpi_to_ltc_error(mp_sqrmod(a,b,c));
 326 }
 327
 328 /* invmod */
 329 static int invmod(void *a, void *b, void *c)
 330 {
 331    LTC_ARGCHK(a != NULL);
 332    LTC_ARGCHK(b != NULL);
 333    LTC_ARGCHK(c != NULL);
 334    return mpi_to_ltc_error(mp_invmod(a, b, c));
 335 }
 336
 337 /* setup */
 338 static int montgomery_setup(void *a, void **b)
 339 {
 340    int err;
 341    LTC_ARGCHK(a != NULL);
 342    LTC_ARGCHK(b != NULL);
 343    *b = XCALLOC(1, sizeof(mp_digit));
 344    if (*b == NULL) {
 345       return CRYPT_MEM;
 346    }
 347    if ((err = mpi_to_ltc_error(mp_montgomery_setup(a, (mp_digit *)*b))) != CRYPT_OK) {
 348       XFREE(*b);
 349    }
 350    return err;
 351 }
 352
 353 /* get normalization value */
 354 static int montgomery_normalization(void *a, void *b)
 355 {
 356    LTC_ARGCHK(a != NULL);
 357    LTC_ARGCHK(b != NULL);
 358    return mpi_to_ltc_error(mp_montgomery_calc_normalization(a, b));
 359 }
 360
 361 /* reduce */
 362 static int montgomery_reduce(void *a, void *b, void *c)
 363 {
 364    LTC_ARGCHK(a != NULL);
 365    LTC_ARGCHK(b != NULL);
 366    LTC_ARGCHK(c != NULL);
 367    return mpi_to_ltc_error(mp_montgomery_reduce(a, b, *((mp_digit *)c)));
 368 }
 369
 370 /* clean up */
 371 static void montgomery_deinit(void *a)
 372 {
 373    XFREE(a);
 374 }
 375
 376 static int exptmod(void *a, void *b, void *c, void *d)
 377 {
 378    LTC_ARGCHK(a != NULL);
 379    LTC_ARGCHK(b != NULL);
 380    LTC_ARGCHK(c != NULL);
 381    LTC_ARGCHK(d != NULL);
 382    return mpi_to_ltc_error(mp_exptmod(a,b,c,d));
 383 }
 384
 385 static int isprime(void *a, int *b)
 386 {
 387    int err;
 388    LTC_ARGCHK(a != NULL);
 389    LTC_ARGCHK(b != NULL);
 390    err = mpi_to_ltc_error(mp_prime_is_prime(a, 8, b));
 391    *b = (*b == MP_YES) ? LTC_MP_YES : LTC_MP_NO;
 392    return err;
 393 }
 394
 395 const ltc_math_descriptor ltm_desc = {
 396
 397    "LibTomMath",
 398    (int)DIGIT_BIT,
 399
 400    &init,
 401    &init_copy,
 402    &deinit,
 403
 404    &neg,
 405    &copy,
 406
 407    &set_int,
 408    &get_int,
 409    &get_digit,
 410    &get_digit_count,
 411    &compare,
 412    &compare_d,
 413    &count_bits,
 414    &count_lsb_bits,
 415    &twoexpt,
 416
 417    &read_radix,
 418    &write_radix,
 419    &unsigned_size,
 420    &unsigned_write,
 421    &unsigned_read,
 422
 423    &add,
 424    &addi,
 425    &sub,
 426    &subi,
 427    &mul,
 428    &muli,
 429    &sqr,
 430    &divide,
 431    &div_2,
 432    &modi,
 433    &gcd,
 434    &lcm,
 435
 436    &mulmod,
 437    &sqrmod,
 438    &invmod,
 439
 440    &montgomery_setup,
 441    &montgomery_normalization,
 442    &montgomery_reduce,
 443    &montgomery_deinit,
 444
 445    &exptmod,
 446    &isprime,
 447
 448 #ifdef MECC
 449 #ifdef MECC_FP
 450    &ltc_ecc_fp_mulmod,
 451 #else
 452    &ltc_ecc_mulmod,
 453 #endif
 454    &ltc_ecc_projective_add_point,
 455    &ltc_ecc_projective_dbl_point,
 456    &ltc_ecc_map,
 457 #ifdef LTC_ECC_SHAMIR
 458 #ifdef MECC_FP
 459    &ltc_ecc_fp_mul2add,
 460 #else
 461    &ltc_ecc_mul2add,
 462 #endif /* MECC_FP */
 463 #else
 464    NULL,
 465 #endif /* LTC_ECC_SHAMIR */
 466 #else
 467    NULL, NULL, NULL, NULL, NULL,
 468 #endif /* MECC */
 469
 470 #ifdef MRSA
 471    &rsa_make_key,
 472    &rsa_exptmod,
 473 #else
 474    NULL, NULL
 475 #endif
 476 };
 477
 478
 479 #endif
 480
 481 /* $Source: /cvs/libtom/libtomcrypt/src/math/ltm_desc.c,v $ */
 482 /* $Revision: 1.29 $ */
 483 /* $Date: 2006/12/03 00:39:56 $ */