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