core: Fix duplication of close_notify_handler for gpgsm.
[gpgme.git] / tests / run-genkey.c
1 /* run-genkey.c  - Test tool to perform key generation
2  * Copyright (C) 2016 g10 Code GmbH
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify it
7  * 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  * GPGME is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * 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, see <https://gnu.org/licenses/>.
18  * SPDX-License-Identifier: LGPL-2.1-or-later
19  */
20
21 /* We need to include config.h so that we know whether we are building
22    with large file system (LFS) support. */
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <assert.h>
31
32 #include <gpgme.h>
33
34 #define PGM "run-genkey"
35
36 #include "run-support.h"
37
38
39 static int verbose;
40
41
42 /* Tokenize STRING using the set of delimiters in DELIM.  Leading
43  * spaces and tabs are removed from all tokens.  The caller must free
44  * the result.
45  *
46  * Returns: A malloced and NULL delimited array with the tokens.  On
47  *          memory error NULL is returned and ERRNO is set.
48  */
49 static char **
50 strtokenize (const char *string, const char *delim)
51 {
52   const char *s;
53   size_t fields;
54   size_t bytes, n;
55   char *buffer;
56   char *p, *px, *pend;
57   char **result;
58
59   /* Count the number of fields.  */
60   for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
61     fields++;
62   fields++; /* Add one for the terminating NULL.  */
63
64   /* Allocate an array for all fields, a terminating NULL, and space
65      for a copy of the string.  */
66   bytes = fields * sizeof *result;
67   if (bytes / sizeof *result != fields)
68     {
69       gpg_err_set_errno (ENOMEM);
70       return NULL;
71     }
72   n = strlen (string) + 1;
73   bytes += n;
74   if (bytes < n)
75     {
76       gpg_err_set_errno (ENOMEM);
77       return NULL;
78     }
79   result = malloc (bytes);
80   if (!result)
81     return NULL;
82   buffer = (char*)(result + fields);
83
84   /* Copy and parse the string.  */
85   strcpy (buffer, string);
86   for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
87     {
88       *pend = 0;
89       while (*p == ' ' || *p == '\t')
90         p++;
91       for (px = pend - 1; px >= p && (*px == ' ' || *px == '\t'); px--)
92         *px = 0;
93       result[n++] = p;
94     }
95   while (*p == ' ' || *p == '\t')
96     p++;
97   for (px = p + strlen (p) - 1; px >= p && (*px == ' ' || *px == '\t'); px--)
98     *px = 0;
99   result[n++] = p;
100   result[n] = NULL;
101
102   assert ((char*)(result + n + 1) == buffer);
103
104   return result;
105 }
106
107
108 static gpg_error_t
109 status_cb (void *opaque, const char *keyword, const char *value)
110 {
111   (void)opaque;
112   fprintf (stderr, "status_cb: %s %s\n", nonnull(keyword), nonnull(value));
113   return 0;
114 }
115
116
117 static void
118 progress_cb (void *opaque, const char *what, int type, int current, int total)
119 {
120   (void)opaque;
121   (void)type;
122
123   if (total)
124     fprintf (stderr, "progress for '%s' %u%% (%d of %d)\n",
125              nonnull (what),
126              (unsigned)(((double)current / total) * 100), current, total);
127   else
128     fprintf (stderr, "progress for '%s' %d\n", nonnull(what), current);
129   fflush (stderr);
130 }
131
132
133 static unsigned long
134 parse_expire_string (const char *string)
135 {
136   unsigned long seconds;
137
138   if (!string || !*string || !strcmp (string, "none")
139       || !strcmp (string, "never") || !strcmp (string, "-"))
140     seconds = 0;
141   else if (strspn (string, "01234567890") == strlen (string))
142     seconds = strtoul (string, NULL, 10);
143   else
144     {
145       fprintf (stderr, PGM ": invalid value '%s'\n", string);
146       exit (1);
147     }
148
149   return seconds;
150 }
151
152
153 /* Parse a usage string and return flags for gpgme_op_createkey.  */
154 static unsigned int
155 parse_usage_string (const char *string)
156 {
157   gpg_error_t err;
158   char **tokens = NULL;
159   const char *s;
160   int i;
161   unsigned int flags = 0;
162
163   tokens = strtokenize (string, " \t,");
164   if (!tokens)
165     {
166       err = gpg_error_from_syserror ();
167       fprintf (stderr, PGM": strtokenize failed: %s\n", gpg_strerror (err));
168       exit (1);
169     }
170
171   for (i=0; (s = tokens[i]); i++)
172     {
173       if (!*s)
174         ;
175       else if (!strcmp (s, "default"))
176         ;
177       else if (!strcmp (s, "sign"))
178         flags |= GPGME_CREATE_SIGN;
179       else if (!strcmp (s, "encr"))
180         flags |= GPGME_CREATE_ENCR;
181       else if (!strcmp (s, "cert"))
182         flags |= GPGME_CREATE_CERT;
183       else if (!strcmp (s, "auth"))
184         flags |= GPGME_CREATE_AUTH;
185       else
186         {
187           free (tokens);
188           fprintf (stderr, PGM": invalid value '%s': %s\n",
189                    string, "bad usage");
190           exit (1);
191         }
192     }
193
194   free (tokens);
195   return flags;
196 }
197
198
199
200 static int
201 show_usage (int ex)
202 {
203   fputs ("usage: " PGM " [options] ARGS\n"
204          "         args: USERID [ALGO [USAGE [EXPIRESECONDS]]]\n"
205          "   for addkey: FPR    [ALGO [USAGE [EXPIRESECONDS]]]\n"
206          "   for adduid: FPR    USERID\n"
207          "   for revuid: FPR    USERID\n"
208          "   for set-primary: FPR    USERID\n"
209          "Options:\n"
210          "  --addkey         add a subkey to the key with FPR\n"
211          "  --adduid         add a user id to the key with FPR\n"
212          "  --revuid         revoke a user id from the key with FPR\n"
213          "  --set-primary    set the primary key flag on USERID\n"
214          "  --verbose        run in verbose mode\n"
215          "  --status         print status lines from the backend\n"
216          "  --progress       print progress info\n"
217          "  --openpgp        use the OpenPGP protocol (default)\n"
218          "  --cms            use the CMS protocol\n"
219          "  --loopback       use a loopback pinentry\n"
220          "  --unprotected    do not use a passphrase\n"
221          "  --force          do not check for a duplicated user id\n"
222          , stderr);
223   exit (ex);
224 }
225
226
227 int
228 main (int argc, char **argv)
229 {
230   int last_argc = -1;
231   gpgme_error_t err;
232   gpgme_ctx_t ctx;
233   gpgme_protocol_t protocol = GPGME_PROTOCOL_OpenPGP;
234   int print_status = 0;
235   int print_progress = 0;
236   int use_loopback = 0;
237   int addkey = 0;
238   int adduid = 0;
239   int revuid = 0;
240   int setpri = 0;
241   const char *userid;
242   const char *algo = NULL;
243   const char *newuserid = NULL;
244   unsigned int flags = 0;
245   unsigned long expire = 0;
246   gpgme_genkey_result_t result;
247
248   if (argc)
249     { argc--; argv++; }
250
251   while (argc && last_argc != argc )
252     {
253       last_argc = argc;
254       if (!strcmp (*argv, "--"))
255         {
256           argc--; argv++;
257           break;
258         }
259       else if (!strcmp (*argv, "--help"))
260         show_usage (0);
261       else if (!strcmp (*argv, "--addkey"))
262         {
263           addkey = 1;
264           adduid = 0;
265           revuid = 0;
266           setpri = 0;
267           argc--; argv++;
268         }
269       else if (!strcmp (*argv, "--adduid"))
270         {
271           addkey = 0;
272           adduid = 1;
273           revuid = 0;
274           setpri = 0;
275           argc--; argv++;
276         }
277       else if (!strcmp (*argv, "--revuid"))
278         {
279           addkey = 0;
280           adduid = 0;
281           revuid = 1;
282           setpri = 0;
283           argc--; argv++;
284         }
285       else if (!strcmp (*argv, "--set-primary"))
286         {
287           addkey = 0;
288           adduid = 0;
289           revuid = 0;
290           setpri = 1;
291           argc--; argv++;
292         }
293       else if (!strcmp (*argv, "--verbose"))
294         {
295           verbose = 1;
296           argc--; argv++;
297         }
298       else if (!strcmp (*argv, "--status"))
299         {
300           print_status = 1;
301           argc--; argv++;
302         }
303       else if (!strcmp (*argv, "--progress"))
304         {
305           print_progress = 1;
306           argc--; argv++;
307         }
308       else if (!strcmp (*argv, "--openpgp"))
309         {
310           protocol = GPGME_PROTOCOL_OpenPGP;
311           argc--; argv++;
312         }
313       else if (!strcmp (*argv, "--cms"))
314         {
315           protocol = GPGME_PROTOCOL_CMS;
316           argc--; argv++;
317         }
318       else if (!strcmp (*argv, "--loopback"))
319         {
320           use_loopback = 1;
321           argc--; argv++;
322         }
323       else if (!strcmp (*argv, "--unprotected"))
324         {
325           flags |= GPGME_CREATE_NOPASSWD;
326           argc--; argv++;
327         }
328       else if (!strcmp (*argv, "--force"))
329         {
330           flags |= GPGME_CREATE_FORCE;
331           argc--; argv++;
332         }
333       else if (!strncmp (*argv, "--", 2))
334         show_usage (1);
335     }
336
337   if (adduid || revuid || setpri)
338     {
339       if (argc != 2)
340         show_usage (1);
341       userid = argv[0];
342       newuserid = argv[1];
343     }
344   else
345     {
346       if (!argc || argc > 4)
347         show_usage (1);
348       userid = argv[0];
349       if (argc > 1)
350         algo = argv[1];
351       if (argc > 2)
352         flags |= parse_usage_string (argv[2]);
353       if (argc > 3)
354         expire = parse_expire_string (argv[3]);
355     }
356
357   init_gpgme (protocol);
358
359   err = gpgme_new (&ctx);
360   fail_if_err (err);
361   gpgme_set_protocol (ctx, protocol);
362   gpgme_set_armor (ctx, 1);
363   if (print_status)
364     {
365       gpgme_set_status_cb (ctx, status_cb, NULL);
366       gpgme_set_ctx_flag (ctx, "full-status", "1");
367     }
368   if (print_progress)
369     gpgme_set_progress_cb (ctx, progress_cb, NULL);
370   if (use_loopback)
371     {
372       gpgme_set_pinentry_mode (ctx, GPGME_PINENTRY_MODE_LOOPBACK);
373       gpgme_set_passphrase_cb (ctx, passphrase_cb, NULL);
374     }
375
376   if (addkey || adduid || revuid || setpri)
377     {
378       gpgme_key_t akey;
379
380       err = gpgme_get_key (ctx, userid, &akey, 1);
381       if (err)
382         {
383           fprintf (stderr, PGM ": error getting secret key for '%s': %s\n",
384                    userid, gpg_strerror (err));
385           exit (1);
386         }
387
388       if (addkey)
389         {
390           err = gpgme_op_createsubkey (ctx, akey, algo, 0, expire, flags);
391           if (err)
392             {
393               fprintf (stderr, PGM ": gpgme_op_createsubkey failed: %s\n",
394                        gpg_strerror (err));
395               exit (1);
396             }
397         }
398       else if (adduid)
399         {
400           err = gpgme_op_adduid (ctx, akey, newuserid, flags);
401           if (err)
402             {
403               fprintf (stderr, PGM ": gpgme_op_adduid failed: %s\n",
404                        gpg_strerror (err));
405               exit (1);
406             }
407         }
408       else if (revuid)
409         {
410           err = gpgme_op_revuid (ctx, akey, newuserid, flags);
411           if (err)
412             {
413               fprintf (stderr, PGM ": gpgme_op_revuid failed: %s\n",
414                        gpg_strerror (err));
415               exit (1);
416             }
417         }
418       else if (setpri)
419         {
420           err = gpgme_op_set_uid_flag (ctx, akey, newuserid, "primary", NULL);
421           if (err)
422             {
423               fprintf (stderr, PGM ": gpgme_op_set_uid_flag failed: %s\n",
424                        gpg_strerror (err));
425               exit (1);
426             }
427         }
428       gpgme_key_unref (akey);
429     }
430   else
431     {
432       err = gpgme_op_createkey (ctx, userid, algo, 0, expire, NULL, flags);
433       if (err)
434         {
435           fprintf (stderr, PGM ": gpgme_op_createkey failed: %s\n",
436                    gpg_strerror (err));
437           exit (1);
438         }
439     }
440
441   if (!setpri)
442     {
443       result = gpgme_op_genkey_result (ctx);
444       if (!result)
445         {
446           fprintf (stderr, PGM": gpgme_op_genkey_result returned NULL\n");
447           exit (1);
448         }
449
450       printf ("Generated key: %s (%s)\n",
451               result->fpr ? result->fpr : "none",
452               result->primary ? (result->sub ? "primary, sub" : "primary")
453               /**/            : (result->sub ? "sub" : "none"));
454
455       if (result->fpr && strlen (result->fpr) < 40)
456         fprintf (stderr, PGM": generated key has unexpected fingerprint\n");
457       if (!result->primary)
458         fprintf (stderr, PGM": primary key was not generated\n");
459       if (!result->sub)
460         fprintf (stderr, PGM": sub key was not generated\n");
461       if (!result->uid)
462         fprintf (stderr, PGM": uid was not generated\n");
463     }
464
465   gpgme_release (ctx);
466   return 0;
467 }