Various minor changes.
[libgcrypt.git] / tests / keygen.c
1 /* keygen.c  -  key generation regression tests
2  *      Copyright (C) 2003, 2005 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.h"
29
30
31
32 static int verbose;
33 static int error_count;
34
35 static void
36 fail ( const char *format, ... )
37 {
38     va_list arg_ptr ;
39
40     va_start( arg_ptr, format ) ;
41     vfprintf (stderr, format, arg_ptr );
42     va_end(arg_ptr);
43     error_count++;
44 }
45
46 static void
47 die ( 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     exit (1);
55 }
56
57
58 static void
59 print_mpi (const char *text, gcry_mpi_t a)
60 {
61   char *buf;
62   void *bufaddr = &buf;
63   gcry_error_t rc;
64
65   rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
66   if (rc)
67     fprintf (stderr, "%s=[error printing number: %s]\n",
68              text, gpg_strerror (rc));
69   else
70     {
71       fprintf (stderr, "%s=0x%s\n", text, buf);
72       gcry_free (buf);
73     }
74 }
75
76
77 static void
78 check_generated_rsa_key (gcry_sexp_t key, unsigned long expected_e)
79 {
80   gcry_sexp_t skey, pkey, list;
81
82   pkey = gcry_sexp_find_token (key, "public-key", 0);
83   if (!pkey)
84     fail ("public part missing in return value\n");
85   else
86     {
87       gcry_mpi_t e = NULL;
88
89       list = gcry_sexp_find_token (pkey, "e", 0);
90       if (!list || !(e=gcry_sexp_nth_mpi (list, 1, 0)) )
91         fail ("public exponent not found\n");
92       else if (!expected_e)
93         {
94           if (verbose)
95             print_mpi ("e", e);
96         }
97       else if ( gcry_mpi_cmp_ui (e, expected_e)) 
98         {
99           print_mpi ("e", e);
100           fail ("public exponent is not %lu\n", expected_e);
101         }
102       gcry_sexp_release (list);
103       gcry_mpi_release (e);
104       gcry_sexp_release (pkey);
105     }
106  
107   skey = gcry_sexp_find_token (key, "private-key", 0);
108   if (!skey)
109     fail ("private part missing in return value\n");
110   else
111     {
112       int rc = gcry_pk_testkey (skey);
113       if (rc)
114         fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
115       gcry_sexp_release (skey);
116     }
117
118  }
119
120 static void
121 check_rsa_keys (void)
122 {
123   gcry_sexp_t keyparm, key;
124   int rc;
125
126   /* Check that DSA generation works and that it can grok the qbits
127      argument. */
128   if (verbose)
129     fprintf (stderr, "creating 1536 bit DSA key using old interface\n");
130   rc = gcry_sexp_new (&keyparm, 
131                       "(genkey\n"
132                       " (dsa\n"
133                       "  (nbits 4:1536)\n"
134                       "  (qbits 3:224)\n"
135                       " ))", 0, 1);
136   if (rc)
137     die ("error creating S-expression: %s\n", gpg_strerror (rc));
138   rc = gcry_pk_genkey (&key, keyparm);
139   gcry_sexp_release (keyparm);
140   if (rc)
141     die ("error generating DSA key: %s\n", gpg_strerror (rc));
142   {
143     char buffer[20000];
144     gcry_sexp_sprint (key, GCRYSEXP_FMT_ADVANCED, buffer, sizeof buffer);
145     if (verbose)
146       printf ("=============================\n%s\n"
147               "=============================\n", buffer);
148   }
149   gcry_sexp_release (key);
150
151   if (verbose)
152     fprintf (stderr, "creating 1024 bit RSA key using old interface\n");
153   rc = gcry_sexp_new (&keyparm, 
154                       "(genkey\n"
155                       " (rsa\n"
156                       "  (nbits 4:1024)\n"
157                       " ))", 0, 1);
158   if (rc)
159     die ("error creating S-expression: %s\n", gpg_strerror (rc));
160   rc = gcry_pk_genkey (&key, keyparm);
161   gcry_sexp_release (keyparm);
162   if (rc)
163     die ("error generating RSA key: %s\n", gpg_strerror (rc));
164
165   check_generated_rsa_key (key, 65537);
166   gcry_sexp_release (key);
167
168
169   if (verbose)
170     fprintf (stderr, "creating 512 bit RSA key with e=257\n");
171   rc = gcry_sexp_new (&keyparm, 
172                       "(genkey\n"
173                       " (rsa\n"
174                       "  (nbits 3:512)\n"
175                       "  (rsa-use-e 3:257)\n"
176                       " ))", 0, 1);
177   if (rc)
178     die ("error creating S-expression: %s\n", gpg_strerror (rc));
179   rc = gcry_pk_genkey (&key, keyparm);
180   gcry_sexp_release (keyparm);
181   if (rc)
182     die ("error generating RSA key: %s\n", gpg_strerror (rc));
183
184   check_generated_rsa_key (key, 257);
185   gcry_sexp_release (key);
186
187   if (verbose)
188     fprintf (stderr, "creating 512 bit RSA key with default e\n");
189   rc = gcry_sexp_new (&keyparm, 
190                       "(genkey\n"
191                       " (rsa\n"
192                       "  (nbits 3:512)\n"
193                       "  (rsa-use-e 1:0)\n"
194                       " ))", 0, 1);
195   if (rc)
196     die ("error creating S-expression: %s\n", gpg_strerror (rc));
197   rc = gcry_pk_genkey (&key, keyparm);
198   gcry_sexp_release (keyparm);
199   if (rc)
200     die ("error generating RSA key: %s\n", gpg_strerror (rc));
201
202   check_generated_rsa_key (key, 0); /* We don't expect a constant exponent. */
203   gcry_sexp_release (key);
204
205 }
206
207
208 static void
209 check_nonce (void)
210 {
211   char a[32], b[32];
212   int i,j;
213   int oops=0;
214
215   if (verbose)
216     fprintf (stderr, "checking gcry_create_nonce\n");
217
218   gcry_create_nonce (a, sizeof a);
219   for (i=0; i < 10; i++)
220     {
221       gcry_create_nonce (b, sizeof b);
222       if (!memcmp (a, b, sizeof a))
223         die ("identical nounce found\n");
224     }
225   for (i=0; i < 10; i++)
226     {
227       gcry_create_nonce (a, sizeof a);
228       if (!memcmp (a, b, sizeof a))
229         die ("identical nounce found\n");
230     }
231
232  again:
233   for (i=1,j=0; i < sizeof a; i++)
234     if (a[0] == a[i])
235       j++;
236   if (j+1 == sizeof (a))
237     {
238       if (oops)
239         die ("impossible nonce found\n");
240       oops++;
241       gcry_create_nonce (a, sizeof a);
242       goto again;
243     }
244 }
245
246 int
247 main (int argc, char **argv)
248 {
249   int debug = 0;
250
251   if (argc > 1 && !strcmp (argv[1], "--verbose"))
252     verbose = 1;
253   else if (argc > 1 && !strcmp (argv[1], "--debug"))
254     verbose = debug = 1;
255
256   if (!gcry_check_version (GCRYPT_VERSION))
257     die ("version mismatch\n");
258   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
259   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
260   if (debug)
261     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
262   /* No valuable keys are create, so we can speed up our RNG. */
263   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
264
265   check_rsa_keys ();
266   check_nonce ();
267   
268   return error_count? 1:0;
269 }
270