]> pd.if.org Git - zpackage/blob - libtomcrypt/src/math/tfm_desc.c
commit files needed for zpm-fetchurl
[zpackage] / libtomcrypt / src / math / tfm_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
10 #define DESC_DEF_ONLY
11 #include "tomcrypt.h"
12
13 #ifdef TFM_DESC
14
15 #include <tfm.h>
16
17 static const struct {
18     int tfm_code, ltc_code;
19 } tfm_to_ltc_codes[] = {
20    { FP_OKAY ,  CRYPT_OK},
21    { FP_MEM  ,  CRYPT_MEM},
22    { FP_VAL  ,  CRYPT_INVALID_ARG},
23 };
24
25 /**
26    Convert a tfm error to a LTC error (Possibly the most powerful function ever!  Oh wait... no)
27    @param err    The error to convert
28    @return The equivalent LTC error code or CRYPT_ERROR if none found
29 */
30 static int tfm_to_ltc_error(int err)
31 {
32    int x;
33
34    for (x = 0; x < (int)(sizeof(tfm_to_ltc_codes)/sizeof(tfm_to_ltc_codes[0])); x++) {
35        if (err == tfm_to_ltc_codes[x].tfm_code) {
36           return tfm_to_ltc_codes[x].ltc_code;
37        }
38    }
39    return CRYPT_ERROR;
40 }
41
42 static int init(void **a)
43 {
44    LTC_ARGCHK(a != NULL);
45
46    *a = XCALLOC(1, sizeof(fp_int));
47    if (*a == NULL) {
48       return CRYPT_MEM;
49    }
50    fp_init(*a);
51    return CRYPT_OK;
52 }
53
54 static void deinit(void *a)
55 {
56    LTC_ARGCHKVD(a != NULL);
57    XFREE(a);
58 }
59
60 static int neg(void *a, void *b)
61 {
62    LTC_ARGCHK(a != NULL);
63    LTC_ARGCHK(b != NULL);
64    fp_neg(((fp_int*)a), ((fp_int*)b));
65    return CRYPT_OK;
66 }
67
68 static int copy(void *a, void *b)
69 {
70    LTC_ARGCHK(a != NULL);
71    LTC_ARGCHK(b != NULL);
72    fp_copy(a, b);
73    return CRYPT_OK;
74 }
75
76 static int init_copy(void **a, void *b)
77 {
78    if (init(a) != CRYPT_OK) {
79       return CRYPT_MEM;
80    }
81    return copy(b, *a);
82 }
83
84 /* ---- trivial ---- */
85 static int set_int(void *a, ltc_mp_digit b)
86 {
87    LTC_ARGCHK(a != NULL);
88    fp_set(a, b);
89    return CRYPT_OK;
90 }
91
92 static unsigned long get_int(void *a)
93 {
94    fp_int *A;
95    LTC_ARGCHK(a != NULL);
96    A = a;
97    return A->used > 0 ? A->dp[0] : 0;
98 }
99
100 static ltc_mp_digit get_digit(void *a, int n)
101 {
102    fp_int *A;
103    LTC_ARGCHK(a != NULL);
104    A = a;
105    return (n >= A->used || n < 0) ? 0 : A->dp[n];
106 }
107
108 static int get_digit_count(void *a)
109 {
110    fp_int *A;
111    LTC_ARGCHK(a != NULL);
112    A = a;
113    return A->used;
114 }
115
116 static int compare(void *a, void *b)
117 {
118    int ret;
119    LTC_ARGCHK(a != NULL);
120    LTC_ARGCHK(b != NULL);
121    ret = fp_cmp(a, b);
122    switch (ret) {
123       case FP_LT: return LTC_MP_LT;
124       case FP_EQ: return LTC_MP_EQ;
125       case FP_GT: return LTC_MP_GT;
126    }
127    return 0;
128 }
129
130 static int compare_d(void *a, ltc_mp_digit b)
131 {
132    int ret;
133    LTC_ARGCHK(a != NULL);
134    ret = fp_cmp_d(a, b);
135    switch (ret) {
136       case FP_LT: return LTC_MP_LT;
137       case FP_EQ: return LTC_MP_EQ;
138       case FP_GT: return LTC_MP_GT;
139    }
140    return 0;
141 }
142
143 static int count_bits(void *a)
144 {
145    LTC_ARGCHK(a != NULL);
146    return fp_count_bits(a);
147 }
148
149 static int count_lsb_bits(void *a)
150 {
151    LTC_ARGCHK(a != NULL);
152    return fp_cnt_lsb(a);
153 }
154
155 static int twoexpt(void *a, int n)
156 {
157    LTC_ARGCHK(a != NULL);
158    fp_2expt(a, n);
159    return CRYPT_OK;
160 }
161
162 /* ---- conversions ---- */
163
164 /* read ascii string */
165 static int read_radix(void *a, const char *b, int radix)
166 {
167    LTC_ARGCHK(a != NULL);
168    LTC_ARGCHK(b != NULL);
169    return tfm_to_ltc_error(fp_read_radix(a, (char *)b, radix));
170 }
171
172 /* write one */
173 static int write_radix(void *a, char *b, int radix)
174 {
175    LTC_ARGCHK(a != NULL);
176    LTC_ARGCHK(b != NULL);
177    return tfm_to_ltc_error(fp_toradix(a, b, radix));
178 }
179
180 /* get size as unsigned char string */
181 static unsigned long unsigned_size(void *a)
182 {
183    LTC_ARGCHK(a != NULL);
184    return fp_unsigned_bin_size(a);
185 }
186
187 /* store */
188 static int unsigned_write(void *a, unsigned char *b)
189 {
190    LTC_ARGCHK(a != NULL);
191    LTC_ARGCHK(b != NULL);
192    fp_to_unsigned_bin(a, b);
193    return CRYPT_OK;
194 }
195
196 /* read */
197 static int unsigned_read(void *a, unsigned char *b, unsigned long len)
198 {
199    LTC_ARGCHK(a != NULL);
200    LTC_ARGCHK(b != NULL);
201    fp_read_unsigned_bin(a, b, len);
202    return CRYPT_OK;
203 }
204
205 /* add */
206 static int add(void *a, void *b, void *c)
207 {
208    LTC_ARGCHK(a != NULL);
209    LTC_ARGCHK(b != NULL);
210    LTC_ARGCHK(c != NULL);
211    fp_add(a, b, c);
212    return CRYPT_OK;
213 }
214
215 static int addi(void *a, ltc_mp_digit b, void *c)
216 {
217    LTC_ARGCHK(a != NULL);
218    LTC_ARGCHK(c != NULL);
219    fp_add_d(a, b, c);
220    return CRYPT_OK;
221 }
222
223 /* sub */
224 static int sub(void *a, void *b, void *c)
225 {
226    LTC_ARGCHK(a != NULL);
227    LTC_ARGCHK(b != NULL);
228    LTC_ARGCHK(c != NULL);
229    fp_sub(a, b, c);
230    return CRYPT_OK;
231 }
232
233 static int subi(void *a, ltc_mp_digit b, void *c)
234 {
235    LTC_ARGCHK(a != NULL);
236    LTC_ARGCHK(c != NULL);
237    fp_sub_d(a, b, c);
238    return CRYPT_OK;
239 }
240
241 /* mul */
242 static int mul(void *a, void *b, void *c)
243 {
244    LTC_ARGCHK(a != NULL);
245    LTC_ARGCHK(b != NULL);
246    LTC_ARGCHK(c != NULL);
247    fp_mul(a, b, c);
248    return CRYPT_OK;
249 }
250
251 static int muli(void *a, ltc_mp_digit b, void *c)
252 {
253    LTC_ARGCHK(a != NULL);
254    LTC_ARGCHK(c != NULL);
255    fp_mul_d(a, b, c);
256    return CRYPT_OK;
257 }
258
259 /* sqr */
260 static int sqr(void *a, void *b)
261 {
262    LTC_ARGCHK(a != NULL);
263    LTC_ARGCHK(b != NULL);
264    fp_sqr(a, b);
265    return CRYPT_OK;
266 }
267
268 /* div */
269 static int divide(void *a, void *b, void *c, void *d)
270 {
271    LTC_ARGCHK(a != NULL);
272    LTC_ARGCHK(b != NULL);
273    return tfm_to_ltc_error(fp_div(a, b, c, d));
274 }
275
276 static int div_2(void *a, void *b)
277 {
278    LTC_ARGCHK(a != NULL);
279    LTC_ARGCHK(b != NULL);
280    fp_div_2(a, b);
281    return CRYPT_OK;
282 }
283
284 /* modi */
285 static int modi(void *a, ltc_mp_digit b, ltc_mp_digit *c)
286 {
287    fp_digit tmp;
288    int      err;
289
290    LTC_ARGCHK(a != NULL);
291    LTC_ARGCHK(c != NULL);
292
293    if ((err = tfm_to_ltc_error(fp_mod_d(a, b, &tmp))) != CRYPT_OK) {
294       return err;
295    }
296    *c = tmp;
297    return CRYPT_OK;
298 }
299
300 /* gcd */
301 static int gcd(void *a, void *b, void *c)
302 {
303    LTC_ARGCHK(a != NULL);
304    LTC_ARGCHK(b != NULL);
305    LTC_ARGCHK(c != NULL);
306    fp_gcd(a, b, c);
307    return CRYPT_OK;
308 }
309
310 /* lcm */
311 static int lcm(void *a, void *b, void *c)
312 {
313    LTC_ARGCHK(a != NULL);
314    LTC_ARGCHK(b != NULL);
315    LTC_ARGCHK(c != NULL);
316    fp_lcm(a, b, c);
317    return CRYPT_OK;
318 }
319
320 static int addmod(void *a, void *b, void *c, void *d)
321 {
322    LTC_ARGCHK(a != NULL);
323    LTC_ARGCHK(b != NULL);
324    LTC_ARGCHK(c != NULL);
325    LTC_ARGCHK(d != NULL);
326    return tfm_to_ltc_error(fp_addmod(a,b,c,d));
327 }
328
329 static int submod(void *a, void *b, void *c, void *d)
330 {
331    LTC_ARGCHK(a != NULL);
332    LTC_ARGCHK(b != NULL);
333    LTC_ARGCHK(c != NULL);
334    LTC_ARGCHK(d != NULL);
335    return tfm_to_ltc_error(fp_submod(a,b,c,d));
336 }
337
338 static int mulmod(void *a, void *b, void *c, void *d)
339 {
340    LTC_ARGCHK(a != NULL);
341    LTC_ARGCHK(b != NULL);
342    LTC_ARGCHK(c != NULL);
343    LTC_ARGCHK(d != NULL);
344    return tfm_to_ltc_error(fp_mulmod(a,b,c,d));
345 }
346
347 static int sqrmod(void *a, void *b, void *c)
348 {
349    LTC_ARGCHK(a != NULL);
350    LTC_ARGCHK(b != NULL);
351    LTC_ARGCHK(c != NULL);
352    return tfm_to_ltc_error(fp_sqrmod(a,b,c));
353 }
354
355 /* invmod */
356 static int invmod(void *a, void *b, void *c)
357 {
358    LTC_ARGCHK(a != NULL);
359    LTC_ARGCHK(b != NULL);
360    LTC_ARGCHK(c != NULL);
361    return tfm_to_ltc_error(fp_invmod(a, b, c));
362 }
363
364 /* setup */
365 static int montgomery_setup(void *a, void **b)
366 {
367    int err;
368    LTC_ARGCHK(a != NULL);
369    LTC_ARGCHK(b != NULL);
370    *b = XCALLOC(1, sizeof(fp_digit));
371    if (*b == NULL) {
372       return CRYPT_MEM;
373    }
374    if ((err = tfm_to_ltc_error(fp_montgomery_setup(a, (fp_digit *)*b))) != CRYPT_OK) {
375       XFREE(*b);
376    }
377    return err;
378 }
379
380 /* get normalization value */
381 static int montgomery_normalization(void *a, void *b)
382 {
383    LTC_ARGCHK(a != NULL);
384    LTC_ARGCHK(b != NULL);
385    fp_montgomery_calc_normalization(a, b);
386    return CRYPT_OK;
387 }
388
389 /* reduce */
390 static int montgomery_reduce(void *a, void *b, void *c)
391 {
392    LTC_ARGCHK(a != NULL);
393    LTC_ARGCHK(b != NULL);
394    LTC_ARGCHK(c != NULL);
395    fp_montgomery_reduce(a, b, *((fp_digit *)c));
396    return CRYPT_OK;
397 }
398
399 /* clean up */
400 static void montgomery_deinit(void *a)
401 {
402    XFREE(a);
403 }
404
405 static int exptmod(void *a, void *b, void *c, void *d)
406 {
407    LTC_ARGCHK(a != NULL);
408    LTC_ARGCHK(b != NULL);
409    LTC_ARGCHK(c != NULL);
410    LTC_ARGCHK(d != NULL);
411    return tfm_to_ltc_error(fp_exptmod(a,b,c,d));
412 }
413
414 static int isprime(void *a, int b, int *c)
415 {
416    LTC_ARGCHK(a != NULL);
417    LTC_ARGCHK(c != NULL);
418    if (b == 0) {
419        b = LTC_MILLER_RABIN_REPS;
420    } /* if */
421    *c = (fp_isprime_ex(a, b) == FP_YES) ? LTC_MP_YES : LTC_MP_NO;
422    return CRYPT_OK;
423 }
424
425 #if defined(LTC_MECC) && defined(LTC_MECC_ACCEL)
426
427 static int tfm_ecc_projective_dbl_point(ecc_point *P, ecc_point *R, void *modulus, void *Mp)
428 {
429    fp_int t1, t2;
430    fp_digit mp;
431
432    LTC_ARGCHK(P       != NULL);
433    LTC_ARGCHK(R       != NULL);
434    LTC_ARGCHK(modulus != NULL);
435    LTC_ARGCHK(Mp      != NULL);
436
437    mp = *((fp_digit*)Mp);
438
439    fp_init(&t1);
440    fp_init(&t2);
441
442    if (P != R) {
443       fp_copy(P->x, R->x);
444       fp_copy(P->y, R->y);
445       fp_copy(P->z, R->z);
446    }
447
448    /* t1 = Z * Z */
449    fp_sqr(R->z, &t1);
450    fp_montgomery_reduce(&t1, modulus, mp);
451    /* Z = Y * Z */
452    fp_mul(R->z, R->y, R->z);
453    fp_montgomery_reduce(R->z, modulus, mp);
454    /* Z = 2Z */
455    fp_add(R->z, R->z, R->z);
456    if (fp_cmp(R->z, modulus) != FP_LT) {
457       fp_sub(R->z, modulus, R->z);
458    }
459
460    /* &t2 = X - T1 */
461    fp_sub(R->x, &t1, &t2);
462    if (fp_cmp_d(&t2, 0) == FP_LT) {
463       fp_add(&t2, modulus, &t2);
464    }
465    /* T1 = X + T1 */
466    fp_add(&t1, R->x, &t1);
467    if (fp_cmp(&t1, modulus) != FP_LT) {
468       fp_sub(&t1, modulus, &t1);
469    }
470    /* T2 = T1 * T2 */
471    fp_mul(&t1, &t2, &t2);
472    fp_montgomery_reduce(&t2, modulus, mp);
473    /* T1 = 2T2 */
474    fp_add(&t2, &t2, &t1);
475    if (fp_cmp(&t1, modulus) != FP_LT) {
476       fp_sub(&t1, modulus, &t1);
477    }
478    /* T1 = T1 + T2 */
479    fp_add(&t1, &t2, &t1);
480    if (fp_cmp(&t1, modulus) != FP_LT) {
481       fp_sub(&t1, modulus, &t1);
482    }
483
484    /* Y = 2Y */
485    fp_add(R->y, R->y, R->y);
486    if (fp_cmp(R->y, modulus) != FP_LT) {
487       fp_sub(R->y, modulus, R->y);
488    }
489    /* Y = Y * Y */
490    fp_sqr(R->y, R->y);
491    fp_montgomery_reduce(R->y, modulus, mp);
492    /* T2 = Y * Y */
493    fp_sqr(R->y, &t2);
494    fp_montgomery_reduce(&t2, modulus, mp);
495    /* T2 = T2/2 */
496    if (fp_isodd(&t2)) {
497       fp_add(&t2, modulus, &t2);
498    }
499    fp_div_2(&t2, &t2);
500    /* Y = Y * X */
501    fp_mul(R->y, R->x, R->y);
502    fp_montgomery_reduce(R->y, modulus, mp);
503
504    /* X  = T1 * T1 */
505    fp_sqr(&t1, R->x);
506    fp_montgomery_reduce(R->x, modulus, mp);
507    /* X = X - Y */
508    fp_sub(R->x, R->y, R->x);
509    if (fp_cmp_d(R->x, 0) == FP_LT) {
510       fp_add(R->x, modulus, R->x);
511    }
512    /* X = X - Y */
513    fp_sub(R->x, R->y, R->x);
514    if (fp_cmp_d(R->x, 0) == FP_LT) {
515       fp_add(R->x, modulus, R->x);
516    }
517
518    /* Y = Y - X */
519    fp_sub(R->y, R->x, R->y);
520    if (fp_cmp_d(R->y, 0) == FP_LT) {
521       fp_add(R->y, modulus, R->y);
522    }
523    /* Y = Y * T1 */
524    fp_mul(R->y, &t1, R->y);
525    fp_montgomery_reduce(R->y, modulus, mp);
526    /* Y = Y - T2 */
527    fp_sub(R->y, &t2, R->y);
528    if (fp_cmp_d(R->y, 0) == FP_LT) {
529       fp_add(R->y, modulus, R->y);
530    }
531
532    return CRYPT_OK;
533 }
534
535 /**
536    Add two ECC points
537    @param P        The point to add
538    @param Q        The point to add
539    @param R        [out] The destination of the double
540    @param modulus  The modulus of the field the ECC curve is in
541    @param Mp       The "b" value from montgomery_setup()
542    @return CRYPT_OK on success
543 */
544 static int tfm_ecc_projective_add_point(ecc_point *P, ecc_point *Q, ecc_point *R, void *modulus, void *Mp)
545 {
546    fp_int  t1, t2, x, y, z;
547    fp_digit mp;
548
549    LTC_ARGCHK(P       != NULL);
550    LTC_ARGCHK(Q       != NULL);
551    LTC_ARGCHK(R       != NULL);
552    LTC_ARGCHK(modulus != NULL);
553    LTC_ARGCHK(Mp      != NULL);
554
555    mp = *((fp_digit*)Mp);
556
557    fp_init(&t1);
558    fp_init(&t2);
559    fp_init(&x);
560    fp_init(&y);
561    fp_init(&z);
562
563    /* should we dbl instead? */
564    fp_sub(modulus, Q->y, &t1);
565    if ( (fp_cmp(P->x, Q->x) == FP_EQ) &&
566         (Q->z != NULL && fp_cmp(P->z, Q->z) == FP_EQ) &&
567         (fp_cmp(P->y, Q->y) == FP_EQ || fp_cmp(P->y, &t1) == FP_EQ)) {
568         return tfm_ecc_projective_dbl_point(P, R, modulus, Mp);
569    }
570
571    fp_copy(P->x, &x);
572    fp_copy(P->y, &y);
573    fp_copy(P->z, &z);
574
575    /* if Z is one then these are no-operations */
576    if (Q->z != NULL) {
577       /* T1 = Z' * Z' */
578       fp_sqr(Q->z, &t1);
579       fp_montgomery_reduce(&t1, modulus, mp);
580       /* X = X * T1 */
581       fp_mul(&t1, &x, &x);
582       fp_montgomery_reduce(&x, modulus, mp);
583       /* T1 = Z' * T1 */
584       fp_mul(Q->z, &t1, &t1);
585       fp_montgomery_reduce(&t1, modulus, mp);
586       /* Y = Y * T1 */
587       fp_mul(&t1, &y, &y);
588       fp_montgomery_reduce(&y, modulus, mp);
589    }
590
591    /* T1 = Z*Z */
592    fp_sqr(&z, &t1);
593    fp_montgomery_reduce(&t1, modulus, mp);
594    /* T2 = X' * T1 */
595    fp_mul(Q->x, &t1, &t2);
596    fp_montgomery_reduce(&t2, modulus, mp);
597    /* T1 = Z * T1 */
598    fp_mul(&z, &t1, &t1);
599    fp_montgomery_reduce(&t1, modulus, mp);
600    /* T1 = Y' * T1 */
601    fp_mul(Q->y, &t1, &t1);
602    fp_montgomery_reduce(&t1, modulus, mp);
603
604    /* Y = Y - T1 */
605    fp_sub(&y, &t1, &y);
606    if (fp_cmp_d(&y, 0) == FP_LT) {
607       fp_add(&y, modulus, &y);
608    }
609    /* T1 = 2T1 */
610    fp_add(&t1, &t1, &t1);
611    if (fp_cmp(&t1, modulus) != FP_LT) {
612       fp_sub(&t1, modulus, &t1);
613    }
614    /* T1 = Y + T1 */
615    fp_add(&t1, &y, &t1);
616    if (fp_cmp(&t1, modulus) != FP_LT) {
617       fp_sub(&t1, modulus, &t1);
618    }
619    /* X = X - T2 */
620    fp_sub(&x, &t2, &x);
621    if (fp_cmp_d(&x, 0) == FP_LT) {
622       fp_add(&x, modulus, &x);
623    }
624    /* T2 = 2T2 */
625    fp_add(&t2, &t2, &t2);
626    if (fp_cmp(&t2, modulus) != FP_LT) {
627       fp_sub(&t2, modulus, &t2);
628    }
629    /* T2 = X + T2 */
630    fp_add(&t2, &x, &t2);
631    if (fp_cmp(&t2, modulus) != FP_LT) {
632       fp_sub(&t2, modulus, &t2);
633    }
634
635    /* if Z' != 1 */
636    if (Q->z != NULL) {
637       /* Z = Z * Z' */
638       fp_mul(&z, Q->z, &z);
639       fp_montgomery_reduce(&z, modulus, mp);
640    }
641
642    /* Z = Z * X */
643    fp_mul(&z, &x, &z);
644    fp_montgomery_reduce(&z, modulus, mp);
645
646    /* T1 = T1 * X  */
647    fp_mul(&t1, &x, &t1);
648    fp_montgomery_reduce(&t1, modulus, mp);
649    /* X = X * X */
650    fp_sqr(&x, &x);
651    fp_montgomery_reduce(&x, modulus, mp);
652    /* T2 = T2 * x */
653    fp_mul(&t2, &x, &t2);
654    fp_montgomery_reduce(&t2, modulus, mp);
655    /* T1 = T1 * X  */
656    fp_mul(&t1, &x, &t1);
657    fp_montgomery_reduce(&t1, modulus, mp);
658
659    /* X = Y*Y */
660    fp_sqr(&y, &x);
661    fp_montgomery_reduce(&x, modulus, mp);
662    /* X = X - T2 */
663    fp_sub(&x, &t2, &x);
664    if (fp_cmp_d(&x, 0) == FP_LT) {
665       fp_add(&x, modulus, &x);
666    }
667
668    /* T2 = T2 - X */
669    fp_sub(&t2, &x, &t2);
670    if (fp_cmp_d(&t2, 0) == FP_LT) {
671       fp_add(&t2, modulus, &t2);
672    }
673    /* T2 = T2 - X */
674    fp_sub(&t2, &x, &t2);
675    if (fp_cmp_d(&t2, 0) == FP_LT) {
676       fp_add(&t2, modulus, &t2);
677    }
678    /* T2 = T2 * Y */
679    fp_mul(&t2, &y, &t2);
680    fp_montgomery_reduce(&t2, modulus, mp);
681    /* Y = T2 - T1 */
682    fp_sub(&t2, &t1, &y);
683    if (fp_cmp_d(&y, 0) == FP_LT) {
684       fp_add(&y, modulus, &y);
685    }
686    /* Y = Y/2 */
687    if (fp_isodd(&y)) {
688       fp_add(&y, modulus, &y);
689    }
690    fp_div_2(&y, &y);
691
692    fp_copy(&x, R->x);
693    fp_copy(&y, R->y);
694    fp_copy(&z, R->z);
695
696    return CRYPT_OK;
697 }
698
699
700 #endif
701
702 static int set_rand(void *a, int size)
703 {
704    LTC_ARGCHK(a != NULL);
705    fp_rand(a, size);
706    return CRYPT_OK;
707 }
708
709 const ltc_math_descriptor tfm_desc = {
710
711    "TomsFastMath",
712    (int)DIGIT_BIT,
713
714    &init,
715    &init_copy,
716    &deinit,
717
718    &neg,
719    &copy,
720
721    &set_int,
722    &get_int,
723    &get_digit,
724    &get_digit_count,
725    &compare,
726    &compare_d,
727    &count_bits,
728    &count_lsb_bits,
729    &twoexpt,
730
731    &read_radix,
732    &write_radix,
733    &unsigned_size,
734    &unsigned_write,
735    &unsigned_read,
736
737    &add,
738    &addi,
739    &sub,
740    &subi,
741    &mul,
742    &muli,
743    &sqr,
744    &divide,
745    &div_2,
746    &modi,
747    &gcd,
748    &lcm,
749
750    &mulmod,
751    &sqrmod,
752    &invmod,
753
754    &montgomery_setup,
755    &montgomery_normalization,
756    &montgomery_reduce,
757    &montgomery_deinit,
758
759    &exptmod,
760    &isprime,
761
762 #ifdef LTC_MECC
763 #ifdef LTC_MECC_FP
764    &ltc_ecc_fp_mulmod,
765 #else
766    &ltc_ecc_mulmod,
767 #endif /* LTC_MECC_FP */
768 #ifdef LTC_MECC_ACCEL
769    &tfm_ecc_projective_add_point,
770    &tfm_ecc_projective_dbl_point,
771 #else
772    &ltc_ecc_projective_add_point,
773    &ltc_ecc_projective_dbl_point,
774 #endif /* LTC_MECC_ACCEL */
775    &ltc_ecc_map,
776 #ifdef LTC_ECC_SHAMIR
777 #ifdef LTC_MECC_FP
778    &ltc_ecc_fp_mul2add,
779 #else
780    &ltc_ecc_mul2add,
781 #endif /* LTC_MECC_FP */
782 #else
783    NULL,
784 #endif /* LTC_ECC_SHAMIR */
785 #else
786    NULL, NULL, NULL, NULL, NULL,
787 #endif /* LTC_MECC */
788
789 #ifdef LTC_MRSA
790    &rsa_make_key,
791    &rsa_exptmod,
792 #else
793    NULL, NULL,
794 #endif
795    &addmod,
796    &submod,
797
798    set_rand,
799
800 };
801
802
803 #endif
804
805 /* ref:         $Format:%D$ */
806 /* git commit:  $Format:%H$ */
807 /* commit time: $Format:%ai$ */