c31e3a1b0e3407c883ac3ebf767ad114b3e0e8ca
[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 <https://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 "status.h"
27 #include "i18n.h"
28 #include "sysutils.h"
29 #include "init.h"
30 #include "asshelp.h"
31 #include "userids.h"
32 #include "ccparray.h"
33 #include "exectool.h"
34 #include "mbox-util.h"
35 #include "name-value.h"
36 #include "call-dirmngr.h"
37 #include "mime-maker.h"
38 #include "send-mail.h"
39 #include "gpg-wks.h"
40
41
42 /* Constants to identify the commands and options. */
43 enum cmd_and_opt_values
44   {
45     aNull = 0,
46
47     oQuiet      = 'q',
48     oVerbose    = 'v',
49     oOutput     = 'o',
50
51     oDebug      = 500,
52
53     aSupported,
54     aCheck,
55     aCreate,
56     aReceive,
57     aRead,
58
59     oGpgProgram,
60     oSend,
61     oFakeSubmissionAddr,
62     oStatusFD,
63
64     oDummy
65   };
66
67
68 /* The list of commands and options. */
69 static ARGPARSE_OPTS opts[] = {
70   ARGPARSE_group (300, ("@Commands:\n ")),
71
72   ARGPARSE_c (aSupported, "supported",
73               ("check whether provider supports WKS")),
74   ARGPARSE_c (aCheck, "check",
75               ("check whether a key is available")),
76   ARGPARSE_c (aCreate,   "create",
77               ("create a publication request")),
78   ARGPARSE_c (aReceive,   "receive",
79               ("receive a MIME confirmation request")),
80   ARGPARSE_c (aRead,      "read",
81               ("receive a plain text confirmation request")),
82
83   ARGPARSE_group (301, ("@\nOptions:\n ")),
84
85   ARGPARSE_s_n (oVerbose, "verbose", ("verbose")),
86   ARGPARSE_s_n (oQuiet, "quiet",  ("be somewhat more quiet")),
87   ARGPARSE_s_s (oDebug, "debug", "@"),
88   ARGPARSE_s_s (oGpgProgram, "gpg", "@"),
89   ARGPARSE_s_n (oSend, "send", "send the mail using sendmail"),
90   ARGPARSE_s_s (oOutput, "output", "|FILE|write the mail to FILE"),
91   ARGPARSE_s_i (oStatusFD, "status-fd", N_("|FD|write status info to this FD")),
92
93   ARGPARSE_s_s (oFakeSubmissionAddr, "fake-submission-addr", "@"),
94
95   ARGPARSE_end ()
96 };
97
98
99 /* The list of supported debug flags.  */
100 static struct debug_flags_s debug_flags [] =
101   {
102     { DBG_MIME_VALUE   , "mime"    },
103     { DBG_PARSER_VALUE , "parser"  },
104     { DBG_CRYPTO_VALUE , "crypto"  },
105     { DBG_MEMORY_VALUE , "memory"  },
106     { DBG_MEMSTAT_VALUE, "memstat" },
107     { DBG_IPC_VALUE    , "ipc"     },
108     { DBG_EXTPROG_VALUE, "extprog" },
109     { 0, NULL }
110   };
111
112
113
114 /* Value of the option --fake-submission-addr.  */
115 const char *fake_submission_addr;
116
117
118 static void wrong_args (const char *text) GPGRT_ATTR_NORETURN;
119 static gpg_error_t command_supported (char *userid);
120 static gpg_error_t command_check (char *userid);
121 static gpg_error_t command_send (const char *fingerprint, char *userid);
122 static gpg_error_t encrypt_response (estream_t *r_output, estream_t input,
123                                      const char *addrspec,
124                                      const char *fingerprint);
125 static gpg_error_t read_confirmation_request (estream_t msg);
126 static gpg_error_t command_receive_cb (void *opaque,
127                                        const char *mediatype, estream_t fp,
128                                        unsigned int flags);
129
130
131 \f
132 /* Print usage information and provide strings for help. */
133 static const char *
134 my_strusage( int level )
135 {
136   const char *p;
137
138   switch (level)
139     {
140     case 11: p = "gpg-wks-client (@GNUPG@)";
141       break;
142     case 13: p = VERSION; break;
143     case 17: p = PRINTABLE_OS_NAME; break;
144     case 19: p = ("Please report bugs to <@EMAIL@>.\n"); break;
145
146     case 1:
147     case 40:
148       p = ("Usage: gpg-wks-client [command] [options] [args] (-h for help)");
149       break;
150     case 41:
151       p = ("Syntax: gpg-wks-client [command] [options] [args]\n"
152            "Client for the Web Key Service\n");
153       break;
154
155     default: p = NULL; break;
156     }
157   return p;
158 }
159
160
161 static void
162 wrong_args (const char *text)
163 {
164   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), strusage (11), text);
165   exit (2);
166 }
167
168
169 \f
170 /* Command line parsing.  */
171 static enum cmd_and_opt_values
172 parse_arguments (ARGPARSE_ARGS *pargs, ARGPARSE_OPTS *popts)
173 {
174   enum cmd_and_opt_values cmd = 0;
175   int no_more_options = 0;
176
177   while (!no_more_options && optfile_parse (NULL, NULL, NULL, pargs, popts))
178     {
179       switch (pargs->r_opt)
180         {
181         case oQuiet:     opt.quiet = 1; break;
182         case oVerbose:   opt.verbose++; break;
183         case oDebug:
184           if (parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags))
185             {
186               pargs->r_opt = ARGPARSE_INVALID_ARG;
187               pargs->err = ARGPARSE_PRINT_ERROR;
188             }
189           break;
190
191         case oGpgProgram:
192           opt.gpg_program = pargs->r.ret_str;
193           break;
194         case oSend:
195           opt.use_sendmail = 1;
196           break;
197         case oOutput:
198           opt.output = pargs->r.ret_str;
199           break;
200         case oFakeSubmissionAddr:
201           fake_submission_addr = pargs->r.ret_str;
202           break;
203         case oStatusFD:
204           wks_set_status_fd (translate_sys2libc_fd_int (pargs->r.ret_int, 1));
205           break;
206
207         case aSupported:
208         case aCreate:
209         case aReceive:
210         case aRead:
211         case aCheck:
212           cmd = pargs->r_opt;
213           break;
214
215         default: pargs->err = 2; break;
216         }
217     }
218
219   return cmd;
220 }
221
222
223 \f
224 /* gpg-wks-client main. */
225 int
226 main (int argc, char **argv)
227 {
228   gpg_error_t err;
229   ARGPARSE_ARGS pargs;
230   enum cmd_and_opt_values cmd;
231
232   gnupg_reopen_std ("gpg-wks-client");
233   set_strusage (my_strusage);
234   log_set_prefix ("gpg-wks-client", GPGRT_LOG_WITH_PREFIX);
235
236   /* Make sure that our subsystems are ready.  */
237   i18n_init();
238   init_common_subsystems (&argc, &argv);
239
240   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
241   setup_libassuan_logging (&opt.debug, NULL);
242
243   /* Parse the command line. */
244   pargs.argc  = &argc;
245   pargs.argv  = &argv;
246   pargs.flags = ARGPARSE_FLAG_KEEP;
247   cmd = parse_arguments (&pargs, opts);
248
249   if (log_get_errorcount (0))
250     exit (2);
251
252   /* Print a warning if an argument looks like an option.  */
253   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
254     {
255       int i;
256
257       for (i=0; i < argc; i++)
258         if (argv[i][0] == '-' && argv[i][1] == '-')
259           log_info (("NOTE: '%s' is not considered an option\n"), argv[i]);
260     }
261
262   /* Set defaults for non given options.  */
263   if (!opt.gpg_program)
264     opt.gpg_program = gnupg_module_name (GNUPG_MODULE_NAME_GPG);
265
266   /* Tell call-dirmngr what options we want.  */
267   set_dirmngr_options (opt.verbose, (opt.debug & DBG_IPC_VALUE), 1);
268
269   /* Run the selected command.  */
270   switch (cmd)
271     {
272     case aSupported:
273       if (argc != 1)
274         wrong_args ("--supported USER-ID");
275       err = command_supported (argv[0]);
276       if (err && gpg_err_code (err) != GPG_ERR_FALSE)
277         log_error ("checking support failed: %s\n", gpg_strerror (err));
278       break;
279
280     case aCreate:
281       if (argc != 2)
282         wrong_args ("--create FINGERPRINT USER-ID");
283       err = command_send (argv[0], argv[1]);
284       if (err)
285         log_error ("creating request failed: %s\n", gpg_strerror (err));
286       break;
287
288     case aReceive:
289       if (argc)
290         wrong_args ("--receive < MIME-DATA");
291       err = wks_receive (es_stdin, command_receive_cb, NULL);
292       if (err)
293         log_error ("processing mail failed: %s\n", gpg_strerror (err));
294       break;
295
296     case aRead:
297       if (argc)
298         wrong_args ("--read < WKS-DATA");
299       err = read_confirmation_request (es_stdin);
300       if (err)
301         log_error ("processing mail failed: %s\n", gpg_strerror (err));
302       break;
303
304     case aCheck:
305       if (argc != 1)
306         wrong_args ("--check USER-ID");
307       err = command_check (argv[0]);
308       break;
309
310     default:
311       usage (1);
312       err = 0;
313       break;
314     }
315
316   if (err)
317     wks_write_status (STATUS_FAILURE, "- %u", err);
318   else if (log_get_errorcount (0))
319     wks_write_status (STATUS_FAILURE, "- %u", GPG_ERR_GENERAL);
320   else
321     wks_write_status (STATUS_SUCCESS, NULL);
322   return log_get_errorcount (0)? 1:0;
323 }
324
325
326 \f
327 struct get_key_status_parm_s
328 {
329   const char *fpr;
330   int found;
331   int count;
332 };
333
334 static void
335 get_key_status_cb (void *opaque, const char *keyword, char *args)
336 {
337   struct get_key_status_parm_s *parm = opaque;
338
339   /*log_debug ("%s: %s\n", keyword, args);*/
340   if (!strcmp (keyword, "EXPORTED"))
341     {
342       parm->count++;
343       if (!ascii_strcasecmp (args, parm->fpr))
344         parm->found = 1;
345     }
346 }
347
348
349 /* Get a key by fingerprint from gpg's keyring and make sure that the
350  * mail address ADDRSPEC is included in the key.  The key is returned
351  * as a new memory stream at R_KEY.
352  *
353  * Fixme: After we have implemented import and export filters for gpg
354  * this function shall only return a key with just this user id.  */
355 static gpg_error_t
356 get_key (estream_t *r_key, const char *fingerprint, const char *addrspec)
357 {
358   gpg_error_t err;
359   ccparray_t ccp;
360   const char **argv = NULL;
361   estream_t key = NULL;
362   struct get_key_status_parm_s parm;
363   char *filterexp = NULL;
364
365   memset (&parm, 0, sizeof parm);
366
367   *r_key = NULL;
368
369   key = es_fopenmem (0, "w+b");
370   if (!key)
371     {
372       err = gpg_error_from_syserror ();
373       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
374       goto leave;
375     }
376
377   /* Prefix the key with the MIME content type.  */
378   es_fputs ("Content-Type: application/pgp-keys\n"
379             "\n", key);
380
381   filterexp = es_bsprintf ("keep-uid=mbox = %s", addrspec);
382   if (!filterexp)
383     {
384       err = gpg_error_from_syserror ();
385       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
386       goto leave;
387     }
388
389   ccparray_init (&ccp, 0);
390
391   ccparray_put (&ccp, "--no-options");
392   if (!opt.verbose)
393     ccparray_put (&ccp, "--quiet");
394   else if (opt.verbose > 1)
395     ccparray_put (&ccp, "--verbose");
396   ccparray_put (&ccp, "--batch");
397   ccparray_put (&ccp, "--status-fd=2");
398   ccparray_put (&ccp, "--always-trust");
399   ccparray_put (&ccp, "--armor");
400   ccparray_put (&ccp, "--export-options=export-minimal");
401   ccparray_put (&ccp, "--export-filter");
402   ccparray_put (&ccp, filterexp);
403   ccparray_put (&ccp, "--export");
404   ccparray_put (&ccp, "--");
405   ccparray_put (&ccp, fingerprint);
406
407   ccparray_put (&ccp, NULL);
408   argv = ccparray_get (&ccp, NULL);
409   if (!argv)
410     {
411       err = gpg_error_from_syserror ();
412       goto leave;
413     }
414   parm.fpr = fingerprint;
415   err = gnupg_exec_tool_stream (opt.gpg_program, argv, NULL,
416                                 NULL, key,
417                                 get_key_status_cb, &parm);
418   if (!err && parm.count > 1)
419     err = gpg_error (GPG_ERR_TOO_MANY);
420   else if (!err && !parm.found)
421     err = gpg_error (GPG_ERR_NOT_FOUND);
422   if (err)
423     {
424       log_error ("export failed: %s\n", gpg_strerror (err));
425       goto leave;
426     }
427
428   es_rewind (key);
429   *r_key = key;
430   key = NULL;
431
432  leave:
433   es_fclose (key);
434   xfree (argv);
435   xfree (filterexp);
436   return err;
437 }
438
439
440 \f
441 struct decrypt_stream_parm_s
442 {
443   char *fpr;
444   char *mainfpr;
445   int  otrust;
446 };
447
448 static void
449 decrypt_stream_status_cb (void *opaque, const char *keyword, char *args)
450 {
451   struct decrypt_stream_parm_s *decinfo = opaque;
452
453   if (DBG_CRYPTO)
454     log_debug ("gpg status: %s %s\n", keyword, args);
455   if (!strcmp (keyword, "DECRYPTION_KEY") && !decinfo->fpr)
456     {
457       char *fields[3];
458
459       if (split_fields (args, fields, DIM (fields)) >= 3)
460         {
461           decinfo->fpr = xstrdup (fields[0]);
462           decinfo->mainfpr = xstrdup (fields[1]);
463           decinfo->otrust = *fields[2];
464         }
465     }
466 }
467
468 /* Decrypt the INPUT stream to a new stream which is stored at success
469  * at R_OUTPUT.  */
470 static gpg_error_t
471 decrypt_stream (estream_t *r_output, struct decrypt_stream_parm_s *decinfo,
472                 estream_t input)
473 {
474   gpg_error_t err;
475   ccparray_t ccp;
476   const char **argv;
477   estream_t output;
478
479   *r_output = NULL;
480   memset (decinfo, 0, sizeof *decinfo);
481
482   output = es_fopenmem (0, "w+b");
483   if (!output)
484     {
485       err = gpg_error_from_syserror ();
486       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
487       return err;
488     }
489
490   ccparray_init (&ccp, 0);
491
492   ccparray_put (&ccp, "--no-options");
493   /* We limit the output to 64 KiB to avoid DoS using compression
494    * tricks.  A regular client will anyway only send a minimal key;
495    * that is one w/o key signatures and attribute packets.  */
496   ccparray_put (&ccp, "--max-output=0x10000");
497   if (!opt.verbose)
498     ccparray_put (&ccp, "--quiet");
499   else if (opt.verbose > 1)
500     ccparray_put (&ccp, "--verbose");
501   ccparray_put (&ccp, "--batch");
502   ccparray_put (&ccp, "--status-fd=2");
503   ccparray_put (&ccp, "--decrypt");
504   ccparray_put (&ccp, "--");
505
506   ccparray_put (&ccp, NULL);
507   argv = ccparray_get (&ccp, NULL);
508   if (!argv)
509     {
510       err = gpg_error_from_syserror ();
511       goto leave;
512     }
513   err = gnupg_exec_tool_stream (opt.gpg_program, argv, input,
514                                 NULL, output,
515                                 decrypt_stream_status_cb, decinfo);
516   if (!err && (!decinfo->fpr || !decinfo->mainfpr || !decinfo->otrust))
517     err = gpg_error (GPG_ERR_INV_ENGINE);
518   if (err)
519     {
520       log_error ("decryption failed: %s\n", gpg_strerror (err));
521       goto leave;
522     }
523   else if (opt.verbose)
524     log_info ("decryption succeeded\n");
525
526   es_rewind (output);
527   *r_output = output;
528   output = NULL;
529
530  leave:
531   if (err)
532     {
533       xfree (decinfo->fpr);
534       xfree (decinfo->mainfpr);
535       memset (decinfo, 0, sizeof *decinfo);
536     }
537   es_fclose (output);
538   xfree (argv);
539   return err;
540 }
541
542
543
544 \f
545 /* Check whether the  provider supports the WKS protocol.  */
546 static gpg_error_t
547 command_supported (char *userid)
548 {
549   gpg_error_t err;
550   char *addrspec = NULL;
551   char *submission_to = NULL;
552
553   addrspec = mailbox_from_userid (userid);
554   if (!addrspec)
555     {
556       log_error (_("\"%s\" is not a proper mail address\n"), userid);
557       err = gpg_error (GPG_ERR_INV_USER_ID);
558       goto leave;
559     }
560
561   /* Get the submission address.  */
562   err = wkd_get_submission_address (addrspec, &submission_to);
563   if (err)
564     {
565       if (gpg_err_code (err) == GPG_ERR_NO_DATA
566           || gpg_err_code (err) == GPG_ERR_UNKNOWN_HOST)
567         {
568           if (opt.verbose)
569             log_info ("provider for '%s' does NOT support WKS (%s)\n",
570                       addrspec, gpg_strerror (err));
571           err = gpg_error (GPG_ERR_FALSE);
572           log_inc_errorcount ();
573         }
574       goto leave;
575     }
576   if (opt.verbose)
577     log_info ("provider for '%s' supports WKS\n", addrspec);
578
579  leave:
580   xfree (submission_to);
581   xfree (addrspec);
582   return err;
583 }
584
585
586 \f
587 /* Check whether the key for USERID is available in the WKD.  */
588 static gpg_error_t
589 command_check (char *userid)
590 {
591   gpg_error_t err;
592   char *addrspec = NULL;
593   estream_t key = NULL;
594   char *fpr = NULL;
595   strlist_t mboxes = NULL;
596   strlist_t sl;
597   int found = 0;
598
599   addrspec = mailbox_from_userid (userid);
600   if (!addrspec)
601     {
602       log_error (_("\"%s\" is not a proper mail address\n"), userid);
603       err = gpg_error (GPG_ERR_INV_USER_ID);
604       goto leave;
605     }
606
607   /* Get the submission address.  */
608   err = wkd_get_key (addrspec, &key);
609   switch (gpg_err_code (err))
610     {
611     case 0:
612       if (opt.verbose)
613         log_info ("public key for '%s' found via WKD\n", addrspec);
614       /* Fixme: Check that the key contains the user id.  */
615       break;
616
617     case GPG_ERR_NO_DATA: /* No such key.  */
618       if (opt.verbose)
619         log_info ("public key for '%s' NOT found via WKD\n", addrspec);
620       err = gpg_error (GPG_ERR_NO_PUBKEY);
621       log_inc_errorcount ();
622       break;
623
624     case GPG_ERR_UNKNOWN_HOST:
625       if (opt.verbose)
626         log_info ("error looking up '%s' via WKD: %s\n",
627                   addrspec, gpg_strerror (err));
628       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
629       break;
630
631     default:
632       log_error ("error looking up '%s' via WKD: %s\n",
633                  addrspec, gpg_strerror (err));
634       break;
635     }
636
637   if (err)
638     goto leave;
639
640   /* Look closer at the key.  */
641   err = wks_list_key (key, &fpr, &mboxes);
642   if (err || !fpr)
643     {
644       log_error ("error parsing key: %s\n",
645                  err? gpg_strerror (err) : "no fingerprint found");
646       err = gpg_error (GPG_ERR_NO_PUBKEY);
647       goto leave;
648     }
649
650   if (opt.verbose)
651     log_info ("fingerprint: %s\n", fpr);
652
653   for (sl = mboxes; sl; sl = sl->next)
654     {
655       if (!strcmp (sl->d, addrspec))
656         found = 1;
657       if (opt.verbose)
658         log_info ("  addr-spec: %s\n", sl->d);
659     }
660   if (!found)
661     {
662       log_error ("public key for '%s' has no user id with the mail address\n",
663                  addrspec);
664       err = gpg_error (GPG_ERR_CERT_REVOKED);
665     }
666
667  leave:
668   xfree (fpr);
669   free_strlist (mboxes);
670   es_fclose (key);
671   xfree (addrspec);
672   return err;
673 }
674
675
676 \f
677 /* Locate the key by fingerprint and userid and send a publication
678  * request.  */
679 static gpg_error_t
680 command_send (const char *fingerprint, char *userid)
681 {
682   gpg_error_t err;
683   KEYDB_SEARCH_DESC desc;
684   char *addrspec = NULL;
685   estream_t key = NULL;
686   estream_t keyenc = NULL;
687   char *submission_to = NULL;
688   mime_maker_t mime = NULL;
689   struct policy_flags_s policy;
690
691   memset (&policy, 0, sizeof policy);
692
693   if (classify_user_id (fingerprint, &desc, 1)
694       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
695            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
696     {
697       log_error (_("\"%s\" is not a fingerprint\n"), fingerprint);
698       err = gpg_error (GPG_ERR_INV_NAME);
699       goto leave;
700     }
701   addrspec = mailbox_from_userid (userid);
702   if (!addrspec)
703     {
704       log_error (_("\"%s\" is not a proper mail address\n"), userid);
705       err = gpg_error (GPG_ERR_INV_USER_ID);
706       goto leave;
707     }
708   err = get_key (&key, fingerprint, addrspec);
709   if (err)
710     goto leave;
711
712   /* Get the submission address.  */
713   if (fake_submission_addr)
714     {
715       submission_to = xstrdup (fake_submission_addr);
716       err = 0;
717     }
718   else
719     err = wkd_get_submission_address (addrspec, &submission_to);
720   if (err)
721     {
722       char *domain = strchr (addrspec, '@');
723       if (domain)
724         domain = domain + 1;
725       log_error (_("looking up WKS submission address for %s: %s\n"),
726                  domain ? domain : addrspec, gpg_strerror (err));
727       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
728         log_error (_("this domain probably doesn't support WKS.\n"));
729       goto leave;
730     }
731   log_info ("submitting request to '%s'\n", submission_to);
732
733   /* Get the policy flags.  */
734   if (!fake_submission_addr)
735     {
736       estream_t mbuf;
737
738       err = wkd_get_policy_flags (addrspec, &mbuf);
739       if (err && gpg_err_code (err) != GPG_ERR_NO_DATA)
740         {
741           log_error ("error reading policy flags for '%s': %s\n",
742                      submission_to, gpg_strerror (err));
743           goto leave;
744         }
745       if (mbuf)
746         {
747           err = wks_parse_policy (&policy, mbuf, 1);
748           es_fclose (mbuf);
749           if (err)
750             goto leave;
751         }
752     }
753
754   if (policy.auth_submit)
755     log_info ("no confirmation required for '%s'\n", addrspec);
756
757   /* Encrypt the key part.  */
758   es_rewind (key);
759   err = encrypt_response (&keyenc, key, submission_to, fingerprint);
760   if (err)
761     goto leave;
762   es_fclose (key);
763   key = NULL;
764
765
766   /* Send the key.  */
767   err = mime_maker_new (&mime, NULL);
768   if (err)
769     goto leave;
770   err = mime_maker_add_header (mime, "From", addrspec);
771   if (err)
772     goto leave;
773   err = mime_maker_add_header (mime, "To", submission_to);
774   if (err)
775     goto leave;
776   err = mime_maker_add_header (mime, "Subject", "Key publishing request");
777   if (err)
778     goto leave;
779
780   /* Tell server which draft we support.  */
781   err = mime_maker_add_header (mime, "Wks-Draft-Version",
782                                STR2(WKS_DRAFT_VERSION));
783   if (err)
784     goto leave;
785
786   err = mime_maker_add_header (mime, "Content-Type",
787                                "multipart/encrypted; "
788                                "protocol=\"application/pgp-encrypted\"");
789   if (err)
790     goto leave;
791   err = mime_maker_add_container (mime);
792   if (err)
793     goto leave;
794
795   err = mime_maker_add_header (mime, "Content-Type",
796                                "application/pgp-encrypted");
797   if (err)
798     goto leave;
799   err = mime_maker_add_body (mime, "Version: 1\n");
800   if (err)
801     goto leave;
802   err = mime_maker_add_header (mime, "Content-Type",
803                                "application/octet-stream");
804   if (err)
805     goto leave;
806
807   err = mime_maker_add_stream (mime, &keyenc);
808   if (err)
809     goto leave;
810
811   err = wks_send_mime (mime);
812
813  leave:
814   mime_maker_release (mime);
815   xfree (submission_to);
816   es_fclose (keyenc);
817   es_fclose (key);
818   xfree (addrspec);
819   return err;
820 }
821
822
823 \f
824 static void
825 encrypt_response_status_cb (void *opaque, const char *keyword, char *args)
826 {
827   gpg_error_t *failure = opaque;
828   char *fields[2];
829
830   if (DBG_CRYPTO)
831     log_debug ("gpg status: %s %s\n", keyword, args);
832
833   if (!strcmp (keyword, "FAILURE"))
834     {
835       if (split_fields (args, fields, DIM (fields)) >= 2
836           && !strcmp (fields[0], "encrypt"))
837         *failure = strtoul (fields[1], NULL, 10);
838     }
839
840 }
841
842
843 /* Encrypt the INPUT stream to a new stream which is stored at success
844  * at R_OUTPUT.  Encryption is done for ADDRSPEC and for FINGERPRINT
845  * (so that the sent message may later be inspected by the user).  We
846  * currently retrieve that key from the WKD, DANE, or from "local".
847  * "local" is last to prefer the latest key version but use a local
848  * copy in case we are working offline.  It might be useful for the
849  * server to send the fingerprint of its encryption key - or even the
850  * entire key back.  */
851 static gpg_error_t
852 encrypt_response (estream_t *r_output, estream_t input, const char *addrspec,
853                   const char *fingerprint)
854 {
855   gpg_error_t err;
856   ccparray_t ccp;
857   const char **argv;
858   estream_t output;
859   gpg_error_t gpg_err = 0;
860
861   *r_output = NULL;
862
863   output = es_fopenmem (0, "w+b");
864   if (!output)
865     {
866       err = gpg_error_from_syserror ();
867       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
868       return err;
869     }
870
871   ccparray_init (&ccp, 0);
872
873   ccparray_put (&ccp, "--no-options");
874   if (!opt.verbose)
875     ccparray_put (&ccp, "--quiet");
876   else if (opt.verbose > 1)
877     ccparray_put (&ccp, "--verbose");
878   ccparray_put (&ccp, "--batch");
879   ccparray_put (&ccp, "--status-fd=2");
880   ccparray_put (&ccp, "--always-trust");
881   ccparray_put (&ccp, "--armor");
882   if (fake_submission_addr)
883     ccparray_put (&ccp, "--auto-key-locate=clear,local");
884   else
885     ccparray_put (&ccp, "--auto-key-locate=clear,wkd,dane,local");
886   ccparray_put (&ccp, "--recipient");
887   ccparray_put (&ccp, addrspec);
888   ccparray_put (&ccp, "--recipient");
889   ccparray_put (&ccp, fingerprint);
890   ccparray_put (&ccp, "--encrypt");
891   ccparray_put (&ccp, "--");
892
893   ccparray_put (&ccp, NULL);
894   argv = ccparray_get (&ccp, NULL);
895   if (!argv)
896     {
897       err = gpg_error_from_syserror ();
898       goto leave;
899     }
900   err = gnupg_exec_tool_stream (opt.gpg_program, argv, input,
901                                 NULL, output,
902                                 encrypt_response_status_cb, &gpg_err);
903   if (err)
904     {
905       if (gpg_err)
906         err = gpg_err;
907       log_error ("encryption failed: %s\n", gpg_strerror (err));
908       goto leave;
909     }
910
911   es_rewind (output);
912   *r_output = output;
913   output = NULL;
914
915  leave:
916   es_fclose (output);
917   xfree (argv);
918   return err;
919 }
920
921
922 static gpg_error_t
923 send_confirmation_response (const char *sender, const char *address,
924                             const char *nonce, int encrypt,
925                             const char *fingerprint)
926 {
927   gpg_error_t err;
928   estream_t body = NULL;
929   estream_t bodyenc = NULL;
930   mime_maker_t mime = NULL;
931
932   body = es_fopenmem (0, "w+b");
933   if (!body)
934     {
935       err = gpg_error_from_syserror ();
936       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
937       return err;
938     }
939
940   /* It is fine to use 8 bit encoding because that is encrypted and
941    * only our client will see it.  */
942   if (encrypt)
943     {
944       es_fputs ("Content-Type: application/vnd.gnupg.wks\n"
945                 "Content-Transfer-Encoding: 8bit\n"
946                 "\n",
947                 body);
948     }
949
950   es_fprintf (body, ("type: confirmation-response\n"
951                      "sender: %s\n"
952                      "address: %s\n"
953                      "nonce: %s\n"),
954               sender,
955               address,
956               nonce);
957
958   es_rewind (body);
959   if (encrypt)
960     {
961       err = encrypt_response (&bodyenc, body, sender, fingerprint);
962       if (err)
963         goto leave;
964       es_fclose (body);
965       body = NULL;
966     }
967
968   err = mime_maker_new (&mime, NULL);
969   if (err)
970     goto leave;
971   err = mime_maker_add_header (mime, "From", address);
972   if (err)
973     goto leave;
974   err = mime_maker_add_header (mime, "To", sender);
975   if (err)
976     goto leave;
977   err = mime_maker_add_header (mime, "Subject", "Key publication confirmation");
978   if (err)
979     goto leave;
980   err = mime_maker_add_header (mime, "Wks-Draft-Version",
981                                STR2(WKS_DRAFT_VERSION));
982   if (err)
983     goto leave;
984
985   if (encrypt)
986     {
987       err = mime_maker_add_header (mime, "Content-Type",
988                                    "multipart/encrypted; "
989                                    "protocol=\"application/pgp-encrypted\"");
990       if (err)
991         goto leave;
992       err = mime_maker_add_container (mime);
993       if (err)
994         goto leave;
995
996       err = mime_maker_add_header (mime, "Content-Type",
997                                    "application/pgp-encrypted");
998       if (err)
999         goto leave;
1000       err = mime_maker_add_body (mime, "Version: 1\n");
1001       if (err)
1002         goto leave;
1003       err = mime_maker_add_header (mime, "Content-Type",
1004                                    "application/octet-stream");
1005       if (err)
1006         goto leave;
1007
1008       err = mime_maker_add_stream (mime, &bodyenc);
1009       if (err)
1010         goto leave;
1011     }
1012   else
1013     {
1014       err = mime_maker_add_header (mime, "Content-Type",
1015                                    "application/vnd.gnupg.wks");
1016       if (err)
1017         goto leave;
1018       err = mime_maker_add_stream (mime, &body);
1019       if (err)
1020         goto leave;
1021     }
1022
1023   err = wks_send_mime (mime);
1024
1025  leave:
1026   mime_maker_release (mime);
1027   es_fclose (bodyenc);
1028   es_fclose (body);
1029   return err;
1030 }
1031
1032
1033 /* Reply to a confirmation request.  The MSG has already been
1034  * decrypted and we only need to send the nonce back.  MAINFPR is
1035  * either NULL or the primary key fingerprint of the key used to
1036  * decrypt the request.  */
1037 static gpg_error_t
1038 process_confirmation_request (estream_t msg, const char *mainfpr)
1039 {
1040   gpg_error_t err;
1041   nvc_t nvc;
1042   nve_t item;
1043   const char *value, *sender, *address, *fingerprint, *nonce;
1044
1045   err = nvc_parse (&nvc, NULL, msg);
1046   if (err)
1047     {
1048       log_error ("parsing the WKS message failed: %s\n", gpg_strerror (err));
1049       goto leave;
1050     }
1051
1052   if (DBG_MIME)
1053     {
1054       log_debug ("request follows:\n");
1055       nvc_write (nvc, log_get_stream ());
1056     }
1057
1058   /* Check that this is a confirmation request.  */
1059   if (!((item = nvc_lookup (nvc, "type:")) && (value = nve_value (item))
1060         && !strcmp (value, "confirmation-request")))
1061     {
1062       if (item && value)
1063         log_error ("received unexpected wks message '%s'\n", value);
1064       else
1065         log_error ("received invalid wks message: %s\n", "'type' missing");
1066       err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
1067       goto leave;
1068     }
1069
1070   /* Get the fingerprint.  */
1071   if (!((item = nvc_lookup (nvc, "fingerprint:"))
1072         && (value = nve_value (item))
1073         && strlen (value) >= 40))
1074     {
1075       log_error ("received invalid wks message: %s\n",
1076                  "'fingerprint' missing or invalid");
1077       err = gpg_error (GPG_ERR_INV_DATA);
1078       goto leave;
1079     }
1080   fingerprint = value;
1081
1082   /* Check that the fingerprint matches the key used to decrypt the
1083    * message.  In --read mode or with the old format we don't have the
1084    * decryption key; thus we can't bail out.  */
1085   if (!mainfpr || ascii_strcasecmp (mainfpr, fingerprint))
1086     {
1087       log_info ("target fingerprint: %s\n", fingerprint);
1088       log_info ("but decrypted with: %s\n", mainfpr);
1089       log_error ("confirmation request not decrypted with target key\n");
1090       if (mainfpr)
1091         {
1092           err = gpg_error (GPG_ERR_INV_DATA);
1093           goto leave;
1094         }
1095     }
1096
1097   /* Get the address.  */
1098   if (!((item = nvc_lookup (nvc, "address:")) && (value = nve_value (item))
1099         && is_valid_mailbox (value)))
1100     {
1101       log_error ("received invalid wks message: %s\n",
1102                  "'address' missing or invalid");
1103       err = gpg_error (GPG_ERR_INV_DATA);
1104       goto leave;
1105     }
1106   address = value;
1107   /* FIXME: Check that the "address" matches the User ID we want to
1108    * publish.  */
1109
1110   /* Get the sender.  */
1111   if (!((item = nvc_lookup (nvc, "sender:")) && (value = nve_value (item))
1112         && is_valid_mailbox (value)))
1113     {
1114       log_error ("received invalid wks message: %s\n",
1115                  "'sender' missing or invalid");
1116       err = gpg_error (GPG_ERR_INV_DATA);
1117       goto leave;
1118     }
1119   sender = value;
1120   /* FIXME: Check that the "sender" matches the From: address.  */
1121
1122   /* Get the nonce.  */
1123   if (!((item = nvc_lookup (nvc, "nonce:")) && (value = nve_value (item))
1124         && strlen (value) > 16))
1125     {
1126       log_error ("received invalid wks message: %s\n",
1127                  "'nonce' missing or too short");
1128       err = gpg_error (GPG_ERR_INV_DATA);
1129       goto leave;
1130     }
1131   nonce = value;
1132
1133   /* Send the confirmation.  If no key was found, try again without
1134    * encryption.  */
1135   err = send_confirmation_response (sender, address, nonce, 1, fingerprint);
1136   if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
1137     {
1138       log_info ("no encryption key found - sending response in the clear\n");
1139       err = send_confirmation_response (sender, address, nonce, 0, NULL);
1140     }
1141
1142  leave:
1143   nvc_release (nvc);
1144   return err;
1145 }
1146
1147
1148 /* Read a confirmation request and decrypt it if needed.  This
1149  * function may not be used with a mail or MIME message but only with
1150  * the actual encrypted or plaintext WKS data.  */
1151 static gpg_error_t
1152 read_confirmation_request (estream_t msg)
1153 {
1154   gpg_error_t err;
1155   int c;
1156   estream_t plaintext = NULL;
1157
1158   /* We take a really simple approach to check whether MSG is
1159    * encrypted: We know that an encrypted message is always armored
1160    * and thus starts with a few dashes.  It is even sufficient to
1161    * check for a single dash, because that can never be a proper first
1162    * WKS data octet.  We need to skip leading spaces, though. */
1163   while ((c = es_fgetc (msg)) == ' ' || c == '\t' || c == '\r' || c == '\n')
1164     ;
1165   if (c == EOF)
1166     {
1167       log_error ("can't process an empty message\n");
1168       return gpg_error (GPG_ERR_INV_DATA);
1169     }
1170   if (es_ungetc (c, msg) != c)
1171     {
1172       log_error ("error ungetting octet from message\n");
1173       return gpg_error (GPG_ERR_INTERNAL);
1174     }
1175
1176   if (c != '-')
1177     err = process_confirmation_request (msg, NULL);
1178   else
1179     {
1180       struct decrypt_stream_parm_s decinfo;
1181
1182       err = decrypt_stream (&plaintext, &decinfo, msg);
1183       if (err)
1184         log_error ("decryption failed: %s\n", gpg_strerror (err));
1185       else if (decinfo.otrust != 'u')
1186         {
1187           err = gpg_error (GPG_ERR_WRONG_SECKEY);
1188           log_error ("key used to decrypt the confirmation request"
1189                      " was not generated by us\n");
1190         }
1191       else
1192         err = process_confirmation_request (plaintext, decinfo.mainfpr);
1193       xfree (decinfo.fpr);
1194       xfree (decinfo.mainfpr);
1195     }
1196
1197   es_fclose (plaintext);
1198   return err;
1199 }
1200
1201
1202 /* Called from the MIME receiver to process the plain text data in MSG.  */
1203 static gpg_error_t
1204 command_receive_cb (void *opaque, const char *mediatype,
1205                     estream_t msg, unsigned int flags)
1206 {
1207   gpg_error_t err;
1208
1209   (void)opaque;
1210   (void)flags;
1211
1212   if (!strcmp (mediatype, "application/vnd.gnupg.wks"))
1213     err = read_confirmation_request (msg);
1214   else
1215     {
1216       log_info ("ignoring unexpected message of type '%s'\n", mediatype);
1217       err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
1218     }
1219
1220   return err;
1221 }