Add GMAC to MAC API
[libgcrypt.git] / tests / mpitests.c
1 /* mpitests.c  -  basic mpi tests
2  *      Copyright (C) 2001, 2002, 2003, 2006 Free Software Foundation, Inc.
3  * Copyright (C) 2013 g10 Code GmbH
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdarg.h>
28
29 #ifdef _GCRYPT_IN_LIBGCRYPT
30 # include "../src/gcrypt-int.h"
31 #else
32 # include <gcrypt.h>
33 #endif
34
35 #define PGM "mpitests"
36
37 static int verbose;
38 static int debug;
39 static int error_count;
40
41
42 static void
43 die (const char *format, ...)
44 {
45   va_list arg_ptr ;
46
47   fflush (stdout);
48   fprintf (stderr, "%s: ", PGM);
49   va_start (arg_ptr, format) ;
50   vfprintf (stderr, format, arg_ptr );
51   va_end(arg_ptr);
52   if (*format && format[strlen(format)-1] != '\n')
53     putc ('\n', stderr);
54   exit (1);
55 }
56
57 static void
58 fail (const char *format, ...)
59 {
60   va_list arg_ptr;
61
62   fflush (stdout);
63   fprintf (stderr, "%s: ", PGM);
64   va_start (arg_ptr, format);
65   vfprintf (stderr, format, arg_ptr);
66   va_end (arg_ptr);
67   if (*format && format[strlen(format)-1] != '\n')
68     putc ('\n', stderr);
69   error_count++;
70   if (error_count >= 50)
71     die ("stopped after 50 errors.");
72 }
73
74
75 /* Set up some test patterns */
76
77 /* 48 bytes with value 1: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
78 unsigned char ones[] = {
79   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
80   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
81   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
82 };
83
84 /* 48 bytes with value 2: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
85 unsigned char twos[] = {
86   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
87   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
88   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
89 };
90
91 /* 48 bytes with value 3: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
92 unsigned char threes[] = {
93   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
94   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
95   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
96 };
97
98 /* 48 bytes with value 0x80: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
99 unsigned char eighties[] = {
100   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
101   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
102   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80
103 };
104
105 /* 48 bytes with value 0xff: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
106 unsigned char manyff[] = {
107   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
108   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
109   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
110 };
111
112
113 static int
114 test_const_and_immutable (void)
115 {
116   gcry_mpi_t one, second_one;
117
118   one = gcry_mpi_set_ui (NULL, 1);
119   if (gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE)
120       || gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
121     die ("immutable or const flag initially set\n");
122
123   second_one = gcry_mpi_copy (one);
124   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
125     die ("immutable flag set after copy\n");
126   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
127     die ("const flag set after copy\n");
128   gcry_mpi_release (second_one);
129
130   gcry_mpi_set_flag (one, GCRYMPI_FLAG_IMMUTABLE);
131   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE))
132     die ("failed to set immutable flag\n");
133   if (gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
134     die ("const flag unexpectly set\n");
135
136   second_one = gcry_mpi_copy (one);
137   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
138     die ("immutable flag not cleared after copy\n");
139   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
140     die ("const flag unexpectly set after copy\n");
141   gcry_mpi_release (second_one);
142
143   gcry_mpi_clear_flag (one, GCRYMPI_FLAG_IMMUTABLE);
144   if (gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE))
145     die ("failed to clear immutable flag\n");
146   if (gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
147     die ("const flag unexpectly set\n");
148
149   gcry_mpi_set_flag (one, GCRYMPI_FLAG_CONST);
150   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
151     die ("failed to set const flag\n");
152   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE))
153     die ("failed to set immutable flag with const flag\n");
154
155   second_one = gcry_mpi_copy (one);
156   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
157     die ("immutable flag not cleared after copy\n");
158   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
159     die ("const flag not cleared after copy\n");
160   gcry_mpi_release (second_one);
161
162   gcry_mpi_clear_flag (one, GCRYMPI_FLAG_IMMUTABLE);
163   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE))
164     die ("clearing immutable flag not ignored for a constant MPI\n");
165   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
166     die ("const flag unexpectly cleared\n");
167
168
169   second_one = gcry_mpi_set (NULL, GCRYMPI_CONST_ONE);
170   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
171     die ("immutable flag not cleared by mpi_set (NULL,x)\n");
172   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
173     die ("const flag not cleared by mpi_set (NULL,x)\n");
174   gcry_mpi_release (second_one);
175
176   second_one = gcry_mpi_set_ui (NULL, 42);
177   gcry_mpi_set (second_one, GCRYMPI_CONST_ONE);
178   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
179     die ("immutable flag not cleared after mpi_set (a,x)\n");
180   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
181     die ("const flag not cleared mpi_set (a,x)\n");
182   gcry_mpi_release (second_one);
183
184
185   /* Due to the the constant flag the release below should be a NOP
186      and will leak memory.  */
187   gcry_mpi_release (one);
188   return 1;
189 }
190
191
192 static void
193 test_opaque (void)
194 {
195   gcry_mpi_t a;
196   char *p;
197   unsigned int nbits;
198
199   p = gcry_xstrdup ("This is a test buffer");
200   a = gcry_mpi_set_opaque (NULL, p, 21*8+1); /* (a non byte aligned length) */
201
202   if (!gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
203     die ("opaque flag not set\n");
204
205   p = gcry_mpi_get_opaque (a, &nbits);
206   if (!p)
207     die ("gcry_mpi_get_opaque returned NULL\n");
208   if (nbits != 21*8+1)
209     die ("gcry_mpi_get_opaque returned a changed bit size\n");
210   if (strcmp (p, "This is a test buffer"))
211     die ("gcry_mpi_get_opaque returned a changed buffer\n");
212
213   if (debug)
214     gcry_log_debugmpi ("mpi", a);
215
216   p = gcry_xstrdup ("This is a test buffer");
217   a = gcry_mpi_set_opaque_copy (NULL, p, 21*8+1);
218   gcry_free (p);
219
220   if (!gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
221     die ("opaque flag not set\n");
222
223   p = gcry_mpi_get_opaque (a, &nbits);
224   if (!p)
225     die ("gcry_mpi_get_opaque returned NULL\n");
226   if (nbits != 21*8+1)
227     die ("gcry_mpi_get_opaque returned a changed bit size\n");
228   if (strcmp (p, "This is a test buffer"))
229     die ("gcry_mpi_get_opaque returned a changed buffer\n");
230
231   if (debug)
232     gcry_log_debugmpi ("mpi", a);
233
234   gcry_mpi_release (a);
235 }
236
237
238 static void
239 test_cmp (void)
240 {
241   gpg_error_t rc;
242   gcry_mpi_t zero, zero2;
243   gcry_mpi_t one;
244   gcry_mpi_t two;
245   gcry_mpi_t all_ones;
246   gcry_mpi_t opa1, opa2;
247   gcry_mpi_t opa1s, opa2s;
248   gcry_mpi_t opa0, opa02;
249
250   zero = gcry_mpi_new (0);
251   zero2= gcry_mpi_set_ui (NULL, 0);
252   one  = gcry_mpi_set_ui (NULL, 1);
253   two  = gcry_mpi_set_ui (NULL, 2);
254   rc = gcry_mpi_scan (&all_ones, GCRYMPI_FMT_USG, ones, sizeof(ones), NULL);
255   if (rc)
256     die ("scanning number failed at line %d", __LINE__);
257   opa0  = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("a"), 0);
258   opa02 = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("b"), 0);
259   opa1  = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("aaaaaaaaaaaaaaaa"), 16*8);
260   opa1s = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("a"), 1*8);
261   opa2  = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("bbbbbbbbbbbbbbbb"), 16*8);
262   opa2s = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("b"), 1*8);
263
264
265   /* Single limb test with cmp_ui */
266   if (gcry_mpi_cmp_ui (zero, 0))
267     fail ("mpi_cmp_ui failed at line %d", __LINE__);
268   if (!(gcry_mpi_cmp_ui (zero, 1) < 0))
269     fail ("mpi_cmp_ui failed at line %d", __LINE__);
270   if (!(gcry_mpi_cmp_ui (zero, (-1)) < 0))
271     fail ("mpi_cmp_ui failed at line %d", __LINE__);
272
273   if (gcry_mpi_cmp_ui (two, 2))
274     fail ("mpi_cmp_ui failed at line %d", __LINE__);
275   if (!(gcry_mpi_cmp_ui (two, 3) < 0))
276     fail ("mpi_cmp_ui failed at line %d", __LINE__);
277   if (!(gcry_mpi_cmp_ui (two, 1) > 0))
278     fail ("mpi_cmp_ui failed at line %d", __LINE__);
279
280   /* Multi limb tests with cmp_ui.  */
281   if (!(gcry_mpi_cmp_ui (all_ones, 0) > 0))
282     fail ("mpi_cmp_ui failed at line %d", __LINE__);
283   if (!(gcry_mpi_cmp_ui (all_ones, (-1)) > 0))
284     fail ("mpi_cmp_ui failed at line %d", __LINE__);
285
286   /* Single limb test with cmp */
287   if (gcry_mpi_cmp (zero, zero2))
288     fail ("mpi_cmp failed at line %d", __LINE__);
289   if (!(gcry_mpi_cmp (zero, one) < 0))
290     fail ("mpi_cmp failed at line %d", __LINE__);
291   if (!(gcry_mpi_cmp (one, zero) > 0))
292     fail ("mpi_cmp failed at line %d", __LINE__);
293
294   gcry_mpi_neg (one, one);
295   if (!(gcry_mpi_cmp (zero, one) > 0))
296     fail ("mpi_cmp failed at line %d", __LINE__);
297   if (!(gcry_mpi_cmp (one, zero) < 0))
298     fail ("mpi_cmp failed at line %d", __LINE__);
299   if (!(gcry_mpi_cmp (one, two) < 0))
300     fail ("mpi_cmp failed at line %d", __LINE__);
301   gcry_mpi_neg (one, one);
302
303   if (!(gcry_mpi_cmp (one, two) < 0))
304     fail ("mpi_cmp failed at line %d", __LINE__);
305   if (!(gcry_mpi_cmp (two, one) > 0))
306     fail ("mpi_cmp failed at line %d", __LINE__);
307   if (!(gcry_mpi_cmp (one, all_ones) < 0))
308     fail ("mpi_cmp failed at line %d", __LINE__);
309
310   /* Tests with opaque values.  */
311   if (!(gcry_mpi_cmp (opa1, one) < 0))
312     fail ("mpi_cmp failed at line %d", __LINE__);
313   if (!(gcry_mpi_cmp (one, opa1) > 0))
314     fail ("mpi_cmp failed at line %d", __LINE__);
315   if (!(gcry_mpi_cmp (opa0, opa02) == 0))
316     fail ("mpi_cmp failed at line %d", __LINE__);
317   if (!(gcry_mpi_cmp (opa1s, opa1) < 0))
318     fail ("mpi_cmp failed at line %d", __LINE__);
319   if (!(gcry_mpi_cmp (opa2, opa1s) > 0))
320     fail ("mpi_cmp failed at line %d", __LINE__);
321   if (!(gcry_mpi_cmp (opa1, opa2) < 0))
322     fail ("mpi_cmp failed at line %d", __LINE__);
323   if (!(gcry_mpi_cmp (opa2, opa1) > 0))
324     fail ("mpi_cmp failed at line %d", __LINE__);
325   if (!(gcry_mpi_cmp (opa1, opa1) == 0))
326     fail ("mpi_cmp failed at line %d", __LINE__);
327
328
329   gcry_mpi_release(opa2s);
330   gcry_mpi_release(opa2);
331   gcry_mpi_release(opa1s);
332   gcry_mpi_release(opa1);
333   gcry_mpi_release(opa02);
334   gcry_mpi_release(opa0);
335   gcry_mpi_release(all_ones);
336   gcry_mpi_release(two);
337   gcry_mpi_release(one);
338   gcry_mpi_release(zero2);
339   gcry_mpi_release(zero);
340 }
341
342
343 static int
344 test_add (void)
345 {
346   gcry_mpi_t one;
347   gcry_mpi_t two;
348   gcry_mpi_t ff;
349   gcry_mpi_t result;
350   unsigned char* pc;
351
352   gcry_mpi_scan(&one, GCRYMPI_FMT_USG, ones, sizeof(ones), NULL);
353   gcry_mpi_scan(&two, GCRYMPI_FMT_USG, twos, sizeof(twos), NULL);
354   gcry_mpi_scan(&ff, GCRYMPI_FMT_USG, manyff, sizeof(manyff), NULL);
355   result = gcry_mpi_new(0);
356
357   gcry_mpi_add(result, one, two);
358   gcry_mpi_aprint(GCRYMPI_FMT_HEX, &pc, NULL, result);
359   if (debug)
360     gcry_log_debug ("Result of one plus two:\n%s\n", pc);
361   gcry_free(pc);
362
363   gcry_mpi_add(result, ff, one);
364   gcry_mpi_aprint(GCRYMPI_FMT_HEX, &pc, NULL, result);
365   if (debug)
366     gcry_log_debug ("Result of ff plus one:\n%s\n", pc);
367   gcry_free(pc);
368
369   gcry_mpi_release(one);
370   gcry_mpi_release(two);
371   gcry_mpi_release(ff);
372   gcry_mpi_release(result);
373   return 1;
374 }
375
376
377 static int
378 test_sub (void)
379 {
380   gcry_mpi_t one;
381   gcry_mpi_t two;
382   gcry_mpi_t result;
383   unsigned char* pc;
384
385   gcry_mpi_scan(&one, GCRYMPI_FMT_USG, ones, sizeof(ones), NULL);
386   gcry_mpi_scan(&two, GCRYMPI_FMT_USG, twos, sizeof(twos), NULL);
387   result = gcry_mpi_new(0);
388   gcry_mpi_sub(result, two, one);
389
390   gcry_mpi_aprint(GCRYMPI_FMT_HEX, &pc, NULL, result);
391   if (debug)
392     gcry_log_debug ("Result of two minus one:\n%s\n", pc);
393   gcry_free(pc);
394
395   gcry_mpi_release(one);
396   gcry_mpi_release(two);
397   gcry_mpi_release(result);
398   return 1;
399 }
400
401
402 static int
403 test_mul (void)
404 {
405   gcry_mpi_t two;
406   gcry_mpi_t three;
407   gcry_mpi_t result;
408   unsigned char* pc;
409
410   gcry_mpi_scan(&two, GCRYMPI_FMT_USG, twos, sizeof(twos), NULL);
411   gcry_mpi_scan(&three, GCRYMPI_FMT_USG, threes, sizeof(threes), NULL);
412   result = gcry_mpi_new(0);
413   gcry_mpi_mul(result, two, three);
414
415   gcry_mpi_aprint(GCRYMPI_FMT_HEX, &pc, NULL, result);
416   if (debug)
417     gcry_log_debug ("Result of two mul three:\n%s\n", pc);
418   gcry_free(pc);
419
420   gcry_mpi_release(two);
421   gcry_mpi_release(three);
422   gcry_mpi_release(result);
423   return 1;
424 }
425
426
427 /* What we test here is that we don't overwrite our args and that
428    using thne same mpi for several args works.  */
429 static int
430 test_powm (void)
431 {
432   int b_int = 17;
433   int e_int = 3;
434   int m_int = 19;
435   gcry_mpi_t base = gcry_mpi_set_ui (NULL, b_int);
436   gcry_mpi_t exp = gcry_mpi_set_ui (NULL, e_int);
437   gcry_mpi_t mod = gcry_mpi_set_ui (NULL, m_int);
438   gcry_mpi_t res = gcry_mpi_new (0);
439
440   gcry_mpi_powm (res, base, exp, mod);
441   if (gcry_mpi_cmp_ui (base, b_int))
442     die ("test_powm failed for base at %d\n", __LINE__);
443   if (gcry_mpi_cmp_ui (exp, e_int))
444     die ("test_powm_ui failed for exp at %d\n", __LINE__);
445   if (gcry_mpi_cmp_ui (mod, m_int))
446     die ("test_powm failed for mod at %d\n", __LINE__);
447
448   /* Check using base for the result.  */
449   gcry_mpi_set_ui (base, b_int);
450   gcry_mpi_set_ui (exp, e_int);
451   gcry_mpi_set_ui(mod, m_int);
452   gcry_mpi_powm (base, base, exp, mod);
453   if (gcry_mpi_cmp (res, base))
454     die ("test_powm failed at %d\n", __LINE__);
455   if (gcry_mpi_cmp_ui (exp, e_int))
456     die ("test_powm_ui failed for exp at %d\n", __LINE__);
457   if (gcry_mpi_cmp_ui (mod, m_int))
458     die ("test_powm failed for mod at %d\n", __LINE__);
459
460   /* Check using exp for the result.  */
461   gcry_mpi_set_ui (base, b_int);
462   gcry_mpi_set_ui (exp, e_int);
463   gcry_mpi_set_ui(mod, m_int);
464   gcry_mpi_powm (exp, base, exp, mod);
465   if (gcry_mpi_cmp (res, exp))
466     die ("test_powm failed at %d\n", __LINE__);
467   if (gcry_mpi_cmp_ui (base, b_int))
468     die ("test_powm failed for base at %d\n", __LINE__);
469   if (gcry_mpi_cmp_ui (mod, m_int))
470     die ("test_powm failed for mod at %d\n", __LINE__);
471
472   /* Check using mod for the result.  */
473   gcry_mpi_set_ui (base, b_int);
474   gcry_mpi_set_ui (exp, e_int);
475   gcry_mpi_set_ui(mod, m_int);
476   gcry_mpi_powm (mod, base, exp, mod);
477   if (gcry_mpi_cmp (res, mod))
478     die ("test_powm failed at %d\n", __LINE__);
479   if (gcry_mpi_cmp_ui (base, b_int))
480     die ("test_powm failed for base at %d\n", __LINE__);
481   if (gcry_mpi_cmp_ui (exp, e_int))
482     die ("test_powm_ui failed for exp at %d\n", __LINE__);
483
484   /* Now check base ^ base mod mod.  */
485   gcry_mpi_set_ui (base, b_int);
486   gcry_mpi_set_ui(mod, m_int);
487   gcry_mpi_powm (res, base, base, mod);
488   if (gcry_mpi_cmp_ui (base, b_int))
489     die ("test_powm failed for base at %d\n", __LINE__);
490   if (gcry_mpi_cmp_ui (mod, m_int))
491     die ("test_powm failed for mod at %d\n", __LINE__);
492
493   /* Check base ^ base mod mod with base as result.  */
494   gcry_mpi_set_ui (base, b_int);
495   gcry_mpi_set_ui(mod, m_int);
496   gcry_mpi_powm (base, base, base, mod);
497   if (gcry_mpi_cmp (res, base))
498     die ("test_powm failed at %d\n", __LINE__);
499   if (gcry_mpi_cmp_ui (mod, m_int))
500     die ("test_powm failed for mod at %d\n", __LINE__);
501
502   /* Check base ^ base mod mod with mod as result.  */
503   gcry_mpi_set_ui (base, b_int);
504   gcry_mpi_set_ui(mod, m_int);
505   gcry_mpi_powm (mod, base, base, mod);
506   if (gcry_mpi_cmp (res, mod))
507     die ("test_powm failed at %d\n", __LINE__);
508   if (gcry_mpi_cmp_ui (base, b_int))
509     die ("test_powm failed for base at %d\n", __LINE__);
510
511   /* Now check base ^ base mod base.  */
512   gcry_mpi_set_ui (base, b_int);
513   gcry_mpi_powm (res, base, base, base);
514   if (gcry_mpi_cmp_ui (base, b_int))
515     die ("test_powm failed for base at %d\n", __LINE__);
516
517   /* Check base ^ base mod base with base as result.  */
518   gcry_mpi_set_ui (base, b_int);
519   gcry_mpi_powm (base, base, base, base);
520   if (gcry_mpi_cmp (res, base))
521     die ("test_powm failed at %d\n", __LINE__);
522
523   gcry_mpi_release (base);
524   gcry_mpi_release (exp);
525   gcry_mpi_release (mod);
526   gcry_mpi_release (res);
527   /* Fixme: We should add the rest of the cases of course.  */
528
529
530
531   return 1;
532 }
533
534
535 int
536 main (int argc, char* argv[])
537 {
538   if (argc > 1 && !strcmp (argv[1], "--verbose"))
539     verbose = 1;
540   else if (argc > 1 && !strcmp (argv[1], "--debug"))
541     verbose = debug = 1;
542
543   if (!gcry_check_version (GCRYPT_VERSION))
544     {
545       fputs ("version mismatch\n", stderr);
546       exit (1);
547     }
548   gcry_control(GCRYCTL_DISABLE_SECMEM);
549
550   test_const_and_immutable ();
551   test_opaque ();
552   test_cmp ();
553   test_add ();
554   test_sub ();
555   test_mul ();
556   test_powm ();
557
558   return !!error_count;
559 }