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