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