c5abc4231c2c152d1ed2c740059c00ee9fbf6855
[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          "Options:\n"
208          "  --addkey         add a subkey to the key with FPR\n"
209          "  --adduid         add a user id to the key with FPR\n"
210          "  --revuid         Revoke a user id from the key with FPR\n"
211          "  --verbose        run in verbose mode\n"
212          "  --status         print status lines from the backend\n"
213          "  --progress       print progress info\n"
214          "  --openpgp        use the OpenPGP protocol (default)\n"
215          "  --cms            use the CMS protocol\n"
216          "  --loopback       use a loopback pinentry\n"
217          "  --unprotected    do not use a passphrase\n"
218          "  --force          do not check for a duplicated user id\n"
219          , stderr);
220   exit (ex);
221 }
222
223
224 int
225 main (int argc, char **argv)
226 {
227   int last_argc = -1;
228   gpgme_error_t err;
229   gpgme_ctx_t ctx;
230   gpgme_protocol_t protocol = GPGME_PROTOCOL_OpenPGP;
231   int print_status = 0;
232   int print_progress = 0;
233   int use_loopback = 0;
234   int addkey = 0;
235   int adduid = 0;
236   int revuid = 0;
237   const char *userid;
238   const char *algo = NULL;
239   const char *newuserid = NULL;
240   unsigned int flags = 0;
241   unsigned long expire = 0;
242   gpgme_genkey_result_t result;
243
244   if (argc)
245     { argc--; argv++; }
246
247   while (argc && last_argc != argc )
248     {
249       last_argc = argc;
250       if (!strcmp (*argv, "--"))
251         {
252           argc--; argv++;
253           break;
254         }
255       else if (!strcmp (*argv, "--help"))
256         show_usage (0);
257       else if (!strcmp (*argv, "--addkey"))
258         {
259           addkey = 1;
260           adduid = 0;
261           revuid = 0;
262           argc--; argv++;
263         }
264       else if (!strcmp (*argv, "--adduid"))
265         {
266           addkey = 0;
267           adduid = 1;
268           revuid = 0;
269           argc--; argv++;
270         }
271       else if (!strcmp (*argv, "--revuid"))
272         {
273           addkey = 0;
274           adduid = 0;
275           revuid = 1;
276           argc--; argv++;
277         }
278       else if (!strcmp (*argv, "--verbose"))
279         {
280           verbose = 1;
281           argc--; argv++;
282         }
283       else if (!strcmp (*argv, "--status"))
284         {
285           print_status = 1;
286           argc--; argv++;
287         }
288       else if (!strcmp (*argv, "--progress"))
289         {
290           print_progress = 1;
291           argc--; argv++;
292         }
293       else if (!strcmp (*argv, "--openpgp"))
294         {
295           protocol = GPGME_PROTOCOL_OpenPGP;
296           argc--; argv++;
297         }
298       else if (!strcmp (*argv, "--cms"))
299         {
300           protocol = GPGME_PROTOCOL_CMS;
301           argc--; argv++;
302         }
303       else if (!strcmp (*argv, "--loopback"))
304         {
305           use_loopback = 1;
306           argc--; argv++;
307         }
308       else if (!strcmp (*argv, "--unprotected"))
309         {
310           flags |= GPGME_CREATE_NOPASSWD;
311           argc--; argv++;
312         }
313       else if (!strcmp (*argv, "--force"))
314         {
315           flags |= GPGME_CREATE_FORCE;
316           argc--; argv++;
317         }
318       else if (!strncmp (*argv, "--", 2))
319         show_usage (1);
320     }
321
322   if (adduid || revuid)
323     {
324       if (argc != 2)
325         show_usage (1);
326       userid = argv[0];
327       newuserid = argv[1];
328     }
329   else
330     {
331       if (!argc || argc > 4)
332         show_usage (1);
333       userid = argv[0];
334       if (argc > 1)
335         algo = argv[1];
336       if (argc > 2)
337         flags |= parse_usage_string (argv[2]);
338       if (argc > 3)
339         expire = parse_expire_string (argv[3]);
340     }
341
342   init_gpgme (protocol);
343
344   err = gpgme_new (&ctx);
345   fail_if_err (err);
346   gpgme_set_protocol (ctx, protocol);
347   gpgme_set_armor (ctx, 1);
348   if (print_status)
349     {
350       gpgme_set_status_cb (ctx, status_cb, NULL);
351       gpgme_set_ctx_flag (ctx, "full-status", "1");
352     }
353   if (print_progress)
354     gpgme_set_progress_cb (ctx, progress_cb, NULL);
355   if (use_loopback)
356     {
357       gpgme_set_pinentry_mode (ctx, GPGME_PINENTRY_MODE_LOOPBACK);
358       gpgme_set_passphrase_cb (ctx, passphrase_cb, NULL);
359     }
360
361   if (addkey || adduid || revuid)
362     {
363       gpgme_key_t akey;
364
365       err = gpgme_get_key (ctx, userid, &akey, 1);
366       if (err)
367         {
368           fprintf (stderr, PGM ": error getting secret key for '%s': %s\n",
369                    userid, gpg_strerror (err));
370           exit (1);
371         }
372
373       if (addkey)
374         {
375           err = gpgme_op_createsubkey (ctx, akey, algo, 0, expire, flags);
376           if (err)
377             {
378               fprintf (stderr, PGM ": gpgme_op_createsubkey failed: %s\n",
379                        gpg_strerror (err));
380               exit (1);
381             }
382         }
383       else if (adduid)
384         {
385           err = gpgme_op_adduid (ctx, akey, newuserid, flags);
386           if (err)
387             {
388               fprintf (stderr, PGM ": gpgme_op_adduid failed: %s\n",
389                        gpg_strerror (err));
390               exit (1);
391             }
392         }
393       else if (revuid)
394         {
395           err = gpgme_op_revuid (ctx, akey, newuserid, flags);
396           if (err)
397             {
398               fprintf (stderr, PGM ": gpgme_op_revuid failed: %s\n",
399                        gpg_strerror (err));
400               exit (1);
401             }
402         }
403       gpgme_key_unref (akey);
404     }
405   else
406     {
407       err = gpgme_op_createkey (ctx, userid, algo, 0, expire, NULL, flags);
408       if (err)
409         {
410           fprintf (stderr, PGM ": gpgme_op_createkey failed: %s\n",
411                    gpg_strerror (err));
412           exit (1);
413         }
414     }
415
416   result = gpgme_op_genkey_result (ctx);
417   if (!result)
418     {
419       fprintf (stderr, PGM": gpgme_op_genkey_result returned NULL\n");
420       exit (1);
421     }
422
423   printf ("Generated key: %s (%s)\n",
424           result->fpr ? result->fpr : "none",
425           result->primary ? (result->sub ? "primary, sub" : "primary")
426           /**/            : (result->sub ? "sub" : "none"));
427
428   if (result->fpr && strlen (result->fpr) < 40)
429     fprintf (stderr, PGM": generated key has unexpected fingerprint\n");
430   if (!result->primary)
431     fprintf (stderr, PGM": primary key was not generated\n");
432   if (!result->sub)
433     fprintf (stderr, PGM": sub key was not generated\n");
434   if (!result->uid)
435     fprintf (stderr, PGM": uid was not generated\n");
436
437   gpgme_release (ctx);
438   return 0;
439 }