ecc: Add Ed25519 key generation and prepare for optimizations.
[libgcrypt.git] / tests / keygen.c
1 /* keygen.c  -  key generation regression tests
2  * Copyright (C) 2003, 2005, 2012 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 #include "../src/gcrypt-int.h"
29
30
31
32 static int verbose;
33 static int debug;
34 static int error_count;
35
36 static void
37 show ( const char *format, ... )
38 {
39     va_list arg_ptr ;
40
41     va_start( arg_ptr, format ) ;
42     vfprintf (stderr, format, arg_ptr );
43     va_end(arg_ptr);
44 }
45
46 static void
47 fail ( const char *format, ... )
48 {
49     va_list arg_ptr ;
50
51     va_start( arg_ptr, format ) ;
52     vfprintf (stderr, format, arg_ptr );
53     va_end(arg_ptr);
54     error_count++;
55 }
56
57 static void
58 die ( const char *format, ... )
59 {
60     va_list arg_ptr ;
61
62     va_start( arg_ptr, format ) ;
63     vfprintf (stderr, format, arg_ptr );
64     va_end(arg_ptr);
65     exit (1);
66 }
67
68
69 static void
70 print_mpi (const char *text, gcry_mpi_t a)
71 {
72   char *buf;
73   void *bufaddr = &buf;
74   gcry_error_t rc;
75
76   rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
77   if (rc)
78     fprintf (stderr, "%s=[error printing number: %s]\n",
79              text, gpg_strerror (rc));
80   else
81     {
82       fprintf (stderr, "%s=0x%s\n", text, buf);
83       gcry_free (buf);
84     }
85 }
86
87
88 static void
89 check_generated_rsa_key (gcry_sexp_t key, unsigned long expected_e)
90 {
91   gcry_sexp_t skey, pkey, list;
92
93   pkey = gcry_sexp_find_token (key, "public-key", 0);
94   if (!pkey)
95     fail ("public part missing in return value\n");
96   else
97     {
98       gcry_mpi_t e = NULL;
99
100       list = gcry_sexp_find_token (pkey, "e", 0);
101       if (!list || !(e=gcry_sexp_nth_mpi (list, 1, 0)) )
102         fail ("public exponent not found\n");
103       else if (!expected_e)
104         {
105           if (verbose)
106             print_mpi ("e", e);
107         }
108       else if ( gcry_mpi_cmp_ui (e, expected_e))
109         {
110           print_mpi ("e", e);
111           fail ("public exponent is not %lu\n", expected_e);
112         }
113       gcry_sexp_release (list);
114       gcry_mpi_release (e);
115       gcry_sexp_release (pkey);
116     }
117
118   skey = gcry_sexp_find_token (key, "private-key", 0);
119   if (!skey)
120     fail ("private part missing in return value\n");
121   else
122     {
123       int rc = gcry_pk_testkey (skey);
124       if (rc)
125         fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
126       gcry_sexp_release (skey);
127     }
128
129  }
130
131 static void
132 check_rsa_keys (void)
133 {
134   gcry_sexp_t keyparm, key;
135   int rc;
136   int i;
137
138   /* Check that DSA generation works and that it can grok the qbits
139      argument. */
140   if (verbose)
141     fprintf (stderr, "creating 5 1024 bit DSA keys\n");
142   for (i=0; i < 5; i++)
143     {
144       rc = gcry_sexp_new (&keyparm,
145                           "(genkey\n"
146                           " (dsa\n"
147                           "  (nbits 4:1024)\n"
148                           " ))", 0, 1);
149       if (rc)
150         die ("error creating S-expression: %s\n", gpg_strerror (rc));
151       rc = gcry_pk_genkey (&key, keyparm);
152       gcry_sexp_release (keyparm);
153       if (rc)
154         die ("error generating DSA key: %s\n", gpg_strerror (rc));
155       gcry_sexp_release (key);
156       if (verbose)
157         fprintf (stderr, "  done\n");
158     }
159
160   if (verbose)
161     fprintf (stderr, "creating 1536 bit DSA key\n");
162   rc = gcry_sexp_new (&keyparm,
163                       "(genkey\n"
164                       " (dsa\n"
165                       "  (nbits 4:1536)\n"
166                       "  (qbits 3:224)\n"
167                       " ))", 0, 1);
168   if (rc)
169     die ("error creating S-expression: %s\n", gpg_strerror (rc));
170   rc = gcry_pk_genkey (&key, keyparm);
171   gcry_sexp_release (keyparm);
172   if (rc)
173     die ("error generating DSA key: %s\n", gpg_strerror (rc));
174   if (debug)
175     {
176       char buffer[20000];
177       gcry_sexp_sprint (key, GCRYSEXP_FMT_ADVANCED, buffer, sizeof buffer);
178       if (verbose)
179         printf ("=============================\n%s\n"
180                 "=============================\n", buffer);
181     }
182   gcry_sexp_release (key);
183
184   if (verbose)
185     fprintf (stderr, "creating 1024 bit RSA key\n");
186   rc = gcry_sexp_new (&keyparm,
187                       "(genkey\n"
188                       " (rsa\n"
189                       "  (nbits 4:1024)\n"
190                       " ))", 0, 1);
191   if (rc)
192     die ("error creating S-expression: %s\n", gpg_strerror (rc));
193   rc = gcry_pk_genkey (&key, keyparm);
194   gcry_sexp_release (keyparm);
195   if (rc)
196     die ("error generating RSA key: %s\n", gpg_strerror (rc));
197
198   check_generated_rsa_key (key, 65537);
199   gcry_sexp_release (key);
200
201
202   if (verbose)
203     fprintf (stderr, "creating 512 bit RSA key with e=257\n");
204   rc = gcry_sexp_new (&keyparm,
205                       "(genkey\n"
206                       " (rsa\n"
207                       "  (nbits 3:512)\n"
208                       "  (rsa-use-e 3:257)\n"
209                       " ))", 0, 1);
210   if (rc)
211     die ("error creating S-expression: %s\n", gpg_strerror (rc));
212   rc = gcry_pk_genkey (&key, keyparm);
213   gcry_sexp_release (keyparm);
214   if (rc)
215     die ("error generating RSA key: %s\n", gpg_strerror (rc));
216
217   check_generated_rsa_key (key, 257);
218   gcry_sexp_release (key);
219
220   if (verbose)
221     fprintf (stderr, "creating 512 bit RSA key with default e\n");
222   rc = gcry_sexp_new (&keyparm,
223                       "(genkey\n"
224                       " (rsa\n"
225                       "  (nbits 3:512)\n"
226                       "  (rsa-use-e 1:0)\n"
227                       " ))", 0, 1);
228   if (rc)
229     die ("error creating S-expression: %s\n", gpg_strerror (rc));
230   rc = gcry_pk_genkey (&key, keyparm);
231   gcry_sexp_release (keyparm);
232   if (rc)
233     die ("error generating RSA key: %s\n", gpg_strerror (rc));
234
235   check_generated_rsa_key (key, 0); /* We don't expect a constant exponent. */
236   gcry_sexp_release (key);
237
238 }
239
240
241 static void
242 check_generated_ecc_key (gcry_sexp_t key)
243 {
244   gcry_sexp_t skey, pkey;
245
246   pkey = gcry_sexp_find_token (key, "public-key", 0);
247   if (!pkey)
248     fail ("public part missing in return value\n");
249   else
250     {
251       /* Fixme: Check more stuff.  */
252       gcry_sexp_release (pkey);
253     }
254
255   skey = gcry_sexp_find_token (key, "private-key", 0);
256   if (!skey)
257     fail ("private part missing in return value\n");
258   else
259     {
260       int rc = gcry_pk_testkey (skey);
261       if (rc)
262         fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
263       gcry_sexp_release (skey);
264     }
265
266   /* Finally check that gcry_pk_testkey also works on the entire
267      S-expression.  */
268   {
269     int rc = gcry_pk_testkey (key);
270     if (rc)
271       fail ("gcry_pk_testkey failed on key pair: %s\n", gpg_strerror (rc));
272   }
273 }
274
275
276 static void
277 check_ecc_keys (void)
278 {
279   const char *curves[] = { "NIST P-521", "NIST P-384", "NIST P-256",
280                            "Ed25519", NULL };
281   int testno;
282   gcry_sexp_t keyparm, key;
283   int rc;
284
285   for (testno=0; curves[testno]; testno++)
286     {
287       if (verbose)
288         fprintf (stderr, "creating ECC key using curve %s\n", curves[testno]);
289       rc = gcry_sexp_build (&keyparm, NULL,
290                             "(genkey(ecc(curve %s)))", curves[testno]);
291       if (rc)
292         die ("error creating S-expression: %s\n", gpg_strerror (rc));
293       rc = gcry_pk_genkey (&key, keyparm);
294       gcry_sexp_release (keyparm);
295       if (rc)
296         die ("error generating ECC key using curve %s: %s\n",
297              curves[testno], gpg_strerror (rc));
298
299       if (!strcmp (curves[testno], "Ed25519"))
300         show ("Note: gcry_pk_testkey does not yet work for Ed25519\n");
301       else
302         check_generated_ecc_key (key);
303
304       gcry_sexp_release (key);
305     }
306 }
307
308
309 static void
310 check_nonce (void)
311 {
312   char a[32], b[32];
313   int i,j;
314   int oops=0;
315
316   if (verbose)
317     fprintf (stderr, "checking gcry_create_nonce\n");
318
319   gcry_create_nonce (a, sizeof a);
320   for (i=0; i < 10; i++)
321     {
322       gcry_create_nonce (b, sizeof b);
323       if (!memcmp (a, b, sizeof a))
324         die ("identical nonce found\n");
325     }
326   for (i=0; i < 10; i++)
327     {
328       gcry_create_nonce (a, sizeof a);
329       if (!memcmp (a, b, sizeof a))
330         die ("identical nonce found\n");
331     }
332
333  again:
334   for (i=1,j=0; i < sizeof a; i++)
335     if (a[0] == a[i])
336       j++;
337   if (j+1 == sizeof (a))
338     {
339       if (oops)
340         die ("impossible nonce found\n");
341       oops++;
342       gcry_create_nonce (a, sizeof a);
343       goto again;
344     }
345 }
346
347
348 static void
349 progress_cb (void *cb_data, const char *what, int printchar,
350                   int current, int total)
351 {
352   (void)cb_data;
353   (void)what;
354   (void)current;
355   (void)total;
356
357   if (printchar == '\n')
358     fputs ( "<LF>", stdout);
359   else
360     putchar (printchar);
361   fflush (stdout);
362 }
363
364
365 int
366 main (int argc, char **argv)
367 {
368   if (argc > 1 && !strcmp (argv[1], "--verbose"))
369     verbose = 1;
370   else if (argc > 1 && !strcmp (argv[1], "--debug"))
371     verbose = debug = 1;
372
373   if (!gcry_check_version (GCRYPT_VERSION))
374     die ("version mismatch\n");
375   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
376   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
377   if (debug)
378     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
379   /* No valuable keys are create, so we can speed up our RNG. */
380   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
381   if (verbose)
382     gcry_set_progress_handler ( progress_cb, NULL );
383
384   check_rsa_keys ();
385   check_ecc_keys ();
386   check_nonce ();
387
388   return error_count? 1:0;
389 }