Merge branch 'master' into STABLE-BRANCH-2-2
[gnupg.git] / tools / gpg-wks-client.c
1 /* gpg-wks-client.c - A client for the Web Key Service protocols.
2  * Copyright (C) 2016 Werner Koch
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include "util.h"
26 #include "i18n.h"
27 #include "sysutils.h"
28 #include "init.h"
29 #include "asshelp.h"
30 #include "userids.h"
31 #include "ccparray.h"
32 #include "exectool.h"
33 #include "mbox-util.h"
34 #include "name-value.h"
35 #include "call-dirmngr.h"
36 #include "mime-maker.h"
37 #include "send-mail.h"
38 #include "gpg-wks.h"
39
40
41 /* Constants to identify the commands and options. */
42 enum cmd_and_opt_values
43   {
44     aNull = 0,
45
46     oQuiet      = 'q',
47     oVerbose    = 'v',
48     oOutput     = 'o',
49
50     oDebug      = 500,
51
52     aCreate,
53     aReceive,
54     aRead,
55
56     oGpgProgram,
57     oSend,
58
59     oDummy
60   };
61
62
63 /* The list of commands and options. */
64 static ARGPARSE_OPTS opts[] = {
65   ARGPARSE_group (300, ("@Commands:\n ")),
66
67   ARGPARSE_c (aCreate,   "create",
68               ("create a publication request")),
69   ARGPARSE_c (aReceive,   "receive",
70               ("receive a MIME confirmation request")),
71   ARGPARSE_c (aRead,      "read",
72               ("receive a plain text confirmation request")),
73
74   ARGPARSE_group (301, ("@\nOptions:\n ")),
75
76   ARGPARSE_s_n (oVerbose, "verbose", ("verbose")),
77   ARGPARSE_s_n (oQuiet, "quiet",  ("be somewhat more quiet")),
78   ARGPARSE_s_s (oDebug, "debug", "@"),
79   ARGPARSE_s_s (oGpgProgram, "gpg", "@"),
80   ARGPARSE_s_n (oSend, "send", "send the mail using sendmail"),
81   ARGPARSE_s_s (oOutput, "output", "|FILE|write the mail to FILE"),
82
83
84   ARGPARSE_end ()
85 };
86
87
88 /* The list of supported debug flags.  */
89 static struct debug_flags_s debug_flags [] =
90   {
91     { DBG_CRYPTO_VALUE , "crypto"  },
92     { DBG_MEMORY_VALUE , "memory"  },
93     { DBG_MEMSTAT_VALUE, "memstat" },
94     { DBG_IPC_VALUE    , "ipc"     },
95     { DBG_EXTPROG_VALUE, "extprog" },
96     { 0, NULL }
97   };
98
99
100 static void wrong_args (const char *text) GPGRT_ATTR_NORETURN;
101 static gpg_error_t command_send (const char *fingerprint, char *userid);
102 static gpg_error_t process_confirmation_request (estream_t msg);
103 static gpg_error_t command_receive_cb (void *opaque,
104                                        const char *mediatype, estream_t fp);
105
106
107 \f
108 /* Print usage information and and provide strings for help. */
109 static const char *
110 my_strusage( int level )
111 {
112   const char *p;
113
114   switch (level)
115     {
116     case 11: p = "gpg-wks-client (@GNUPG@)";
117       break;
118     case 13: p = VERSION; break;
119     case 17: p = PRINTABLE_OS_NAME; break;
120     case 19: p = ("Please report bugs to <@EMAIL@>.\n"); break;
121
122     case 1:
123     case 40:
124       p = ("Usage: gpg-wks-client [command] [options] [args] (-h for help)");
125       break;
126     case 41:
127       p = ("Syntax: gpg-wks-client [command] [options] [args]\n"
128            "Client for the Web Key Service\n");
129       break;
130
131     default: p = NULL; break;
132     }
133   return p;
134 }
135
136
137 static void
138 wrong_args (const char *text)
139 {
140   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), strusage (11), text);
141   exit (2);
142 }
143
144
145 \f
146 /* Command line parsing.  */
147 static enum cmd_and_opt_values
148 parse_arguments (ARGPARSE_ARGS *pargs, ARGPARSE_OPTS *popts)
149 {
150   enum cmd_and_opt_values cmd = 0;
151   int no_more_options = 0;
152
153   while (!no_more_options && optfile_parse (NULL, NULL, NULL, pargs, popts))
154     {
155       switch (pargs->r_opt)
156         {
157         case oQuiet:     opt.quiet = 1; break;
158         case oVerbose:   opt.verbose++; break;
159         case oDebug:
160           if (parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags))
161             {
162               pargs->r_opt = ARGPARSE_INVALID_ARG;
163               pargs->err = ARGPARSE_PRINT_ERROR;
164             }
165           break;
166
167         case oGpgProgram:
168           opt.gpg_program = pargs->r.ret_str;
169           break;
170         case oSend:
171           opt.use_sendmail = 1;
172           break;
173         case oOutput:
174           opt.output = pargs->r.ret_str;
175           break;
176
177         case aCreate:
178         case aReceive:
179         case aRead:
180           cmd = pargs->r_opt;
181           break;
182
183         default: pargs->err = 2; break;
184         }
185     }
186
187   return cmd;
188 }
189
190
191 \f
192 /* gpg-wks-client main. */
193 int
194 main (int argc, char **argv)
195 {
196   gpg_error_t err;
197   ARGPARSE_ARGS pargs;
198   enum cmd_and_opt_values cmd;
199
200   gnupg_reopen_std ("gpg-wks-client");
201   set_strusage (my_strusage);
202   log_set_prefix ("gpg-wks-client", GPGRT_LOG_WITH_PREFIX);
203
204   /* Make sure that our subsystems are ready.  */
205   i18n_init();
206   init_common_subsystems (&argc, &argv);
207
208   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
209   setup_libassuan_logging (&opt.debug);
210
211   /* Parse the command line. */
212   pargs.argc  = &argc;
213   pargs.argv  = &argv;
214   pargs.flags = ARGPARSE_FLAG_KEEP;
215   cmd = parse_arguments (&pargs, opts);
216
217   if (log_get_errorcount (0))
218     exit (2);
219
220   /* Print a warning if an argument looks like an option.  */
221   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
222     {
223       int i;
224
225       for (i=0; i < argc; i++)
226         if (argv[i][0] == '-' && argv[i][1] == '-')
227           log_info (("NOTE: '%s' is not considered an option\n"), argv[i]);
228     }
229
230   /* Set defaults for non given options.  */
231   if (!opt.gpg_program)
232     opt.gpg_program = gnupg_module_name (GNUPG_MODULE_NAME_GPG);
233
234   /* Tell call-dirmngr what options we want.  */
235   set_dirmngr_options (opt.verbose, (opt.debug & DBG_IPC_VALUE), 1);
236
237   /* Run the selected command.  */
238   switch (cmd)
239     {
240     case aCreate:
241       if (argc != 2)
242         wrong_args ("--create FINGERPRINT USER-ID");
243       err = command_send (argv[0], argv[1]);
244       if (err)
245         log_error ("creating request failed: %s\n", gpg_strerror (err));
246       break;
247
248     case aReceive:
249       if (argc)
250         wrong_args ("--receive < MIME-DATA");
251       err = wks_receive (es_stdin, command_receive_cb, NULL);
252       if (err)
253         log_error ("processing mail failed: %s\n", gpg_strerror (err));
254       break;
255
256     case aRead:
257       if (argc)
258         wrong_args ("--read < WKS-DATA");
259       err = process_confirmation_request (es_stdin);
260       if (err)
261         log_error ("processing mail failed: %s\n", gpg_strerror (err));
262       break;
263
264     default:
265       usage (1);
266       break;
267     }
268
269   return log_get_errorcount (0)? 1:0;
270 }
271
272
273 \f
274 struct get_key_status_parm_s
275 {
276   const char *fpr;
277   int found;
278   int count;
279 };
280
281 static void
282 get_key_status_cb (void *opaque, const char *keyword, char *args)
283 {
284   struct get_key_status_parm_s *parm = opaque;
285
286   /*log_debug ("%s: %s\n", keyword, args);*/
287   if (!strcmp (keyword, "EXPORTED"))
288     {
289       parm->count++;
290       if (!ascii_strcasecmp (args, parm->fpr))
291         parm->found = 1;
292     }
293 }
294
295
296 /* Get a key by fingerprint from gpg's keyring and make sure that the
297  * mail address ADDRSPEC is included in the key.  The key is returned
298  * as a new memory stream at R_KEY.
299  *
300  * Fixme: After we have implemented import and export filters for gpg
301  * this function shall only return a key with just this user id.  */
302 static gpg_error_t
303 get_key (estream_t *r_key, const char *fingerprint, const char *addrspec)
304 {
305   gpg_error_t err;
306   ccparray_t ccp;
307   const char **argv = NULL;
308   estream_t key = NULL;
309   struct get_key_status_parm_s parm;
310   char *filterexp = NULL;
311
312   memset (&parm, 0, sizeof parm);
313
314   *r_key = NULL;
315
316   key = es_fopenmem (0, "w+b");
317   if (!key)
318     {
319       err = gpg_error_from_syserror ();
320       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
321       goto leave;
322     }
323
324   filterexp = es_bsprintf ("keep-uid=mbox = %s", addrspec);
325   if (!filterexp)
326     {
327       err = gpg_error_from_syserror ();
328       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
329       goto leave;
330     }
331
332   ccparray_init (&ccp, 0);
333
334   ccparray_put (&ccp, "--no-options");
335   if (!opt.verbose)
336     ccparray_put (&ccp, "--quiet");
337   else if (opt.verbose > 1)
338     ccparray_put (&ccp, "--verbose");
339   ccparray_put (&ccp, "--batch");
340   ccparray_put (&ccp, "--status-fd=2");
341   ccparray_put (&ccp, "--always-trust");
342   ccparray_put (&ccp, "--armor");
343   ccparray_put (&ccp, "--export-options=export-minimal");
344   ccparray_put (&ccp, "--export-filter");
345   ccparray_put (&ccp, filterexp);
346   ccparray_put (&ccp, "--export");
347   ccparray_put (&ccp, "--");
348   ccparray_put (&ccp, fingerprint);
349
350   ccparray_put (&ccp, NULL);
351   argv = ccparray_get (&ccp, NULL);
352   if (!argv)
353     {
354       err = gpg_error_from_syserror ();
355       goto leave;
356     }
357   parm.fpr = fingerprint;
358   err = gnupg_exec_tool_stream (opt.gpg_program, argv, NULL,
359                                 NULL, key,
360                                 get_key_status_cb, &parm);
361   if (!err && parm.count > 1)
362     err = gpg_error (GPG_ERR_TOO_MANY);
363   else if (!err && !parm.found)
364     err = gpg_error (GPG_ERR_NOT_FOUND);
365   if (err)
366     {
367       log_error ("export failed: %s\n", gpg_strerror (err));
368       goto leave;
369     }
370
371   es_rewind (key);
372   *r_key = key;
373   key = NULL;
374
375  leave:
376   es_fclose (key);
377   xfree (argv);
378   xfree (filterexp);
379   return err;
380 }
381
382
383 \f
384 /* Locate the key by fingerprint and userid and send a publication
385  * request.  */
386 static gpg_error_t
387 command_send (const char *fingerprint, char *userid)
388 {
389   gpg_error_t err;
390   KEYDB_SEARCH_DESC desc;
391   char *addrspec = NULL;
392   estream_t key = NULL;
393   char *submission_to = NULL;
394   mime_maker_t mime = NULL;
395
396   if (classify_user_id (fingerprint, &desc, 1)
397       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
398            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
399     {
400       log_error (_("\"%s\" is not a fingerprint\n"), fingerprint);
401       err = gpg_error (GPG_ERR_INV_NAME);
402       goto leave;
403     }
404   addrspec = mailbox_from_userid (userid);
405   if (!addrspec)
406     {
407       log_error (_("\"%s\" is not a proper mail address\n"), userid);
408       err = gpg_error (GPG_ERR_INV_USER_ID);
409       goto leave;
410     }
411   err = get_key (&key, fingerprint, addrspec);
412   if (err)
413     goto leave;
414
415   /* Get the submission address.  */
416   err = wkd_get_submission_address (addrspec, &submission_to);
417   if (err)
418     goto leave;
419   log_info ("submitting request to '%s'\n", submission_to);
420
421   /* Send the key.  */
422   err = mime_maker_new (&mime, NULL);
423   if (err)
424     goto leave;
425   err = mime_maker_add_header (mime, "From", addrspec);
426   if (err)
427     goto leave;
428   err = mime_maker_add_header (mime, "To", submission_to);
429   if (err)
430     goto leave;
431   err = mime_maker_add_header (mime, "Subject", "Key publishing request");
432   if (err)
433     goto leave;
434
435   err = mime_maker_add_header (mime, "Content-type", "application/pgp-keys");
436   if (err)
437     goto leave;
438
439   err = mime_maker_add_stream (mime, &key);
440   if (err)
441     goto leave;
442
443   err = wks_send_mime (mime);
444
445  leave:
446   mime_maker_release (mime);
447   xfree (submission_to);
448   es_fclose (key);
449   xfree (addrspec);
450   return err;
451 }
452
453
454 \f
455 static void
456 encrypt_response_status_cb (void *opaque, const char *keyword, char *args)
457 {
458   gpg_error_t *failure = opaque;
459   char *fields[2];
460
461   if (opt.debug)
462     log_debug ("%s: %s\n", keyword, args);
463
464   if (!strcmp (keyword, "FAILURE"))
465     {
466       if (split_fields (args, fields, DIM (fields)) >= 2
467           && !strcmp (fields[0], "encrypt"))
468         *failure = strtoul (fields[1], NULL, 10);
469     }
470
471 }
472
473
474 /* Encrypt the INPUT stream to a new stream which is stored at success
475  * at R_OUTPUT.  Encryption is done for ADDRSPEC.  We currently
476  * retrieve that key from the WKD, DANE, or from "local".  "local" is
477  * last to prefer the latest key version but use a local copy in case
478  * we are working offline.  It might be useful for the server to send
479  * the fingerprint of its encryption key - or even the entire key
480  * back.  */
481 static gpg_error_t
482 encrypt_response (estream_t *r_output, estream_t input, const char *addrspec)
483 {
484   gpg_error_t err;
485   ccparray_t ccp;
486   const char **argv;
487   estream_t output;
488   gpg_error_t gpg_err = 0;
489
490   *r_output = NULL;
491
492   output = es_fopenmem (0, "w+b");
493   if (!output)
494     {
495       err = gpg_error_from_syserror ();
496       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
497       return err;
498     }
499
500   ccparray_init (&ccp, 0);
501
502   ccparray_put (&ccp, "--no-options");
503   if (!opt.verbose)
504     ccparray_put (&ccp, "--quiet");
505   else if (opt.verbose > 1)
506     ccparray_put (&ccp, "--verbose");
507   ccparray_put (&ccp, "--batch");
508   ccparray_put (&ccp, "--status-fd=2");
509   ccparray_put (&ccp, "--always-trust");
510   ccparray_put (&ccp, "--armor");
511   ccparray_put (&ccp, "--auto-key-locate=clear,wkd,dane,local");
512   ccparray_put (&ccp, "--recipient");
513   ccparray_put (&ccp, addrspec);
514   ccparray_put (&ccp, "--encrypt");
515   ccparray_put (&ccp, "--");
516
517   ccparray_put (&ccp, NULL);
518   argv = ccparray_get (&ccp, NULL);
519   if (!argv)
520     {
521       err = gpg_error_from_syserror ();
522       goto leave;
523     }
524   err = gnupg_exec_tool_stream (opt.gpg_program, argv, input,
525                                 NULL, output,
526                                 encrypt_response_status_cb, &gpg_err);
527   if (err)
528     {
529       if (gpg_err)
530         err = gpg_err;
531       log_error ("encryption failed: %s\n", gpg_strerror (err));
532       goto leave;
533     }
534
535   es_rewind (output);
536   *r_output = output;
537   output = NULL;
538
539  leave:
540   es_fclose (output);
541   xfree (argv);
542   return err;
543 }
544
545
546 static gpg_error_t
547 send_confirmation_response (const char *sender, const char *address,
548                             const char *nonce, int encrypt)
549 {
550   gpg_error_t err;
551   estream_t body = NULL;
552   estream_t bodyenc = NULL;
553   mime_maker_t mime = NULL;
554
555   body = es_fopenmem (0, "w+b");
556   if (!body)
557     {
558       err = gpg_error_from_syserror ();
559       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
560       return err;
561     }
562
563   /* It is fine to use 8 bit encoding because that is encrypted and
564    * only our client will see it.  */
565   if (encrypt)
566     {
567       es_fputs ("Content-Type: application/vnd.gnupg.wks\n"
568                 "Content-Transfer-Encoding: 8bit\n"
569                 "\n",
570                 body);
571     }
572
573   es_fprintf (body, ("type: confirmation-response\n"
574                      "sender: %s\n"
575                      "address: %s\n"
576                      "nonce: %s\n"),
577               sender,
578               address,
579               nonce);
580
581   es_rewind (body);
582   if (encrypt)
583     {
584       err = encrypt_response (&bodyenc, body, sender);
585       if (err)
586         goto leave;
587       es_fclose (body);
588       body = NULL;
589     }
590
591   err = mime_maker_new (&mime, NULL);
592   if (err)
593     goto leave;
594   err = mime_maker_add_header (mime, "From", address);
595   if (err)
596     goto leave;
597   err = mime_maker_add_header (mime, "To", sender);
598   if (err)
599     goto leave;
600   err = mime_maker_add_header (mime, "Subject", "Key publication confirmation");
601   if (err)
602     goto leave;
603
604   if (encrypt)
605     {
606       err = mime_maker_add_header (mime, "Content-Type",
607                                    "multipart/encrypted; "
608                                    "protocol=\"application/pgp-encrypted\"");
609       if (err)
610         goto leave;
611       err = mime_maker_add_container (mime, "multipart/encrypted");
612       if (err)
613         goto leave;
614
615       err = mime_maker_add_header (mime, "Content-Type",
616                                    "application/pgp-encrypted");
617       if (err)
618         goto leave;
619       err = mime_maker_add_body (mime, "Version: 1\n");
620       if (err)
621         goto leave;
622       err = mime_maker_add_header (mime, "Content-Type",
623                                    "application/octet-stream");
624       if (err)
625         goto leave;
626
627       err = mime_maker_add_stream (mime, &bodyenc);
628       if (err)
629         goto leave;
630     }
631   else
632     {
633       err = mime_maker_add_header (mime, "Content-Type",
634                                    "application/vnd.gnupg.wks");
635       if (err)
636         goto leave;
637       err = mime_maker_add_stream (mime, &body);
638       if (err)
639         goto leave;
640     }
641
642   err = wks_send_mime (mime);
643
644  leave:
645   mime_maker_release (mime);
646   es_fclose (bodyenc);
647   es_fclose (body);
648   return err;
649 }
650
651
652 /* Reply to a confirmation request.  The MSG has already been
653  * decrypted and we only need to send the nonce back.  */
654 static gpg_error_t
655 process_confirmation_request (estream_t msg)
656 {
657   gpg_error_t err;
658   nvc_t nvc;
659   nve_t item;
660   const char *value, *sender, *address, *nonce;
661
662   err = nvc_parse (&nvc, NULL, msg);
663   if (err)
664     {
665       log_error ("parsing the WKS message failed: %s\n", gpg_strerror (err));
666       goto leave;
667     }
668
669   if (opt.debug)
670     {
671       log_debug ("request follows:\n");
672       nvc_write (nvc, log_get_stream ());
673     }
674
675   /* Check that this is a confirmation request.  */
676   if (!((item = nvc_lookup (nvc, "type:")) && (value = nve_value (item))
677         && !strcmp (value, "confirmation-request")))
678     {
679       if (item && value)
680         log_error ("received unexpected wks message '%s'\n", value);
681       else
682         log_error ("received invalid wks message: %s\n", "'type' missing");
683       err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
684       goto leave;
685     }
686
687   /* FIXME: Check that the fingerprint matches the key used to decrypt the
688    * message.  */
689
690   /* Get the address.  */
691   if (!((item = nvc_lookup (nvc, "address:")) && (value = nve_value (item))
692         && is_valid_mailbox (value)))
693     {
694       log_error ("received invalid wks message: %s\n",
695                  "'address' missing or invalid");
696       err = gpg_error (GPG_ERR_INV_DATA);
697       goto leave;
698     }
699   address = value;
700   /* FIXME: Check that the "address" matches the User ID we want to
701    * publish.  */
702
703   /* Get the sender.  */
704   if (!((item = nvc_lookup (nvc, "sender:")) && (value = nve_value (item))
705         && is_valid_mailbox (value)))
706     {
707       log_error ("received invalid wks message: %s\n",
708                  "'sender' missing or invalid");
709       err = gpg_error (GPG_ERR_INV_DATA);
710       goto leave;
711     }
712   sender = value;
713   /* FIXME: Check that the "sender" matches the From: address.  */
714
715   /* Get the nonce.  */
716   if (!((item = nvc_lookup (nvc, "nonce:")) && (value = nve_value (item))
717         && strlen (value) > 16))
718     {
719       log_error ("received invalid wks message: %s\n",
720                  "'nonce' missing or too short");
721       err = gpg_error (GPG_ERR_INV_DATA);
722       goto leave;
723     }
724   nonce = value;
725
726   /* Send the confirmation.  If no key was found, try again without
727    * encryption.  */
728   err = send_confirmation_response (sender, address, nonce, 1);
729   if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
730     {
731       log_info ("no encryption key found - sending response in the clear\n");
732       err = send_confirmation_response (sender, address, nonce, 0);
733     }
734
735  leave:
736   nvc_release (nvc);
737   return err;
738 }
739
740
741 /* Called from the MIME receiver to process the plain text data in MSG.  */
742 static gpg_error_t
743 command_receive_cb (void *opaque, const char *mediatype, estream_t msg)
744 {
745   gpg_error_t err;
746
747   (void)opaque;
748
749   if (!strcmp (mediatype, "application/vnd.gnupg.wks"))
750     err = process_confirmation_request (msg);
751   else
752     {
753       log_info ("ignoring unexpected message of type '%s'\n", mediatype);
754       err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
755     }
756
757   return err;
758 }