g10: Unattended key generation "Key-Grip" and "Subkey-Grip".
[gnupg.git] / tools / wks-util.c
1 /* wks-utils.c - Common helper functions for wks tools
2  * Copyright (C) 2016 g10 Code GmbH
3  * Copyright (C) 2016 Bundesamt für Sicherheit in der Informationstechnik
4  *
5  * This file is part of GnuPG.
6  *
7  * This file is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * This file is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  */
17
18 #include <config.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include "../common/util.h"
24 #include "../common/status.h"
25 #include "../common/ccparray.h"
26 #include "../common/exectool.h"
27 #include "../common/mbox-util.h"
28 #include "mime-maker.h"
29 #include "send-mail.h"
30 #include "gpg-wks.h"
31
32 /* The stream to output the status information.  Output is disabled if
33    this is NULL.  */
34 static estream_t statusfp;
35
36
37 \f
38 /* Set the status FD.  */
39 void
40 wks_set_status_fd (int fd)
41 {
42   static int last_fd = -1;
43
44   if (fd != -1 && last_fd == fd)
45     return;
46
47   if (statusfp && statusfp != es_stdout && statusfp != es_stderr)
48     es_fclose (statusfp);
49   statusfp = NULL;
50   if (fd == -1)
51     return;
52
53   if (fd == 1)
54     statusfp = es_stdout;
55   else if (fd == 2)
56     statusfp = es_stderr;
57   else
58     statusfp = es_fdopen (fd, "w");
59   if (!statusfp)
60     {
61       log_fatal ("can't open fd %d for status output: %s\n",
62                  fd, gpg_strerror (gpg_error_from_syserror ()));
63     }
64   last_fd = fd;
65 }
66
67
68 /* Write a status line with code NO followed by the outout of the
69  * printf style FORMAT.  The caller needs to make sure that LFs and
70  * CRs are not printed.  */
71 void
72 wks_write_status (int no, const char *format, ...)
73 {
74   va_list arg_ptr;
75
76   if (!statusfp)
77     return;  /* Not enabled.  */
78
79   es_fputs ("[GNUPG:] ", statusfp);
80   es_fputs (get_status_string (no), statusfp);
81   if (format)
82     {
83       es_putc (' ', statusfp);
84       va_start (arg_ptr, format);
85       es_vfprintf (statusfp, format, arg_ptr);
86       va_end (arg_ptr);
87     }
88   es_putc ('\n', statusfp);
89 }
90
91
92 \f
93
94 /* Append UID to LIST and return the new item.  On success LIST is
95  * updated.  On error ERRNO is set and NULL returned. */
96 static uidinfo_list_t
97 append_to_uidinfo_list (uidinfo_list_t *list, const char *uid, time_t created)
98 {
99   uidinfo_list_t r, sl;
100
101   sl = xtrymalloc (sizeof *sl + strlen (uid));
102   if (!sl)
103     return NULL;
104
105   strcpy (sl->uid, uid);
106   sl->created = created;
107   sl->mbox = mailbox_from_userid (uid);
108   sl->next = NULL;
109   if (!*list)
110     *list = sl;
111   else
112     {
113       for (r = *list; r->next; r = r->next )
114         ;
115       r->next = sl;
116     }
117   return sl;
118 }
119
120
121 /* Free the list of uid infos at LIST.  */
122 void
123 free_uidinfo_list (uidinfo_list_t list)
124 {
125   while (list)
126     {
127       uidinfo_list_t tmp = list->next;
128       xfree (list->mbox);
129       xfree (list);
130       list = tmp;
131     }
132 }
133
134
135 \f
136 /* Helper for wks_list_key and wks_filter_uid.  */
137 static void
138 key_status_cb (void *opaque, const char *keyword, char *args)
139 {
140   (void)opaque;
141
142   if (DBG_CRYPTO)
143     log_debug ("gpg status: %s %s\n", keyword, args);
144 }
145
146
147 /* Run gpg on KEY and store the primary fingerprint at R_FPR and the
148  * list of mailboxes at R_MBOXES.  Returns 0 on success; on error NULL
149  * is stored at R_FPR and R_MBOXES and an error code is returned.
150  * R_FPR may be NULL if the fingerprint is not needed.  */
151 gpg_error_t
152 wks_list_key (estream_t key, char **r_fpr, uidinfo_list_t *r_mboxes)
153 {
154   gpg_error_t err;
155   ccparray_t ccp;
156   const char **argv;
157   estream_t listing;
158   char *line = NULL;
159   size_t length_of_line = 0;
160   size_t  maxlen;
161   ssize_t len;
162   char **fields = NULL;
163   int nfields;
164   int lnr;
165   char *fpr = NULL;
166   uidinfo_list_t mboxes = NULL;
167
168   if (r_fpr)
169     *r_fpr = NULL;
170   *r_mboxes = NULL;
171
172   /* Open a memory stream.  */
173   listing = es_fopenmem (0, "w+b");
174   if (!listing)
175     {
176       err = gpg_error_from_syserror ();
177       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
178       return err;
179     }
180
181   ccparray_init (&ccp, 0);
182
183   ccparray_put (&ccp, "--no-options");
184   if (!opt.verbose)
185     ccparray_put (&ccp, "--quiet");
186   else if (opt.verbose > 1)
187     ccparray_put (&ccp, "--verbose");
188   ccparray_put (&ccp, "--batch");
189   ccparray_put (&ccp, "--status-fd=2");
190   ccparray_put (&ccp, "--always-trust");
191   ccparray_put (&ccp, "--with-colons");
192   ccparray_put (&ccp, "--dry-run");
193   ccparray_put (&ccp, "--import-options=import-minimal,import-show");
194   ccparray_put (&ccp, "--import");
195
196   ccparray_put (&ccp, NULL);
197   argv = ccparray_get (&ccp, NULL);
198   if (!argv)
199     {
200       err = gpg_error_from_syserror ();
201       goto leave;
202     }
203   err = gnupg_exec_tool_stream (opt.gpg_program, argv, key,
204                                 NULL, listing,
205                                 key_status_cb, NULL);
206   if (err)
207     {
208       log_error ("import failed: %s\n", gpg_strerror (err));
209       goto leave;
210     }
211
212   es_rewind (listing);
213   lnr = 0;
214   maxlen = 2048; /* Set limit.  */
215   while ((len = es_read_line (listing, &line, &length_of_line, &maxlen)) > 0)
216     {
217       lnr++;
218       if (!maxlen)
219         {
220           log_error ("received line too long\n");
221           err = gpg_error (GPG_ERR_LINE_TOO_LONG);
222           goto leave;
223         }
224       /* Strip newline and carriage return, if present.  */
225       while (len > 0
226              && (line[len - 1] == '\n' || line[len - 1] == '\r'))
227         line[--len] = '\0';
228       /* log_debug ("line '%s'\n", line); */
229
230       xfree (fields);
231       fields = strtokenize (line, ":");
232       if (!fields)
233         {
234           err = gpg_error_from_syserror ();
235           log_error ("strtokenize failed: %s\n", gpg_strerror (err));
236           goto leave;
237         }
238       for (nfields = 0; fields[nfields]; nfields++)
239         ;
240       if (!nfields)
241         {
242           err = gpg_error (GPG_ERR_INV_ENGINE);
243           goto leave;
244         }
245       if (!strcmp (fields[0], "sec"))
246         {
247           /* gpg may return "sec" as the first record - but we do not
248            * accept secret keys.  */
249           err = gpg_error (GPG_ERR_NO_PUBKEY);
250           goto leave;
251         }
252       if (lnr == 1 && strcmp (fields[0], "pub"))
253         {
254           /* First record is not a public key.  */
255           err = gpg_error (GPG_ERR_INV_ENGINE);
256           goto leave;
257         }
258       if (lnr > 1 && !strcmp (fields[0], "pub"))
259         {
260           /* More than one public key.  */
261           err = gpg_error (GPG_ERR_TOO_MANY);
262           goto leave;
263         }
264       if (!strcmp (fields[0], "sub") || !strcmp (fields[0], "ssb"))
265         break; /* We can stop parsing here.  */
266
267       if (!strcmp (fields[0], "fpr") && nfields > 9 && !fpr)
268         {
269           fpr = xtrystrdup (fields[9]);
270           if (!fpr)
271             {
272               err = gpg_error_from_syserror ();
273               goto leave;
274             }
275         }
276       else if (!strcmp (fields[0], "uid") && nfields > 9)
277         {
278           /* Fixme: Unescape fields[9] */
279           if (!append_to_uidinfo_list (&mboxes, fields[9],
280                                        parse_timestamp (fields[5], NULL)))
281             {
282               err = gpg_error_from_syserror ();
283               goto leave;
284             }
285         }
286     }
287   if (len < 0 || es_ferror (listing))
288     {
289       err = gpg_error_from_syserror ();
290       log_error ("error reading memory stream\n");
291       goto leave;
292     }
293
294   if (!fpr)
295     {
296       err = gpg_error (GPG_ERR_NO_PUBKEY);
297       goto leave;
298     }
299
300   if (r_fpr)
301     {
302       *r_fpr = fpr;
303       fpr = NULL;
304     }
305   *r_mboxes = mboxes;
306   mboxes = NULL;
307
308  leave:
309   xfree (fpr);
310   free_uidinfo_list (mboxes);
311   xfree (fields);
312   es_free (line);
313   xfree (argv);
314   es_fclose (listing);
315   return err;
316 }
317
318
319 /* Run gpg as a filter on KEY and write the output to a new stream
320  * stored at R_NEWKEY.  The new key will containn only the user id
321  * UID.  Returns 0 on success.  Only one key is expected in KEY. */
322 gpg_error_t
323 wks_filter_uid (estream_t *r_newkey, estream_t key, const char *uid)
324 {
325   gpg_error_t err;
326   ccparray_t ccp;
327   const char **argv = NULL;
328   estream_t newkey;
329   char *filterexp = NULL;
330
331   *r_newkey = NULL;
332
333   /* Open a memory stream.  */
334   newkey = es_fopenmem (0, "w+b");
335   if (!newkey)
336     {
337       err = gpg_error_from_syserror ();
338       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
339       return err;
340     }
341
342   /* Prefix the key with the MIME content type.  */
343   es_fputs ("Content-Type: application/pgp-keys\n"
344             "\n", newkey);
345
346   filterexp = es_bsprintf ("keep-uid=uid=%s", uid);
347   if (!filterexp)
348     {
349       err = gpg_error_from_syserror ();
350       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
351       goto leave;
352     }
353
354   ccparray_init (&ccp, 0);
355
356   ccparray_put (&ccp, "--no-options");
357   if (!opt.verbose)
358     ccparray_put (&ccp, "--quiet");
359   else if (opt.verbose > 1)
360     ccparray_put (&ccp, "--verbose");
361   ccparray_put (&ccp, "--batch");
362   ccparray_put (&ccp, "--status-fd=2");
363   ccparray_put (&ccp, "--always-trust");
364   ccparray_put (&ccp, "--armor");
365   ccparray_put (&ccp, "--import-options=import-export");
366   ccparray_put (&ccp, "--import-filter");
367   ccparray_put (&ccp, filterexp);
368   ccparray_put (&ccp, "--import");
369
370   ccparray_put (&ccp, NULL);
371   argv = ccparray_get (&ccp, NULL);
372   if (!argv)
373     {
374       err = gpg_error_from_syserror ();
375       goto leave;
376     }
377   err = gnupg_exec_tool_stream (opt.gpg_program, argv, key,
378                                 NULL, newkey,
379                                 key_status_cb, NULL);
380   if (err)
381     {
382       log_error ("import/export failed: %s\n", gpg_strerror (err));
383       goto leave;
384     }
385
386   es_rewind (newkey);
387   *r_newkey = newkey;
388   newkey = NULL;
389
390  leave:
391   xfree (filterexp);
392   xfree (argv);
393   es_fclose (newkey);
394   return err;
395 }
396
397
398 /* Helper to write mail to the output(s).  */
399 gpg_error_t
400 wks_send_mime (mime_maker_t mime)
401 {
402   gpg_error_t err;
403   estream_t mail;
404
405   /* Without any option we take a short path.  */
406   if (!opt.use_sendmail && !opt.output)
407     {
408       es_set_binary (es_stdout);
409       return mime_maker_make (mime, es_stdout);
410     }
411
412
413   mail = es_fopenmem (0, "w+b");
414   if (!mail)
415     {
416       err = gpg_error_from_syserror ();
417       return err;
418     }
419
420   err = mime_maker_make (mime, mail);
421
422   if (!err && opt.output)
423     {
424       es_rewind (mail);
425       err = send_mail_to_file (mail, opt.output);
426     }
427
428   if (!err && opt.use_sendmail)
429     {
430       es_rewind (mail);
431       err = send_mail (mail);
432     }
433
434   es_fclose (mail);
435   return err;
436 }
437
438
439 /* Parse the policy flags by reading them from STREAM and storing them
440  * into FLAGS.  If IGNORE_UNKNOWN is iset unknown keywords are
441  * ignored.  */
442 gpg_error_t
443 wks_parse_policy (policy_flags_t flags, estream_t stream, int ignore_unknown)
444 {
445   enum tokens {
446     TOK_MAILBOX_ONLY,
447     TOK_DANE_ONLY,
448     TOK_AUTH_SUBMIT,
449     TOK_MAX_PENDING,
450     TOK_PROTOCOL_VERSION
451   };
452   static struct {
453     const char *name;
454     enum tokens token;
455   } keywords[] = {
456     { "mailbox-only", TOK_MAILBOX_ONLY },
457     { "dane-only",    TOK_DANE_ONLY    },
458     { "auth-submit",  TOK_AUTH_SUBMIT  },
459     { "max-pending",  TOK_MAX_PENDING  },
460     { "protocol-version", TOK_PROTOCOL_VERSION }
461   };
462   gpg_error_t err = 0;
463   int lnr = 0;
464   char line[1024];
465   char *p, *keyword, *value;
466   int i, n;
467
468   memset (flags, 0, sizeof *flags);
469
470   while (es_fgets (line, DIM(line)-1, stream) )
471     {
472       lnr++;
473       n = strlen (line);
474       if (!n || line[n-1] != '\n')
475         {
476           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
477                            : GPG_ERR_INCOMPLETE_LINE);
478           break;
479         }
480       trim_trailing_spaces (line);
481       /* Skip empty and comment lines. */
482       for (p=line; spacep (p); p++)
483         ;
484       if (!*p || *p == '#')
485         continue;
486
487       if (*p == ':')
488         {
489           err = gpg_error (GPG_ERR_SYNTAX);
490           break;
491         }
492
493       keyword = p;
494       value = NULL;
495       if ((p = strchr (p, ':')))
496         {
497           /* Colon found: Keyword with value.  */
498           *p++ = 0;
499           for (; spacep (p); p++)
500             ;
501           if (!*p)
502             {
503               err = gpg_error (GPG_ERR_MISSING_VALUE);
504               break;
505             }
506           value = p;
507         }
508
509       for (i=0; i < DIM (keywords); i++)
510         if (!ascii_strcasecmp (keywords[i].name, keyword))
511           break;
512       if (!(i < DIM (keywords)))
513         {
514           if (ignore_unknown)
515             continue;
516           err = gpg_error (GPG_ERR_INV_NAME);
517           break;
518         }
519
520       switch (keywords[i].token)
521         {
522         case TOK_MAILBOX_ONLY: flags->mailbox_only = 1; break;
523         case TOK_DANE_ONLY:    flags->dane_only = 1;    break;
524         case TOK_AUTH_SUBMIT:  flags->auth_submit = 1;  break;
525         case TOK_MAX_PENDING:
526           if (!value)
527             {
528               err = gpg_error (GPG_ERR_SYNTAX);
529               goto leave;
530             }
531           /* FIXME: Define whether these are seconds, hours, or days
532            * and decide whether to allow other units.  */
533           flags->max_pending = atoi (value);
534           break;
535         case TOK_PROTOCOL_VERSION:
536           if (!value)
537             {
538               err = gpg_error (GPG_ERR_SYNTAX);
539               goto leave;
540             }
541           flags->protocol_version = atoi (value);
542           break;
543         }
544     }
545
546   if (!err && !es_feof (stream))
547     err = gpg_error_from_syserror ();
548
549  leave:
550   if (err)
551     log_error ("error reading '%s', line %d: %s\n",
552                es_fname_get (stream), lnr, gpg_strerror (err));
553
554   return err;
555 }